1 /** 2 * Copyright (C) 2016 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.cellbroadcastreceiver.unit; 18 19 import static org.junit.Assert.assertEquals; 20 import static org.mockito.Matchers.anyInt; 21 import static org.mockito.Matchers.anyString; 22 import static org.mockito.Mockito.doReturn; 23 import static org.mockito.Mockito.eq; 24 import static org.mockito.Mockito.spy; 25 import static org.mockito.Mockito.times; 26 import static org.mockito.Mockito.verify; 27 28 import android.content.Context; 29 import android.content.ContextWrapper; 30 import android.content.SharedPreferences; 31 import android.telephony.SmsCbMessage; 32 import android.telephony.SubscriptionManager; 33 import android.telephony.TelephonyManager; 34 import android.test.suitebuilder.annotation.SmallTest; 35 36 import com.android.cellbroadcastreceiver.CellBroadcastChannelManager.CellBroadcastChannelRange; 37 import com.android.cellbroadcastreceiver.CellBroadcastConfigService; 38 import com.android.cellbroadcastreceiver.CellBroadcastSettings; 39 import com.android.cellbroadcastreceiver.unit.CellBroadcastTest; 40 import com.android.internal.telephony.ISms; 41 import com.android.internal.telephony.cdma.sms.SmsEnvelope; 42 import com.android.internal.telephony.gsm.SmsCbConstants; 43 44 import org.junit.After; 45 import org.junit.Before; 46 import org.junit.Test; 47 import org.mockito.ArgumentCaptor; 48 import org.mockito.Mock; 49 50 import java.lang.reflect.Method; 51 import java.util.ArrayList; 52 import java.util.List; 53 54 /** 55 * Cell broadcast config service tests 56 */ 57 public class CellBroadcastConfigServiceTest extends CellBroadcastTest { 58 59 @Mock 60 ISms.Stub mMockedSmsService; 61 62 @Mock 63 SharedPreferences mMockedSharedPreferences; 64 65 private CellBroadcastConfigService mConfigService; 66 67 @Before setUp()68 public void setUp() throws Exception { 69 super.setUp(getClass().getSimpleName()); 70 mConfigService = spy(new CellBroadcastConfigService()); 71 TelephonyManager.disableServiceHandleCaching(); 72 73 Class[] cArgs = new Class[1]; 74 cArgs[0] = Context.class; 75 76 Method method = ContextWrapper.class.getDeclaredMethod("attachBaseContext", cArgs); 77 method.setAccessible(true); 78 method.invoke(mConfigService, mContext); 79 80 doReturn(mMockedSharedPreferences).when(mContext) 81 .getSharedPreferences(anyString(), anyInt()); 82 83 mMockedServiceManager.replaceService("isms", mMockedSmsService); 84 doReturn(mMockedSmsService).when(mMockedSmsService).queryLocalInterface(anyString()); 85 86 putResources(com.android.cellbroadcastreceiver.R.array 87 .cmas_presidential_alerts_channels_range_strings, new String[]{ 88 "0x1112-0x1112:rat=gsm", 89 "0x1000-0x1000:rat=cdma", 90 "0x111F-0x111F:rat=gsm", 91 }); 92 putResources(com.android.cellbroadcastreceiver.R.array 93 .cmas_alert_extreme_channels_range_strings, new String[]{ 94 "0x1113-0x1114:rat=gsm", 95 "0x1001-0x1001:rat=cdma", 96 "0x1120-0x1121:rat=gsm", 97 }); 98 putResources(com.android.cellbroadcastreceiver.R.array 99 .cmas_alerts_severe_range_strings, new String[]{ 100 "0x1115-0x111A:rat=gsm", 101 "0x1002-0x1002:rat=cdma", 102 "0x1122-0x1127:rat=gsm", 103 }); 104 putResources(com.android.cellbroadcastreceiver.R.array 105 .required_monthly_test_range_strings, new String[]{ 106 "0x111C-0x111C:rat=gsm", 107 "0x1004-0x1004:rat=cdma", 108 "0x1129-0x1129:rat=gsm", 109 }); 110 putResources(com.android.cellbroadcastreceiver.R.array 111 .exercise_alert_range_strings, new String[]{ 112 "0x111D-0x111D:rat=gsm", 113 "0x112A-0x112A:rat=gsm", 114 }); 115 putResources(com.android.cellbroadcastreceiver.R.array 116 .operator_defined_alert_range_strings, new String[]{ 117 "0x111E-0x111E:rat=gsm", 118 "0x112B-0x112B:rat=gsm", 119 }); 120 putResources(com.android.cellbroadcastreceiver.R.array 121 .etws_alerts_range_strings, new String[]{ 122 "0x1100-0x1102:rat=gsm", 123 "0x1104-0x1104:rat=gsm", 124 }); 125 putResources(com.android.cellbroadcastreceiver.R.array 126 .etws_test_alerts_range_strings, new String[]{ 127 "0x1103-0x1103:rat=gsm", 128 }); 129 putResources(com.android.cellbroadcastreceiver.R.array 130 .cmas_amber_alerts_channels_range_strings, new String[]{ 131 "0x111B-0x111B:rat=gsm", 132 "0x1003-0x1003:rat=cdma", 133 "0x1128-0x1128:rat=gsm", 134 }); 135 } 136 137 @After tearDown()138 public void tearDown() throws Exception { 139 super.tearDown(); 140 TelephonyManager.enableServiceHandleCaching(); 141 } 142 setCellBroadcastRange(int subId, boolean enable, List<CellBroadcastChannelRange> ranges)143 private void setCellBroadcastRange(int subId, boolean enable, 144 List<CellBroadcastChannelRange> ranges) 145 throws Exception { 146 147 Class[] cArgs = new Class[3]; 148 cArgs[0] = Integer.TYPE; 149 cArgs[1] = Boolean.TYPE; 150 cArgs[2] = List.class; 151 152 Method method = 153 CellBroadcastConfigService.class.getDeclaredMethod("setCellBroadcastRange", cArgs); 154 method.setAccessible(true); 155 156 method.invoke(mConfigService, subId, enable, ranges); 157 } 158 159 /** 160 * Test enable cell broadcast range 161 */ 162 @Test 163 @SmallTest testEnableCellBroadcastRange()164 public void testEnableCellBroadcastRange() throws Exception { 165 ArrayList<CellBroadcastChannelRange> result = new ArrayList<>(); 166 result.add(new CellBroadcastChannelRange(mContext, 167 SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, "10-20")); 168 setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, true, result); 169 ArgumentCaptor<Integer> captorStart = ArgumentCaptor.forClass(Integer.class); 170 ArgumentCaptor<Integer> captorEnd = ArgumentCaptor.forClass(Integer.class); 171 ArgumentCaptor<Integer> captorType = ArgumentCaptor.forClass(Integer.class); 172 173 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber(anyInt(), 174 captorStart.capture(), captorEnd.capture(), captorType.capture()); 175 176 assertEquals(10, captorStart.getValue().intValue()); 177 assertEquals(20, captorEnd.getValue().intValue()); 178 assertEquals(1, captorType.getValue().intValue()); 179 } 180 181 /** 182 * Test disable cell broadcast range 183 */ 184 @Test 185 @SmallTest testDisableCellBroadcastRange()186 public void testDisableCellBroadcastRange() throws Exception { 187 ArrayList<CellBroadcastChannelRange> result = new ArrayList<>(); 188 result.add(new CellBroadcastChannelRange(mContext, 189 SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, "10-20")); 190 setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, false, result); 191 ArgumentCaptor<Integer> captorStart = ArgumentCaptor.forClass(Integer.class); 192 ArgumentCaptor<Integer> captorEnd = ArgumentCaptor.forClass(Integer.class); 193 ArgumentCaptor<Integer> captorType = ArgumentCaptor.forClass(Integer.class); 194 195 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber(anyInt(), 196 captorStart.capture(), captorEnd.capture(), captorType.capture()); 197 198 assertEquals(10, captorStart.getValue().intValue()); 199 assertEquals(20, captorEnd.getValue().intValue()); 200 assertEquals(1, captorType.getValue().intValue()); 201 } 202 setPreference(String pref, boolean value)203 private void setPreference(String pref, boolean value) { 204 doReturn(value).when(mMockedSharedPreferences).getBoolean(eq(pref), eq(true)); 205 } 206 207 /** 208 * Test enabling channels for default countries (US) 209 */ 210 @Test 211 @SmallTest testEnablingChannelsDefault()212 public void testEnablingChannelsDefault() throws Exception { 213 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); 214 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true); 215 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true); 216 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true); 217 218 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 219 220 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 221 eq(0), 222 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), 223 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), 224 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 225 226 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 227 eq(0), 228 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), 229 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), 230 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 231 232 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 233 eq(0), 234 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), 235 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), 236 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 237 238 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 239 eq(0), 240 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), 241 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), 242 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 243 244 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 245 eq(0), 246 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE), 247 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE), 248 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 249 250 251 // GSM 252 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 253 eq(0), 254 eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING), 255 eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING), 256 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 257 258 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 259 eq(0), 260 eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), 261 eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), 262 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 263 264 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 265 eq(0), 266 eq(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE), 267 eq(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE), 268 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 269 270 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 271 eq(0), 272 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), 273 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), 274 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 275 276 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 277 eq(0), 278 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED), 279 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY), 280 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 281 282 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 283 eq(0), 284 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED), 285 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY), 286 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 287 288 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 289 eq(0), 290 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), 291 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), 292 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 293 294 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 295 eq(0), 296 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST), 297 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST), 298 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 299 } 300 301 /** 302 * Test enabling channels for Presidential alert 303 */ 304 @Test 305 @SmallTest testEnablingPresidential()306 public void testEnablingPresidential() throws Exception { 307 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); 308 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 309 310 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 311 eq(0), 312 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), 313 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), 314 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 315 316 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 317 eq(0), 318 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), 319 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), 320 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 321 322 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 323 eq(0), 324 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), 325 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), 326 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 327 328 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, false); 329 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 330 331 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 332 eq(0), 333 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), 334 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), 335 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 336 337 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 338 eq(0), 339 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), 340 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), 341 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 342 343 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 344 eq(0), 345 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), 346 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), 347 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 348 349 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); 350 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 351 352 verify(mMockedSmsService, times(3)).enableCellBroadcastRangeForSubscriber( 353 eq(0), 354 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), 355 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), 356 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 357 358 verify(mMockedSmsService, times(3)).enableCellBroadcastRangeForSubscriber( 359 eq(0), 360 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), 361 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), 362 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 363 364 verify(mMockedSmsService, times(3)).enableCellBroadcastRangeForSubscriber( 365 eq(0), 366 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), 367 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), 368 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 369 370 } 371 372 /** 373 * Test enabling channels for extreme alert 374 */ 375 @Test 376 @SmallTest testEnablingExtreme()377 public void testEnablingExtreme() throws Exception { 378 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); 379 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true); 380 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 381 382 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 383 eq(0), 384 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), 385 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), 386 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 387 388 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 389 eq(0), 390 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED), 391 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY), 392 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 393 394 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 395 eq(0), 396 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED_LANGUAGE), 397 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY_LANGUAGE), 398 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 399 400 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, false); 401 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 402 403 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 404 eq(0), 405 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), 406 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), 407 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 408 409 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 410 eq(0), 411 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED), 412 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY), 413 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 414 415 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 416 eq(0), 417 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED_LANGUAGE), 418 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY_LANGUAGE), 419 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 420 421 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true); 422 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 423 424 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 425 eq(0), 426 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), 427 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), 428 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 429 430 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 431 eq(0), 432 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED), 433 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY), 434 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 435 436 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 437 eq(0), 438 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED_LANGUAGE), 439 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY_LANGUAGE), 440 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 441 442 } 443 444 /** 445 * Test enabling channels for severe alert 446 */ 447 @Test 448 @SmallTest testEnablingSevere()449 public void testEnablingSevere() throws Exception { 450 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); 451 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true); 452 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 453 454 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 455 eq(0), 456 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), 457 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), 458 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 459 460 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 461 eq(0), 462 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED), 463 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY), 464 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 465 466 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 467 eq(0), 468 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED_LANGUAGE), 469 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY_LANGUAGE), 470 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 471 472 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, false); 473 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 474 475 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 476 eq(0), 477 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), 478 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), 479 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 480 481 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 482 eq(0), 483 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED), 484 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY), 485 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 486 487 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 488 eq(0), 489 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED_LANGUAGE), 490 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY_LANGUAGE), 491 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 492 493 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true); 494 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 495 496 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 497 eq(0), 498 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), 499 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), 500 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 501 502 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 503 eq(0), 504 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED), 505 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY), 506 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 507 508 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 509 eq(0), 510 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED_LANGUAGE), 511 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY_LANGUAGE), 512 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 513 } 514 515 /** 516 * Test enabling channels for amber alert 517 */ 518 @Test 519 @SmallTest testEnablingAmber()520 public void testEnablingAmber() throws Exception { 521 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); 522 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true); 523 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 524 525 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 526 eq(0), 527 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), 528 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), 529 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 530 531 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 532 eq(0), 533 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), 534 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), 535 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 536 537 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 538 eq(0), 539 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), 540 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), 541 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 542 543 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, false); 544 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 545 546 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 547 eq(0), 548 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), 549 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), 550 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 551 552 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 553 eq(0), 554 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), 555 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), 556 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 557 558 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 559 eq(0), 560 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), 561 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), 562 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 563 564 setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true); 565 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 566 567 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 568 eq(0), 569 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), 570 eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), 571 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); 572 573 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 574 eq(0), 575 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), 576 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), 577 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 578 579 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 580 eq(0), 581 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), 582 eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), 583 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 584 } 585 586 /** 587 * Test enabling channels for ETWS alert 588 */ 589 @Test 590 @SmallTest testEnablingETWS()591 public void testEnablingETWS() throws Exception { 592 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); 593 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 594 595 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 596 eq(0), 597 eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING), 598 eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING), 599 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 600 601 verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( 602 eq(0), 603 eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), 604 eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), 605 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 606 607 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, false); 608 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 609 610 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 611 eq(0), 612 eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING), 613 eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING), 614 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 615 616 verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( 617 eq(0), 618 eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), 619 eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), 620 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 621 622 setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); 623 mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); 624 625 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 626 eq(0), 627 eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING), 628 eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING), 629 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 630 631 verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( 632 eq(0), 633 eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), 634 eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), 635 eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); 636 } 637 } 638