1 /* 2 * Copyright (C) 2020 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.services.telephony.rcs; 18 19 import static com.android.services.telephony.rcs.DelegateStateTracker.SUPPORT_REGISTERING_DELEGATE_STATE; 20 21 import static org.junit.Assert.assertEquals; 22 import static org.mockito.ArgumentMatchers.any; 23 import static org.mockito.ArgumentMatchers.anyInt; 24 import static org.mockito.ArgumentMatchers.eq; 25 import static org.mockito.Mockito.never; 26 import static org.mockito.Mockito.times; 27 import static org.mockito.Mockito.verify; 28 29 import android.app.compat.CompatChanges; 30 import android.net.InetAddresses; 31 import android.os.Binder; 32 import android.telephony.ims.DelegateRegistrationState; 33 import android.telephony.ims.FeatureTagState; 34 import android.telephony.ims.SipDelegateConfiguration; 35 import android.telephony.ims.SipDelegateManager; 36 import android.telephony.ims.aidl.ISipDelegate; 37 import android.telephony.ims.aidl.ISipDelegateConnectionStateCallback; 38 import android.util.ArraySet; 39 40 import androidx.test.ext.junit.runners.AndroidJUnit4; 41 import androidx.test.filters.SmallTest; 42 43 import com.android.TelephonyTestBase; 44 import com.android.internal.telephony.metrics.RcsStats; 45 46 import org.junit.After; 47 import org.junit.Before; 48 import org.junit.Test; 49 import org.junit.runner.RunWith; 50 import org.mockito.ArgumentCaptor; 51 import org.mockito.Mock; 52 53 import java.net.InetSocketAddress; 54 import java.util.ArrayList; 55 import java.util.List; 56 import java.util.Set; 57 58 @RunWith(AndroidJUnit4.class) 59 public class DelegateStateTrackerTest extends TelephonyTestBase { 60 private static final int TEST_SUB_ID = 1; 61 62 @Mock private ISipDelegate mSipDelegate; 63 @Mock private ISipDelegateConnectionStateCallback mAppCallback; 64 @Mock private RcsStats mRcsStats; 65 66 @Before setUp()67 public void setUp() throws Exception { 68 super.setUp(); 69 } 70 71 @After tearDown()72 public void tearDown() throws Exception { 73 super.tearDown(); 74 } 75 76 /** 77 * When an underlying SipDelegate is created, the app should only receive one onCreated callback 78 * independent of how many times sipDelegateConnected is called. Once created, registration 79 * and IMS configuration events should propagate up to the app as well. 80 */ 81 @SmallTest 82 @Test testDelegateCreated()83 public void testDelegateCreated() throws Exception { 84 DelegateStateTracker stateTracker = new DelegateStateTracker(TEST_SUB_ID, 85 Binder.getCallingUid(), mAppCallback, mSipDelegate, mRcsStats); 86 Set<FeatureTagState> deniedTags = getMmTelDeniedTag(); 87 Set<String> supportedTags = getSupportedTags(); 88 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 89 // Calling connected multiple times should not generate multiple onCreated events. 90 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 91 verify(mAppCallback).onCreated(mSipDelegate); 92 verify(mRcsStats).createSipDelegateStats(TEST_SUB_ID, supportedTags); 93 94 // Ensure status updates are sent to app as expected. 95 DelegateRegistrationState regState = new DelegateRegistrationState.Builder() 96 .addRegisteredFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG) 97 .build(); 98 InetSocketAddress localAddr = new InetSocketAddress( 99 InetAddresses.parseNumericAddress("1.1.1.1"), 80); 100 InetSocketAddress serverAddr = new InetSocketAddress( 101 InetAddresses.parseNumericAddress("2.2.2.2"), 81); 102 SipDelegateConfiguration c = new SipDelegateConfiguration.Builder(1, 103 SipDelegateConfiguration.SIP_TRANSPORT_TCP, localAddr, serverAddr).build(); 104 stateTracker.onRegistrationStateChanged(regState); 105 stateTracker.onConfigurationChanged(c); 106 verify(mAppCallback).onFeatureTagStatusChanged(eq(regState), 107 eq(new ArrayList<>(deniedTags))); 108 verify(mRcsStats).onSipTransportFeatureTagStats(TEST_SUB_ID, deniedTags, 109 regState.getDeregisteredFeatureTags(), 110 regState.getRegisteredFeatureTags()); 111 verify(mAppCallback).onConfigurationChanged(c); 112 verify(mAppCallback, never()).onDestroyed(anyInt()); 113 } 114 115 /** 116 * onDestroyed should be called when sipDelegateDestroyed is called. 117 */ 118 @SmallTest 119 @Test testDelegateDestroyed()120 public void testDelegateDestroyed() throws Exception { 121 DelegateStateTracker stateTracker = new DelegateStateTracker(TEST_SUB_ID, 122 Binder.getCallingUid(), mAppCallback, mSipDelegate, mRcsStats); 123 Set<FeatureTagState> deniedTags = getMmTelDeniedTag(); 124 Set<String> supportedTags = getSupportedTags(); 125 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 126 verify(mRcsStats).createSipDelegateStats(eq(TEST_SUB_ID), eq(supportedTags)); 127 128 stateTracker.sipDelegateDestroyed( 129 SipDelegateManager.SIP_DELEGATE_DESTROY_REASON_REQUESTED_BY_APP); 130 verify(mAppCallback).onDestroyed( 131 SipDelegateManager.SIP_DELEGATE_DESTROY_REASON_REQUESTED_BY_APP); 132 verify(mRcsStats).onSipDelegateStats(eq(TEST_SUB_ID), eq(supportedTags), 133 eq(SipDelegateManager.SIP_DELEGATE_DESTROY_REASON_REQUESTED_BY_APP)); 134 } 135 136 /** 137 * When a SipDelegate is created and then an event occurs that will destroy->create a new 138 * SipDelegate underneath, we need to move the state of the features that are reporting 139 * registered to DEREGISTERING_REASON_FEATURE_TAGS_CHANGING so that the app can close dialogs on 140 * it. Once the new underlying SipDelegate is created, we must verify that the new registration 141 * is propagated up without any overrides. 142 */ 143 @SmallTest 144 @Test testDelegateChangingRegisteredTagsOverride()145 public void testDelegateChangingRegisteredTagsOverride() throws Exception { 146 DelegateStateTracker stateTracker = new DelegateStateTracker(TEST_SUB_ID, 147 Binder.getCallingUid(), mAppCallback, mSipDelegate, mRcsStats); 148 Set<FeatureTagState> deniedTags = getMmTelDeniedTag(); 149 Set<String> supportedTags = getSupportedTags(); 150 Set<String> registeringTags = getRegisteringTag(); 151 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 152 153 // SipDelegate created 154 verify(mAppCallback).onCreated(mSipDelegate); 155 156 DelegateRegistrationState regState = new DelegateRegistrationState.Builder() 157 .addRegisteredFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG) 158 .addRegisteringFeatureTags(registeringTags) 159 .addDeregisteringFeatureTag(ImsSignallingUtils.FILE_TRANSFER_HTTP_TAG, 160 DelegateRegistrationState.DEREGISTERING_REASON_PROVISIONING_CHANGE) 161 .addDeregisteredFeatureTag(ImsSignallingUtils.GROUP_CHAT_TAG, 162 DelegateRegistrationState.DEREGISTERED_REASON_NOT_PROVISIONED) 163 .build(); 164 165 stateTracker.onRegistrationStateChanged(regState); 166 // Simulate underlying SipDelegate switch 167 stateTracker.sipDelegateChanging( 168 DelegateRegistrationState.DEREGISTERING_REASON_FEATURE_TAGS_CHANGING); 169 // onFeatureTagStatusChanged should now be called with registered features overridden with 170 // DEREGISTERING_REASON_FEATURE_TAGS_CHANGING 171 DelegateRegistrationState.Builder overrideBuilder = 172 new DelegateRegistrationState.Builder() 173 .addDeregisteringFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG, 174 DelegateRegistrationState.DEREGISTERING_REASON_FEATURE_TAGS_CHANGING) 175 // Already Deregistering/Deregistered tags should not be overridden. 176 .addDeregisteringFeatureTag(ImsSignallingUtils.FILE_TRANSFER_HTTP_TAG, 177 DelegateRegistrationState.DEREGISTERING_REASON_PROVISIONING_CHANGE) 178 .addDeregisteredFeatureTag(ImsSignallingUtils.GROUP_CHAT_TAG, 179 DelegateRegistrationState.DEREGISTERED_REASON_NOT_PROVISIONED); 180 if (CompatChanges.isChangeEnabled(SUPPORT_REGISTERING_DELEGATE_STATE, 181 Binder.getCallingUid())) { 182 for (String tag : registeringTags) { 183 overrideBuilder.addDeregisteringFeatureTag(tag, 184 DelegateRegistrationState.DEREGISTERING_REASON_FEATURE_TAGS_CHANGING); 185 } 186 } else { 187 for (String tag : registeringTags) { 188 overrideBuilder.addDeregisteredFeatureTag(tag, 189 DelegateRegistrationState.DEREGISTERED_REASON_NOT_REGISTERED); 190 } 191 } 192 193 DelegateRegistrationState overrideRegState = overrideBuilder.build(); 194 195 // new underlying SipDelegate created 196 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 197 stateTracker.onRegistrationStateChanged(regState); 198 199 DelegateRegistrationState.Builder builder = new DelegateRegistrationState.Builder() 200 .addRegisteredFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG) 201 .addDeregisteringFeatureTag(ImsSignallingUtils.FILE_TRANSFER_HTTP_TAG, 202 DelegateRegistrationState.DEREGISTERING_REASON_PROVISIONING_CHANGE) 203 .addDeregisteredFeatureTag(ImsSignallingUtils.GROUP_CHAT_TAG, 204 DelegateRegistrationState.DEREGISTERED_REASON_NOT_PROVISIONED); 205 if (CompatChanges.isChangeEnabled(SUPPORT_REGISTERING_DELEGATE_STATE, 206 Binder.getCallingUid())) { 207 builder.addRegisteringFeatureTags(registeringTags); 208 } else { 209 for (String tag : registeringTags) { 210 builder.addDeregisteredFeatureTag(tag, 211 DelegateRegistrationState.DEREGISTERED_REASON_NOT_REGISTERED); 212 } 213 } 214 DelegateRegistrationState regStateResult = builder.build(); 215 // Verify registration state through the process: 216 ArgumentCaptor<DelegateRegistrationState> regCaptor = 217 ArgumentCaptor.forClass(DelegateRegistrationState.class); 218 verify(mAppCallback, times(3)).onFeatureTagStatusChanged( 219 regCaptor.capture(), eq(new ArrayList<>(deniedTags))); 220 List<DelegateRegistrationState> testStates = regCaptor.getAllValues(); 221 // feature tags should first be registered 222 assertEquals(regStateResult, testStates.get(0)); 223 // registered feature tags should have moved to deregistering 224 assertEquals(overrideRegState, testStates.get(1)); 225 // and then moved back to registered after underlying FT change done. 226 assertEquals(regStateResult, testStates.get(2)); 227 228 //onCreate should only have been called once and onDestroy should have never been called. 229 verify(mAppCallback).onCreated(mSipDelegate); 230 verify(mAppCallback, never()).onDestroyed(anyInt()); 231 } 232 233 /** 234 * When registration states are changed in a case that an application doesn't support the new 235 * 'registering' state the 'registering' state will be moved to the 'registered' state 236 * as the old behavior. 237 * 238 * This method tests the case where the application doesn't support consuming the 239 * DEREGISTERING_REASON_LOSING_PDN reason. 240 */ 241 @Test testDelegateChangingRegisteredTagsRegisteringDisable()242 public void testDelegateChangingRegisteredTagsRegisteringDisable() throws Exception { 243 DelegateStateTracker stateTracker = new DelegateStateTracker(TEST_SUB_ID, 244 Binder.getCallingUid(), mAppCallback, mSipDelegate, mRcsStats); 245 stateTracker.setCompatChangesFactory((changeId, uid) -> false); 246 Set<FeatureTagState> deniedTags = getMmTelDeniedTag(); 247 Set<String> supportedTags = getSupportedTags(); 248 Set<String> registeringTags = getRegisteringTag(); 249 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 250 // SipDelegate created 251 verify(mAppCallback).onCreated(mSipDelegate); 252 DelegateRegistrationState regState = new DelegateRegistrationState.Builder() 253 .addRegisteredFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG) 254 .addRegisteringFeatureTags(registeringTags) 255 .addDeregisteringFeatureTag(ImsSignallingUtils.FILE_TRANSFER_HTTP_TAG, 256 DelegateRegistrationState.DEREGISTERING_REASON_LOSING_PDN) 257 .addDeregisteredFeatureTag(ImsSignallingUtils.GROUP_CHAT_TAG, 258 DelegateRegistrationState.DEREGISTERED_REASON_NOT_PROVISIONED) 259 .build(); 260 stateTracker.onRegistrationStateChanged(regState); 261 262 DelegateRegistrationState.Builder builder = new DelegateRegistrationState.Builder() 263 .addRegisteredFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG) 264 .addDeregisteringFeatureTag(ImsSignallingUtils.FILE_TRANSFER_HTTP_TAG, 265 DelegateRegistrationState.DEREGISTERING_REASON_PDN_CHANGE) 266 .addDeregisteredFeatureTag(ImsSignallingUtils.GROUP_CHAT_TAG, 267 DelegateRegistrationState.DEREGISTERED_REASON_NOT_PROVISIONED); 268 for (String tag : registeringTags) { 269 builder.addDeregisteredFeatureTag(tag, 270 DelegateRegistrationState.DEREGISTERED_REASON_NOT_REGISTERED); 271 } 272 DelegateRegistrationState overrideRegState = builder.build(); 273 274 275 // Verify registration state through the process: 276 ArgumentCaptor<DelegateRegistrationState> regCaptor = 277 ArgumentCaptor.forClass(DelegateRegistrationState.class); 278 verify(mAppCallback, times(1)).onFeatureTagStatusChanged( 279 regCaptor.capture(), eq(new ArrayList<>(deniedTags))); 280 List<DelegateRegistrationState> testStates = regCaptor.getAllValues(); 281 282 assertEquals(overrideRegState, testStates.get(0)); 283 verify(mAppCallback).onCreated(mSipDelegate); 284 } 285 286 /** 287 * When registration states are changed in a case that an application supports the new 288 * 'registering' state the state will be kept. 289 * 290 * This method tests the case where the application supports consuming the 291 * DEREGISTERING_REASON_LOSING_PDN reason. 292 */ 293 @Test testDelegateChangingRegisteredTagsRegisteringEnable()294 public void testDelegateChangingRegisteredTagsRegisteringEnable() throws Exception { 295 DelegateStateTracker stateTracker = new DelegateStateTracker(TEST_SUB_ID, 296 Binder.getCallingUid(), mAppCallback, mSipDelegate, mRcsStats); 297 stateTracker.setCompatChangesFactory((changeId, uid) -> true); 298 Set<FeatureTagState> deniedTags = getMmTelDeniedTag(); 299 Set<String> supportedTags = getSupportedTags(); 300 Set<String> registeringTags = getRegisteringTag(); 301 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 302 // SipDelegate created 303 verify(mAppCallback).onCreated(mSipDelegate); 304 305 DelegateRegistrationState regState = new DelegateRegistrationState.Builder() 306 .addRegisteredFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG) 307 .addRegisteringFeatureTags(registeringTags) 308 .addDeregisteringFeatureTag(ImsSignallingUtils.FILE_TRANSFER_HTTP_TAG, 309 DelegateRegistrationState.DEREGISTERING_REASON_LOSING_PDN) 310 .addDeregisteredFeatureTag(ImsSignallingUtils.GROUP_CHAT_TAG, 311 DelegateRegistrationState.DEREGISTERED_REASON_NOT_PROVISIONED) 312 .build(); 313 stateTracker.onRegistrationStateChanged(regState); 314 315 // Verify registration state through the process: 316 ArgumentCaptor<DelegateRegistrationState> regCaptor = 317 ArgumentCaptor.forClass(DelegateRegistrationState.class); 318 verify(mAppCallback, times(1)).onFeatureTagStatusChanged( 319 regCaptor.capture(), eq(new ArrayList<>(deniedTags))); 320 List<DelegateRegistrationState> testStates = regCaptor.getAllValues(); 321 322 assertEquals(regState, testStates.get(0)); 323 verify(mAppCallback).onCreated(mSipDelegate); 324 } 325 326 327 /** 328 * Test the case that when the underlying Denied tags change in the SipDelegate, the change is 329 * properly shown in the registration update event. 330 */ 331 @SmallTest 332 @Test testDelegateChangingDeniedTagsChanged()333 public void testDelegateChangingDeniedTagsChanged() throws Exception { 334 DelegateStateTracker stateTracker = new DelegateStateTracker(TEST_SUB_ID, 335 Binder.getCallingUid(), mAppCallback, mSipDelegate, mRcsStats); 336 Set<FeatureTagState> deniedTags = getMmTelDeniedTag(); 337 Set<String> supportedTags = getSupportedTags(); 338 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 339 // SipDelegate created 340 verify(mAppCallback).onCreated(mSipDelegate); 341 DelegateRegistrationState regState = new DelegateRegistrationState.Builder() 342 .addRegisteredFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG) 343 .build(); 344 stateTracker.onRegistrationStateChanged(regState); 345 // Simulate underlying SipDelegate switch 346 stateTracker.sipDelegateChanging( 347 DelegateRegistrationState.DEREGISTERING_REASON_FEATURE_TAGS_CHANGING); 348 // onFeatureTagStatusChanged should now be called with registered features overridden with 349 // DEREGISTERING_REASON_FEATURE_TAGS_CHANGING 350 DelegateRegistrationState overrideRegState = new DelegateRegistrationState.Builder() 351 .addDeregisteringFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG, 352 DelegateRegistrationState.DEREGISTERING_REASON_FEATURE_TAGS_CHANGING) 353 .build(); 354 // Verify registration state so far. 355 ArgumentCaptor<DelegateRegistrationState> regCaptor = 356 ArgumentCaptor.forClass(DelegateRegistrationState.class); 357 verify(mAppCallback, times(2)).onFeatureTagStatusChanged( 358 regCaptor.capture(), eq(new ArrayList<>(deniedTags))); 359 List<DelegateRegistrationState> testStates = regCaptor.getAllValues(); 360 assertEquals(2, testStates.size()); 361 // feature tags should first be registered 362 assertEquals(regState, testStates.get(0)); 363 // registered feature tags should have moved to deregistering 364 assertEquals(overrideRegState, testStates.get(1)); 365 366 // new underlying SipDelegate created, but SipDelegate denied one to one chat 367 deniedTags.add(new FeatureTagState(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG, 368 SipDelegateManager.DENIED_REASON_NOT_ALLOWED)); 369 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 370 DelegateRegistrationState fullyDeniedRegState = new DelegateRegistrationState.Builder() 371 .build(); 372 // In this special case, it will be the SipDelegateConnectionBase that will trigger 373 // reg state change. 374 stateTracker.onRegistrationStateChanged(fullyDeniedRegState); 375 verify(mAppCallback).onFeatureTagStatusChanged(regCaptor.capture(), 376 eq(new ArrayList<>(deniedTags))); 377 // now all feature tags denied, so we should see only denied tags. 378 assertEquals(fullyDeniedRegState, regCaptor.getValue()); 379 380 //onCreate should only have been called once and onDestroy should have never been called. 381 verify(mAppCallback).onCreated(mSipDelegate); 382 verify(mAppCallback, never()).onDestroyed(anyInt()); 383 } 384 385 /** 386 * Test that when we move from changing tags state to the delegate being destroyed, we get the 387 * correct onDestroy event sent to the app. 388 */ 389 @SmallTest 390 @Test testDelegateChangingDeniedTagsChangingToDestroy()391 public void testDelegateChangingDeniedTagsChangingToDestroy() throws Exception { 392 DelegateStateTracker stateTracker = new DelegateStateTracker(TEST_SUB_ID, 393 Binder.getCallingUid(), mAppCallback, mSipDelegate, mRcsStats); 394 Set<FeatureTagState> deniedTags = getMmTelDeniedTag(); 395 Set<String> supportedTags = getSupportedTags(); 396 stateTracker.sipDelegateConnected(supportedTags, deniedTags); 397 // SipDelegate created 398 verify(mAppCallback).onCreated(mSipDelegate); 399 DelegateRegistrationState regState = new DelegateRegistrationState.Builder() 400 .addRegisteredFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG) 401 .addDeregisteredFeatureTag(ImsSignallingUtils.GROUP_CHAT_TAG, 402 DelegateRegistrationState.DEREGISTERED_REASON_NOT_PROVISIONED) 403 .build(); 404 stateTracker.onRegistrationStateChanged(regState); 405 verify(mAppCallback).onFeatureTagStatusChanged(any(), 406 eq(new ArrayList<>(deniedTags))); 407 // Simulate underlying SipDelegate switch 408 stateTracker.sipDelegateChanging( 409 DelegateRegistrationState.DEREGISTERING_REASON_DESTROY_PENDING); 410 // Destroy 411 stateTracker.sipDelegateDestroyed( 412 SipDelegateManager.SIP_DELEGATE_DESTROY_REASON_REQUESTED_BY_APP); 413 414 // onFeatureTagStatusChanged should now be called with registered features overridden with 415 // DEREGISTERING_REASON_DESTROY_PENDING 416 DelegateRegistrationState overrideRegState = new DelegateRegistrationState.Builder() 417 .addDeregisteringFeatureTag(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG, 418 DelegateRegistrationState.DEREGISTERING_REASON_DESTROY_PENDING) 419 // Deregistered should stay the same. 420 .addDeregisteredFeatureTag(ImsSignallingUtils.GROUP_CHAT_TAG, 421 DelegateRegistrationState.DEREGISTERED_REASON_NOT_PROVISIONED) 422 .build(); 423 // Verify registration state through process: 424 ArgumentCaptor<DelegateRegistrationState> regCaptor = 425 ArgumentCaptor.forClass(DelegateRegistrationState.class); 426 verify(mAppCallback, times(2)).onFeatureTagStatusChanged(regCaptor.capture(), 427 eq(new ArrayList<>(deniedTags))); 428 List<DelegateRegistrationState> testStates = regCaptor.getAllValues(); 429 assertEquals(2, testStates.size()); 430 // feature tags should first be registered 431 assertEquals(regState, testStates.get(0)); 432 // registered feature tags should have moved to deregistering 433 assertEquals(overrideRegState, testStates.get(1)); 434 //onCreate/onDestroy should only be called once. 435 verify(mAppCallback).onCreated(mSipDelegate); 436 verify(mAppCallback).onDestroyed( 437 SipDelegateManager.SIP_DELEGATE_DESTROY_REASON_REQUESTED_BY_APP); 438 } 439 getMmTelDeniedTag()440 private Set<FeatureTagState> getMmTelDeniedTag() { 441 Set<FeatureTagState> deniedTags = new ArraySet<>(); 442 deniedTags.add(new FeatureTagState(ImsSignallingUtils.MMTEL_TAG, 443 SipDelegateManager.DENIED_REASON_NOT_ALLOWED)); 444 return deniedTags; 445 } 446 getSupportedTags()447 private Set<String> getSupportedTags() { 448 Set<String> supportedTags = new ArraySet<>(); 449 supportedTags.add(ImsSignallingUtils.ONE_TO_ONE_CHAT_TAG); 450 supportedTags.add(ImsSignallingUtils.GROUP_CHAT_TAG); 451 return supportedTags; 452 } 453 getRegisteringTag()454 private Set<String> getRegisteringTag() { 455 Set<String> registeringTags = new ArraySet<>(); 456 registeringTags.add(ImsSignallingUtils.CHATBOT_COMMUNICATION_USING_SESSION_TAG); 457 return registeringTags; 458 459 } 460 } 461