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