diff options
Diffstat (limited to 'tests')
13 files changed, 1722 insertions, 817 deletions
diff --git a/tests/compliancetests/AndroidManifest.xml b/tests/compliancetests/AndroidManifest.xml index 2b42acf36..b9edb6207 100644 --- a/tests/compliancetests/AndroidManifest.xml +++ b/tests/compliancetests/AndroidManifest.xml @@ -18,6 +18,8 @@ package="com.android.cellbroadcastreceiver.tests.compliancetests"> <uses-permission android:name="android.permission.READ_CELL_BROADCASTS" /> + <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" /> + <uses-permission android:name="android.permission.CHANGE_CONFIGURATION" /> <application> <uses-library android:name="android.test.runner" /> diff --git a/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastBaseTest.java b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastBaseTest.java new file mode 100644 index 000000000..74395e31a --- /dev/null +++ b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastBaseTest.java @@ -0,0 +1,332 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.cellbroadcastreceiver.compliancetests; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assume.assumeTrue; + +import android.app.Instrumentation; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.PackageManager; +import android.os.Build; +import android.os.SystemProperties; +import android.support.test.uiautomator.UiDevice; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import android.telephony.mockmodem.IRadioMessagingImpl; +import android.telephony.mockmodem.MockModemConfigBase.SimInfoChangedResult; +import android.telephony.mockmodem.MockModemManager; +import android.telephony.mockmodem.MockSimService; +import android.util.Log; + +import androidx.test.platform.app.InstrumentationRegistry; + +import com.android.internal.telephony.CellBroadcastUtils; +import com.android.modules.utils.build.SdkLevel; + +import org.json.JSONObject; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Rule; +import org.junit.rules.TestName; + +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; + + +public class CellBroadcastBaseTest { + private static final String TAG = "CellBroadcastBaseTest"; + protected static MockModemManager sMockModemManager; + protected static int sSlotId = 0; + protected static JSONObject sCarriersObject; + protected static JSONObject sChannelsObject; + protected static JSONObject sSettingsObject; + protected static int sPreconditionError = 0; + protected static final int ERROR_SDK_VERSION = 1; + protected static final int ERROR_NO_TELEPHONY = 2; + protected static final int ERROR_MULTI_SIM = 3; + protected static final int ERROR_MOCK_MODEM_DISABLE = 4; + + protected static final String ALLOW_MOCK_MODEM_PROPERTY = "persist.radio.allow_mock_modem"; + protected static final boolean DEBUG = !"user".equals(Build.TYPE); + + protected static final String EXPECTED_RESULT_CHANNELS_JSON = "emergency_alert_channels.json"; + protected static final String CARRIER_LISTS_JSON = "region_plmn_list.json"; + protected static final String EXPECTED_RESULT_SETTINGS_JSON = "emergency_alert_settings.json"; + protected static final String CARRIER_MCCMNC_FIELD = "mccmnc"; + protected static final String CHANNEL_DEFAULT_VALUE_FIELD = "default_value"; + + protected static final String ACTION_SET_CHANNELS_DONE = + "android.cellbroadcast.compliancetest.SET_CHANNELS_DONE"; + protected static CountDownLatch sSetChannelIsDone = new CountDownLatch(1); + protected static String sInputMccMnc = null; + protected static BroadcastReceiver sReceiver = null; + + protected static final int MAX_WAIT_TIME = 15 * 1000; + + protected static Instrumentation sInstrumentation = null; + protected static UiDevice sDevice = null; + protected static String sPackageName = null; + + protected static IRadioMessagingImpl.CallBackWithExecutor sCallBackWithExecutor = null; + + protected static Context getContext() { + return InstrumentationRegistry.getInstrumentation().getContext(); + } + + private static class BroadcastChannelListener + implements IRadioMessagingImpl.BroadcastCallback { + @Override + public void onGsmBroadcastActivated() { + TelephonyManager tm = getContext().getSystemService(TelephonyManager.class); + logd("onGsmBroadcastActivated, mccmnc = " + tm.getSimOperator()); + if (sInputMccMnc != null && sInputMccMnc.equals(tm.getSimOperator())) { + sSetChannelIsDone.countDown(); + logd("wait is released"); + } + } + + @Override + public void onCdmaBroadcastActivated() { + } + } + + @BeforeClass + public static void beforeAllTests() throws Exception { + logd("CellBroadcastBaseTest#beforeAllTests()"); + if (!SdkLevel.isAtLeastT()) { + Log.i(TAG, "sdk level is below T"); + sPreconditionError = ERROR_SDK_VERSION; + return; + } + + final PackageManager pm = getContext().getPackageManager(); + boolean hasTelephonyFeature = pm.hasSystemFeature(PackageManager.FEATURE_TELEPHONY); + if (!hasTelephonyFeature) { + Log.i(TAG, "Not have Telephony Feature"); + sPreconditionError = ERROR_NO_TELEPHONY; + return; + } + + TelephonyManager tm = + (TelephonyManager) getContext().getSystemService(Context.TELEPHONY_SERVICE); + boolean isMultiSim = tm != null && tm.getPhoneCount() > 1; + if (isMultiSim) { + Log.i(TAG, "Not support Multi-Sim"); + sPreconditionError = ERROR_MULTI_SIM; + return; + } + + if (!isMockModemAllowed()) { + Log.i(TAG, "Mock Modem is not allowed"); + sPreconditionError = ERROR_MOCK_MODEM_DISABLE; + return; + } + + if (!SdkLevel.isAtLeastU()) { + sReceiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + if (ACTION_SET_CHANNELS_DONE.equals(action)) { + int subId = intent.getIntExtra("sub_id", -1); + logd("INTENT_SET_CHANNELS_DONE is received, subId=" + subId); + TelephonyManager tm = getContext().getSystemService(TelephonyManager.class) + .createForSubscriptionId(subId); + if (tm != null) { + String mccMncOfIntent = tm.getSimOperator(); + logd("mccMncOfIntent = " + mccMncOfIntent); + if (sInputMccMnc != null && sInputMccMnc.equals(mccMncOfIntent)) { + sSetChannelIsDone.countDown(); + logd("wait is released"); + } + } + } + } + }; + IntentFilter filter = new IntentFilter(); + filter.addAction(ACTION_SET_CHANNELS_DONE); + getContext().registerReceiver(sReceiver, filter, Context.RECEIVER_EXPORTED); + } + + sMockModemManager = new MockModemManager(); + assertTrue(sMockModemManager.connectMockModemService( + MockSimService.MOCK_SIM_PROFILE_ID_TWN_CHT)); + sSlotId = SubscriptionManager.getSlotIndex(SubscriptionManager.getDefaultSubscriptionId()); + if (SdkLevel.isAtLeastU()) { + BroadcastChannelListener broadcastCallback = new BroadcastChannelListener(); + sCallBackWithExecutor = new IRadioMessagingImpl.CallBackWithExecutor( + Runnable::run, broadcastCallback); + sMockModemManager.registerBroadcastCallback(sSlotId, sCallBackWithExecutor); + } + waitForNotify(); + + String jsonCarrier = loadJsonFile(CARRIER_LISTS_JSON); + sCarriersObject = new JSONObject(jsonCarrier); + String jsonChannels = loadJsonFile(EXPECTED_RESULT_CHANNELS_JSON); + sChannelsObject = new JSONObject(jsonChannels); + String jsonSettings = loadJsonFile(EXPECTED_RESULT_SETTINGS_JSON); + sSettingsObject = new JSONObject(jsonSettings); + + sInstrumentation = InstrumentationRegistry.getInstrumentation(); + sDevice = UiDevice.getInstance(sInstrumentation); + sPackageName = CellBroadcastUtils + .getDefaultCellBroadcastReceiverPackageName(getContext()); + } + + private static void waitForNotify() { + while (sSetChannelIsDone.getCount() > 0) { + try { + sSetChannelIsDone.await(MAX_WAIT_TIME, TimeUnit.MILLISECONDS); + sSetChannelIsDone.countDown(); + } catch (InterruptedException e) { + // do nothing + } + } + } + + @AfterClass + public static void afterAllTests() throws Exception { + logd("CellBroadcastBaseTest#afterAllTests()"); + + if (sReceiver != null) { + getContext().unregisterReceiver(sReceiver); + } + if (sCallBackWithExecutor != null && sMockModemManager != null) { + sMockModemManager.unregisterBroadcastCallback(sSlotId, sCallBackWithExecutor); + } + if (sMockModemManager != null) { + // Rebind all interfaces which is binding to MockModemService to default. + assertTrue(sMockModemManager.disconnectMockModemService()); + sMockModemManager = null; + } + } + + @Rule + public final TestName mTestNameRule = new TestName(); + @Before + public void beforeTest() throws Exception { + assumeTrue(getErrorMessage(sPreconditionError), sPreconditionError == 0); + } + + protected static String loadJsonFile(String jsonFile) { + String json = null; + try { + InputStream inputStream = getContext().getAssets().open(jsonFile); + int size = inputStream.available(); + byte[] byteArray = new byte[size]; + inputStream.read(byteArray); + inputStream.close(); + json = new String(byteArray, "UTF-8"); + } catch (IOException e) { + e.printStackTrace(); + return null; + } + return json; + } + + protected String[] paramsForTest() throws Throwable { + logd("paramsForTest"); + String jsonCarrier = loadJsonFile(CARRIER_LISTS_JSON); + JSONObject carriersObject = new JSONObject(jsonCarrier); + Iterator<String> carrierList = carriersObject.keys(); + + ArrayList<String> carrierLists = new ArrayList<>(); + for (Iterator<String> it = carrierList; it.hasNext();) { + carrierLists.add(it.next()); + } + return carrierLists.toArray(new String[]{}); + } + + protected Object[] paramsCarrierAndChannelForTest() throws Throwable { + logd("paramsCarrierAndChannelForTest"); + String jsonCarrier = loadJsonFile(CARRIER_LISTS_JSON); + JSONObject carriersObject = new JSONObject(jsonCarrier); + Iterator<String> carrierList = carriersObject.keys(); + + ArrayList<Object> result = new ArrayList<Object>(); + for (Iterator<String> it = carrierList; it.hasNext();) { + String carrierName = it.next(); + String jsonChannels = loadJsonFile(EXPECTED_RESULT_CHANNELS_JSON); + JSONObject channelsObject = new JSONObject(jsonChannels); + JSONObject channelsForCarrier = channelsObject.getJSONObject(carrierName); + for (Iterator<String> iterator = channelsForCarrier.keys(); iterator.hasNext();) { + String channelId = iterator.next(); + result.add(new String[]{carrierName, channelId}); + } + } + return result.toArray(new Object[]{}); + } + + protected void setSimInfo(String carrierName) throws Throwable { + JSONObject carrierObject = sCarriersObject.getJSONObject(carrierName); + String mccMncFromObject = carrierObject.getString(CARRIER_MCCMNC_FIELD); + String mcc = mccMncFromObject.substring(0, 3); + String mnc = mccMncFromObject.substring(3); + sInputMccMnc = mccMncFromObject; + sSetChannelIsDone = new CountDownLatch(1); + + String[] mccMnc = new String[] {mcc, mnc}; + logd("carrierName = " + carrierName + + ", mcc = " + mccMnc[0] + ", mnc = " + mccMnc[1]); + + int slotId = 0; + + boolean isSuccessful = sMockModemManager.setSimInfo(slotId, + SimInfoChangedResult.SIM_INFO_TYPE_MCC_MNC, mccMnc); + assertTrue(isSuccessful); + waitForNotify(); + } + + private static boolean isMockModemAllowed() { + boolean isAllowed = SystemProperties.getBoolean(ALLOW_MOCK_MODEM_PROPERTY, false); + // Check for developer settings for user build. Always allow for debug builds + return isAllowed || DEBUG; + } + + protected String getErrorMessage(int error) { + String errorMessage = "Precondition Error"; + switch (error) { + case ERROR_SDK_VERSION: + errorMessage = "SDK level is below T"; + break; + case ERROR_NO_TELEPHONY: + errorMessage = "Not have Telephony Feature"; + break; + case ERROR_MULTI_SIM: + errorMessage = "Multi-sim is not supported in Mock Modem"; + break; + case ERROR_MOCK_MODEM_DISABLE: + errorMessage = "Please enable mock modem to run the test! The option can be " + + "updated in Settings -> System -> Developer options -> Allow Mock Modem"; + break; + } + return errorMessage; + } + + protected static void logd(String msg) { + if (DEBUG) Log.d(TAG, msg); + } +} diff --git a/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastCarrierTestConfig.java b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastCarrierTestConfig.java new file mode 100644 index 000000000..5f5593c7f --- /dev/null +++ b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastCarrierTestConfig.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.cellbroadcastreceiver.compliancetests; + +import android.text.TextUtils; + +import org.json.JSONException; +import org.json.JSONObject; + +public class CellBroadcastCarrierTestConfig implements ITestConfig { + private static final String CARRIER_MCCMNC_FIELD = "mccmnc"; + private static final String CARRIER_DISABLE_NAVIGATION = "disable_navigation"; + private static final String CARRIER_FULLSCREEN = "fullscreen"; + private static final String CARRIER_LANGUAGE = "language"; + private static final String CARRIER_CHECK_SETTING_MAIN_LANG = "check_setting_with_main_lang"; + + public String mMccMnc; + public boolean mDisableNavigation; + public boolean mNeedFullScreen; + public String mLanguageTag; + public boolean mCheckSettingWithMainLanguage = true; + + public CellBroadcastCarrierTestConfig(JSONObject carriersObject, String carrierName) + throws JSONException { + JSONObject carrierObject = carriersObject.getJSONObject(carrierName); + mMccMnc = carrierObject.getString(CARRIER_MCCMNC_FIELD); + String disableNavigationString = + getObjectString(carrierObject, CARRIER_DISABLE_NAVIGATION); + mDisableNavigation = false; + if (!TextUtils.isEmpty(disableNavigationString) && disableNavigationString.equals("true")) { + mDisableNavigation = true; + } + String fullScreenString = getObjectString(carrierObject, CARRIER_FULLSCREEN); + mNeedFullScreen = false; + if (!TextUtils.isEmpty(fullScreenString) && fullScreenString.equals("true")) { + mNeedFullScreen = true; + } + mLanguageTag = getObjectString(carrierObject, CARRIER_LANGUAGE); + String checkSettingWithMainLanguageTag = getObjectString(carrierObject, + CARRIER_CHECK_SETTING_MAIN_LANG); + if (checkSettingWithMainLanguageTag != null + && checkSettingWithMainLanguageTag.equals("false")) { + mCheckSettingWithMainLanguage = false; + } + } +} diff --git a/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastChannelTestConfig.java b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastChannelTestConfig.java new file mode 100644 index 000000000..289f750ad --- /dev/null +++ b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastChannelTestConfig.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.cellbroadcastreceiver.compliancetests; + +import android.text.TextUtils; + +import org.json.JSONException; +import org.json.JSONObject; + +public class CellBroadcastChannelTestConfig implements ITestConfig { + private static final String CHANNEL_DEFAULT_VALUE_FIELD = "default_value"; + private static final String CHANNEL_TITLE = "title"; + private static final String CHANNEL_FILTER_LANGUAGE = "filter_language"; + private static final String CHANNEL_ALERT_TYPE = "alert_type"; + private static final String CHANNEL_TEST_MODE = "test_mode"; + private static final String CHANNEL_DISPLAY = "display"; + private static final String CHANNEL_WARNING_TYPE = "warning_type"; + + public boolean mChannelDefaultValue = true; + public String mExpectedTitle; + public String mFilteredLanguage; + public boolean mIgnoreMessageByLanguageFilter; + public boolean mFilteredLanguageBySecondLanguagePref; + public boolean mAlertTypeIsNotification; + public boolean mIsEnabledOnTestMode; + public boolean mNeedDisplay = true; + public String mWarningType; + + public CellBroadcastChannelTestConfig(JSONObject channelsObject, + String carrierName, String channel) throws JSONException { + JSONObject channelsForCarrier = channelsObject.getJSONObject(carrierName); + JSONObject object = channelsForCarrier.getJSONObject(channel); + String defaultValue = object.getString(CHANNEL_DEFAULT_VALUE_FIELD); + if (!TextUtils.isEmpty(defaultValue) && defaultValue.equals("false")) { + mChannelDefaultValue = false; + } + mExpectedTitle = object.getString(CHANNEL_TITLE); + mFilteredLanguage = getObjectString(object, CHANNEL_FILTER_LANGUAGE); + mIgnoreMessageByLanguageFilter = false; + if (!TextUtils.isEmpty(mFilteredLanguage) + && mFilteredLanguage.equals("language_setting")) { + mIgnoreMessageByLanguageFilter = true; + } else if (!TextUtils.isEmpty(mFilteredLanguage) + && mFilteredLanguage.equals("second_language_pref")) { + mFilteredLanguageBySecondLanguagePref = true; + } + String alertType = getObjectString(object, CHANNEL_ALERT_TYPE); + mAlertTypeIsNotification = false; + if (!TextUtils.isEmpty(alertType) && alertType.equals("notification")) { + mAlertTypeIsNotification = true; + } + String testModeString = getObjectString(object, CHANNEL_TEST_MODE); + if (!TextUtils.isEmpty(testModeString) && testModeString.equals("true")) { + mIsEnabledOnTestMode = true; + } + String displayString = getObjectString(object, CHANNEL_DISPLAY); + if (!TextUtils.isEmpty(displayString) && displayString.equals("false")) { + mNeedDisplay = false; + } + mWarningType = getObjectString(object, CHANNEL_WARNING_TYPE); + } +} diff --git a/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastConfigTest.java b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastConfigTest.java index 113c2f592..5d3dad99e 100644 --- a/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastConfigTest.java +++ b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastConfigTest.java @@ -17,238 +17,34 @@ package com.android.cellbroadcastreceiver.compliancetests; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.junit.Assume.assumeTrue; -import android.content.BroadcastReceiver; -import android.content.Context; -import android.content.Intent; -import android.content.IntentFilter; -import android.content.pm.PackageManager; -import android.os.Build; -import android.os.SystemProperties; -import android.telephony.TelephonyManager; -import android.telephony.mockmodem.MockModemConfigBase.SimInfoChangedResult; -import android.telephony.mockmodem.MockModemManager; -import android.telephony.mockmodem.MockSimService; import android.text.TextUtils; import android.util.ArraySet; -import android.util.Log; - -import androidx.test.InstrumentationRegistry; - -import com.android.modules.utils.build.SdkLevel; import org.json.JSONException; import org.json.JSONObject; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; -import java.io.IOException; -import java.io.InputStream; -import java.util.ArrayList; import java.util.Iterator; import java.util.Set; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.TimeUnit; import junitparams.JUnitParamsRunner; import junitparams.Parameters; @RunWith(JUnitParamsRunner.class) -public class CellBroadcastConfigTest { +public class CellBroadcastConfigTest extends CellBroadcastBaseTest { private static final String TAG = "CellBroadcastConfigTest"; - private static MockModemManager sMockModemManager; - private static JSONObject sCarriersObject; - private static JSONObject sChannelsObject; - private static int sPreconditionError = 0; - private static final int ERROR_SDK_VERSION = 1; - private static final int ERROR_NO_TELEPHONY = 2; - private static final int ERROR_MULTI_SIM = 3; - private static final int ERROR_MOCK_MODEM_DISABLE = 4; - - private static final String ALLOW_MOCK_MODEM_PROPERTY = "persist.radio.allow_mock_modem"; - private static final boolean DEBUG = !"user".equals(Build.TYPE); - - private static final String EXPECTED_RESULT_CHANNELS_JSON = "emergency_alert_channels.json"; - private static final String CARRIER_LISTS_JSON = "region_plmn_list.json"; - private static final String CARRIER_MCCMNC_FIELD = "mccmnc"; - private static final String CHANNEL_DEFAULT_VALUE_FIELD = "default_value"; - - private static final String ACTION_SET_CHANNELS_DONE = - "android.cellbroadcast.compliancetest.SET_CHANNELS_DONE"; - private static CountDownLatch sSetChannelIsDone = new CountDownLatch(1); - private static String sInputMccMnc = null; - private static BroadcastReceiver sReceiver = null; - - private static final int MAX_WAIT_TIME = 15 * 1000; - - private static Context getContext() { - return InstrumentationRegistry.getInstrumentation().getContext(); - } - - @BeforeClass - public static void beforeAllTests() throws Exception { - logd("CellBroadcastConfigTest#beforeAllTests()"); - if (!SdkLevel.isAtLeastT()) { - Log.i(TAG, "sdk level is below T"); - sPreconditionError = ERROR_SDK_VERSION; - return; - } - - final PackageManager pm = getContext().getPackageManager(); - boolean hasTelephonyFeature = pm.hasSystemFeature(PackageManager.FEATURE_TELEPHONY); - if (!hasTelephonyFeature) { - Log.i(TAG, "Not have Telephony Feature"); - sPreconditionError = ERROR_NO_TELEPHONY; - return; - } - - TelephonyManager tm = - (TelephonyManager) getContext().getSystemService(Context.TELEPHONY_SERVICE); - boolean isMultiSim = tm != null && tm.getPhoneCount() > 1; - if (isMultiSim) { - Log.i(TAG, "Not support Multi-Sim"); - sPreconditionError = ERROR_MULTI_SIM; - return; - } - - if (!isMockModemAllowed()) { - Log.i(TAG, "Mock Modem is not allowed"); - sPreconditionError = ERROR_MOCK_MODEM_DISABLE; - return; - } - - sReceiver = new BroadcastReceiver() { - @Override - public void onReceive(Context context, Intent intent) { - String action = intent.getAction(); - if (ACTION_SET_CHANNELS_DONE.equals(action)) { - int subId = intent.getIntExtra("sub_id", -1); - logd("INTENT_SET_CHANNELS_DONE is received, subId=" + subId); - TelephonyManager tm = getContext().getSystemService(TelephonyManager.class) - .createForSubscriptionId(subId); - if (tm != null) { - String mccMncOfIntent = tm.getSimOperator(); - logd("mccMncOfIntent = " + mccMncOfIntent); - if (sInputMccMnc != null && sInputMccMnc.equals(mccMncOfIntent)) { - sSetChannelIsDone.countDown(); - logd("wait is released"); - } - } - } - } - }; - - IntentFilter filter = new IntentFilter(); - filter.addAction(ACTION_SET_CHANNELS_DONE); - getContext().registerReceiver(sReceiver, filter, Context.RECEIVER_EXPORTED); - - sMockModemManager = new MockModemManager(); - assertTrue(sMockModemManager.connectMockModemService( - MockSimService.MOCK_SIM_PROFILE_ID_TWN_CHT)); - waitForNotify(); - - String jsonCarrier = loadJsonFile(CARRIER_LISTS_JSON); - sCarriersObject = new JSONObject(jsonCarrier); - String jsonChannels = loadJsonFile(EXPECTED_RESULT_CHANNELS_JSON); - sChannelsObject = new JSONObject(jsonChannels); - } - - private static void waitForNotify() { - logd("waitForNotify start"); - while (sSetChannelIsDone.getCount() > 0) { - try { - sSetChannelIsDone.await(MAX_WAIT_TIME, TimeUnit.MILLISECONDS); - sSetChannelIsDone.countDown(); - } catch (InterruptedException e) { - // do nothing - } - } - logd("waitForNotify done"); - } - - @AfterClass - public static void afterAllTests() throws Exception { - logd("CellBroadcastConfigTest#afterAllTests()"); - - if (sReceiver != null) { - getContext().unregisterReceiver(sReceiver); - } - - if (sMockModemManager != null) { - // Rebind all interfaces which is binding to MockModemService to default. - assertTrue(sMockModemManager.disconnectMockModemService()); - sMockModemManager = null; - } - } - - @Before - public void beforeTest() { - logd("CellBroadcastConfigTest#beforeTest()"); - - assumeTrue(getErrorMessage(sPreconditionError), sPreconditionError == 0); - - - } - - private static String loadJsonFile(String jsonFile) { - String json = null; - try { - InputStream inputStream = getContext().getAssets().open(jsonFile); - int size = inputStream.available(); - byte[] byteArray = new byte[size]; - inputStream.read(byteArray); - inputStream.close(); - json = new String(byteArray, "UTF-8"); - } catch (IOException e) { - e.printStackTrace(); - return null; - } - return json; - } - - private String[] paramsForTest() throws Throwable { - logd("paramsForTest"); - String jsonCarrier = loadJsonFile(CARRIER_LISTS_JSON); - JSONObject carriersObject = new JSONObject(jsonCarrier); - Iterator<String> carrierList = carriersObject.keys(); - - ArrayList<String> carrierLists = new ArrayList<>(); - for (Iterator<String> it = carrierList; it.hasNext();) { - carrierLists.add(it.next()); - } - return carrierLists.toArray(new String[]{}); - } @Test @Parameters(method = "paramsForTest") public void testCellBroadcastRange(String carrierName) throws Throwable { logd("CellBroadcastConfigTest#testCellBroadcastRange"); - JSONObject carrierObject = sCarriersObject.getJSONObject(carrierName); - String mccMncFromObject = carrierObject.getString(CARRIER_MCCMNC_FIELD); - String mcc = mccMncFromObject.substring(0, 3); - String mnc = mccMncFromObject.substring(3); - sInputMccMnc = mccMncFromObject; - sSetChannelIsDone = new CountDownLatch(1); - - String[] mccMnc = new String[] {mcc, mnc}; - logd("carrierName = " + carrierName - + ", mcc = " + mccMnc[0] + ", mnc = " + mccMnc[1]); - - int slotId = 0; - - boolean isSuccessful = sMockModemManager.setSimInfo(slotId, - SimInfoChangedResult.SIM_INFO_TYPE_MCC_MNC, mccMnc); - assertTrue(isSuccessful); - waitForNotify(); + setSimInfo(carrierName); logd("Check Broadcast Channel Configs"); - Set<Integer> outputConfigs = sMockModemManager.getGsmBroadcastConfig(); + Set<Integer> outputConfigs = sMockModemManager.getGsmBroadcastConfig(sSlotId); verifyOutput(outputConfigs, carrierName); } @@ -287,34 +83,4 @@ public class CellBroadcastConfigTest { assertEquals("Check Channel Configs for " + carrierName, expectedChannels, outputSet); } - - private static boolean isMockModemAllowed() { - boolean isAllowed = SystemProperties.getBoolean(ALLOW_MOCK_MODEM_PROPERTY, false); - // Check for developer settings for user build. Always allow for debug builds - return isAllowed || DEBUG; - } - - private String getErrorMessage(int error) { - String errorMessage = "Precondition Error"; - switch (error) { - case ERROR_SDK_VERSION: - errorMessage = "SDK level is below T"; - break; - case ERROR_NO_TELEPHONY: - errorMessage = "Not have Telephony Feature"; - break; - case ERROR_MULTI_SIM: - errorMessage = "Multi-sim is not supported in Mock Modem"; - break; - case ERROR_MOCK_MODEM_DISABLE: - errorMessage = "Please enable mock modem to run the test! The option can be " - + "updated in Settings -> System -> Developer options -> Allow Mock Modem"; - break; - } - return errorMessage; - } - - private static void logd(String msg) { - if (DEBUG) Log.d(TAG, msg); - } } diff --git a/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastSettingTestConfig.java b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastSettingTestConfig.java new file mode 100644 index 000000000..97294e05e --- /dev/null +++ b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastSettingTestConfig.java @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.cellbroadcastreceiver.compliancetests; + +import org.json.JSONException; +import org.json.JSONObject; + +public class CellBroadcastSettingTestConfig implements ITestConfig { + private static final String SETTING_TOGGLE_AVAIL = "toggle_avail"; + private static final String SETTING_DEFAULT_VALUE = "default_value"; + private static final String SETTING_SUMMARY = "summary"; + + public boolean mIsToggleAvailability = true; + public boolean mExpectedSwitchValue; + public String mSummary; + + public CellBroadcastSettingTestConfig(JSONObject settingsForCarrier, String settingName) + throws JSONException { + JSONObject object = settingsForCarrier.getJSONObject(settingName); + String toggleAvail = object.getString(SETTING_TOGGLE_AVAIL); + String defaultToggle = object.getString(SETTING_DEFAULT_VALUE); + if (toggleAvail != null && toggleAvail.equals("false")) { + mIsToggleAvailability = false; + } + mExpectedSwitchValue = defaultToggle != null && defaultToggle.equals("true"); + mSummary = getObjectString(object, SETTING_SUMMARY); + } +} diff --git a/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastUiTest.java b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastUiTest.java new file mode 100644 index 000000000..f0d28f709 --- /dev/null +++ b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/CellBroadcastUiTest.java @@ -0,0 +1,410 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.cellbroadcastreceiver.compliancetests; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assume.assumeTrue; + +import android.app.KeyguardManager; +import android.app.LocaleManager; +import android.app.UiAutomation; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageManager; +import android.net.Uri; +import android.os.LocaleList; +import android.provider.Settings; +import android.provider.Telephony; +import android.support.test.uiautomator.By; +import android.support.test.uiautomator.BySelector; +import android.support.test.uiautomator.UiObject; +import android.support.test.uiautomator.UiObject2; +import android.support.test.uiautomator.UiObjectNotFoundException; +import android.support.test.uiautomator.UiScrollable; +import android.support.test.uiautomator.UiSelector; +import android.support.test.uiautomator.Until; +import android.text.TextUtils; +import android.widget.LinearLayout; + +import com.android.internal.util.HexDump; + +import org.json.JSONObject; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.Iterator; + +import junitparams.JUnitParamsRunner; +import junitparams.Parameters; + +@RunWith(JUnitParamsRunner.class) +public class CellBroadcastUiTest extends CellBroadcastBaseTest { + private static final String TAG = "CellBroadcastUiTest"; + private static final int UI_TIMEOUT = 10000; + private static final Uri CONTENT_URI = Uri.parse("content://cellbroadcasts"); + private static final String SELECT_BY_SERIAL_NUMBER = + Telephony.CellBroadcasts.SERIAL_NUMBER + "=?"; + private static int sSerialId = 0; + /** Bitmask for messages of ETWS type (including future extensions). */ + private static final int MESSAGE_ID_ETWS_TYPE_MASK = 0xFFF8; + /** Value for messages of ETWS type after applying {@link #MESSAGE_ID_ETWS_TYPE_MASK}. */ + private static final int MESSAGE_ID_ETWS_TYPE = 0x1100; // 4352 + private static final String CELL_BROADCAST_LIST_ACTIVITY = + "com.android.cellbroadcastreceiver.CellBroadcastSettings"; + private static final BySelector FULL_SCREEN_DIALOG = + By.res("android:id/immersive_cling_title"); + private static final BySelector CLOSE_BUTTON = + By.res("android:id/ok"); + + private boolean mIsOptOutDialogHandled = false; + + @Before + public void beforeTest() throws Exception { + super.beforeTest(); + + if ("testEmergencyAlertSettingsUi".equals(mTestNameRule.getMethodName()) + || "testAlertUiOnReceivedAlert".equals(mTestNameRule.getMethodName())) { + KeyguardManager keyguardManager = getContext().getSystemService(KeyguardManager.class); + assumeTrue("cannot test under secure keyguard", + keyguardManager != null && !keyguardManager.isKeyguardSecure()); + // dismiss keyguard and wait from idle + if (keyguardManager != null && keyguardManager.isKeyguardLocked()) { + dismissKeyGuard(); + } + } + if ("testAlertUiOnReceivedAlert".equals(mTestNameRule.getMethodName())) { + PackageManager pm = getContext().getPackageManager(); + assumeTrue("FULL_ACCESS_CELL_BROADCAST_HISTORY permission " + + "is necessary for this test", pm.checkPermission( + "com.android.cellbroadcastservice.FULL_ACCESS_CELL_BROADCAST_HISTORY", + "com.android.shell") != PackageManager.PERMISSION_DENIED); + } + if ("testEmergencyAlertSettingsUi".equals(mTestNameRule.getMethodName()) + || "testAlertUiOnReceivedAlert".equals(mTestNameRule.getMethodName())) { + sDevice.pressHome(); + } + } + + @After + public void afterTest() { + if (sPreconditionError != 0) { + return; + } + + if ("testAlertUiOnReceivedAlert".equals(mTestNameRule.getMethodName()) + && (sSerialId > 0)) { + deleteMessageWithShellPermissionIdentity(); + + if (!mIsOptOutDialogHandled) { + UiObject2 yesButton = sDevice.wait(Until.findObject(By.text("Yes")), 1000); + if (yesButton != null) { + logd("yesButton click"); + yesButton.click(); + mIsOptOutDialogHandled = true; + } + } + } + + if ("testEmergencyAlertSettingsUi".equals(mTestNameRule.getMethodName()) + || "testAlertUiOnReceivedAlert".equals(mTestNameRule.getMethodName())) { + LocaleManager localeManager = getContext().getSystemService(LocaleManager.class); + localeManager.setApplicationLocales(sPackageName, LocaleList.getEmptyLocaleList()); + } + } + + @Test + @Parameters(method = "paramsCarrierAndChannelForTest") + public void testAlertUiOnReceivedAlert(String carrierName, String channel) throws Throwable { + logd("CellBroadcastUiTest#testAlertUiOnReceivedAlert"); + CellBroadcastCarrierTestConfig carrierInfo = + new CellBroadcastCarrierTestConfig(sCarriersObject, carrierName); + CellBroadcastChannelTestConfig channelInfo = + new CellBroadcastChannelTestConfig(sChannelsObject, carrierName, channel); + // setup mccmnc + if (sInputMccMnc == null || (sInputMccMnc != null + && !sInputMccMnc.equals(carrierInfo.mMccMnc))) { + setSimInfo(carrierName); + } + + // change language of CBR + changeLocale(carrierInfo, sPackageName, true); + + if (!channelInfo.mChannelDefaultValue || TextUtils.isEmpty(channelInfo.mExpectedTitle) + || channelInfo.mFilteredLanguageBySecondLanguagePref + || channelInfo.mIsEnabledOnTestMode + || !channelInfo.mNeedDisplay) { + // let's skip for alerttitle + return; + } + boolean isMessageEnglish = !channelInfo.mIgnoreMessageByLanguageFilter + || (channelInfo.mIgnoreMessageByLanguageFilter && carrierInfo.mLanguageTag != null + && !carrierInfo.mLanguageTag.equals("en")); + + // receive broadcast message + receiveBroadcastMessage(channel, channelInfo.mWarningType, isMessageEnglish); + + logd("carrier " + carrierName + ", expectedTitle = " + + channelInfo.mExpectedTitle + " for channel " + channel + + ", alertTypeIsNotification = " + channelInfo.mAlertTypeIsNotification); + if (channelInfo.mAlertTypeIsNotification) { + verifyNotificationPosted(carrierName, channelInfo.mExpectedTitle, channel, + sPackageName, channelInfo.mIgnoreMessageByLanguageFilter); + } else { + verifyAlertDialogTitle(carrierName, channelInfo.mExpectedTitle, channel, + carrierInfo.mDisableNavigation, carrierInfo.mNeedFullScreen, sPackageName, + channelInfo.mIgnoreMessageByLanguageFilter); + } + } + + public void receiveBroadcastMessage(String channelName, String warningType, + boolean isMessageEnglish) { + int channel = Integer.parseInt(channelName); + String hexChannel = String.format("%04X", channel); + + sSerialId++; + String serialHexString = String.format("%04X", sSerialId); + logd("receiveBroadcastMessage, channel = " + hexChannel + + ", serialIdHexString = " + serialHexString); + + boolean isEtws = (channel & MESSAGE_ID_ETWS_TYPE_MASK) == MESSAGE_ID_ETWS_TYPE; + String langCode = isMessageEnglish ? "01" : "00"; // 01 is english, 00 is german + String etwsWarningType = TextUtils.isEmpty(warningType) ? "00" : warningType; + String pduCode = isEtws ? etwsWarningType : langCode; + String hexString = serialHexString + hexChannel + pduCode + "11D4F29C0E0AB2CB727A08"; + byte[] data = HexDump.hexStringToByteArray(hexString); + + sMockModemManager.newBroadcastSms(sSlotId, data); + } + + private void verifyAlertDialogTitle(String carrier, String title, String channel, + boolean disableNavigation, boolean needsFullScreen, String packageName, + boolean ignoreMessageByLanguageFilter) { + boolean expectedResult = ignoreMessageByLanguageFilter ? false : true; + if (needsFullScreen && !isConfirmedForFullScreenGuide(getContext())) { + checkForFullScreenGuide(); + } + boolean result = false; + String outputTitle = null; + UiObject2 item = sDevice.wait(Until.findObject(By.res(packageName, "alertTitle")), + UI_TIMEOUT); + if (item != null) { + outputTitle = item.getText(); + if (outputTitle != null && outputTitle.startsWith(title)) { + result = true; + } + if (disableNavigation) { + // for certain country like chile, check if system navigation bar is disabled + sDevice.openNotification(); + UiSelector notificationStackScroller = new UiSelector() + .packageName("com.android.systemui") + .resourceId("com.android.systemui:id/notification_stack_scroller"); + UiObject widget = new UiObject(notificationStackScroller); + boolean canOpenNotification = widget.waitForExists(3000); + assertEquals("carrier=" + carrier + ", channel=" + channel + + ", system ui should be disabled. ", canOpenNotification, false); + } + // dismiss dialog + UiObject2 okItem = sDevice.wait(Until.findObject( + By.res(packageName, "dismissButton")), UI_TIMEOUT); + if (okItem != null) { + okItem.click(); + } + } + assertEquals("carrier=" + carrier + ", channel=" + channel + + ", output title=" + outputTitle + + ", expected title=" + title, expectedResult, result); + } + + /** Pulls down notification shade and verifies that message text is found. */ + private void verifyNotificationPosted(String carrier, String title, String channel, + String packageName, boolean ignoreMessageByLanguageFilter) + throws UiObjectNotFoundException { + boolean expectedResult = ignoreMessageByLanguageFilter ? false : true; + + // open notification shade + sDevice.openNotification(); + boolean hasObject = sDevice.wait(Until.hasObject(By.text(title)), UI_TIMEOUT); + if (hasObject) { + dismissNotificationAsNeeded(title, packageName); + } + assertEquals("carrier=" + carrier + ", channel=" + channel + + ", expected title=" + title, expectedResult, hasObject); + } + + private void dismissNotificationAsNeeded(String title, String packageName) + throws UiObjectNotFoundException { + UiSelector notificationStackScroller = new UiSelector() + .packageName("com.android.systemui") + .resourceId("com.android.systemui:id/notification_stack_scroller"); + UiObject object = sDevice.findObject(notificationStackScroller); + UiObject object2 = object.getChild(new UiSelector().textContains(title)); + if (object2 != null) { + object2.click(); + UiObject2 okItem = sDevice.wait(Until.findObject( + By.res(packageName, "dismissButton")), UI_TIMEOUT); + if (okItem != null) { + okItem.click(); + } + } + } + + @Test + @Parameters(method = "paramsForTest") + public void testEmergencyAlertSettingsUi(String carrierName) throws Throwable { + logd("CellBroadcastUiTest#testEmergencyAlertSettingsUi"); + CellBroadcastCarrierTestConfig carrierInfo = + new CellBroadcastCarrierTestConfig(sCarriersObject, carrierName); + // setup mccmnc + if (sInputMccMnc == null || (sInputMccMnc != null + && !sInputMccMnc.equals(carrierInfo.mMccMnc))) { + setSimInfo(carrierName); + } + + // change language of CBR + changeLocale(carrierInfo, sPackageName, false); + + // launch setting activity of CBR + Intent intent = new Intent(Intent.ACTION_MAIN); + intent.setComponent(new ComponentName(sPackageName, CELL_BROADCAST_LIST_ACTIVITY)); + intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + getContext().startActivity(intent); + + UiScrollable listView = new UiScrollable(new UiSelector().resourceId("android:id" + + "/list_container")); + listView.waitForExists(2000); + + // check if there is each setting menu + JSONObject settingsForCarrier = sSettingsObject.getJSONObject(carrierName); + for (Iterator<String> iterator = settingsForCarrier.keys(); iterator.hasNext(); ) { + String settingName = iterator.next(); + CellBroadcastSettingTestConfig settingInfo = + new CellBroadcastSettingTestConfig(settingsForCarrier, settingName); + if (!settingInfo.mIsToggleAvailability) { + continue; + } + UiObject item = null; + try { + item = listView.getChildByText(new UiSelector() + .className(LinearLayout.class.getName()), settingName, true); + } catch (UiObjectNotFoundException e) { + logd("let's scrollforward if it cannot find switch"); + listView.scrollForward(); + try { + item = listView.getChildByText(new UiSelector() + .className(LinearLayout.class.getName()), + settingName, true); + } catch (UiObjectNotFoundException e2) { + assertTrue("carrier=" + carrierName + ", settingName=" + + settingName, false); + } + return; + } + UiObject itemSwitch = null; + try { + itemSwitch = item.getChild(new UiSelector() + .className(android.widget.Switch.class.getName())); + logd("itemSwitch = " + itemSwitch.isChecked()); + } catch (UiObjectNotFoundException e) { + logd("switch not found, let's find again"); + String searchText = settingName; + if (settingInfo.mSummary != null) { + searchText = settingInfo.mSummary; + } else { + // let's scrollforward if it cannot find switch + listView.scrollForward(); + } + item = listView.getChildByText(new UiSelector() + .className(LinearLayout.class.getName()), searchText, true); + itemSwitch = item.getChild(new UiSelector() + .className(android.widget.Switch.class.getName())); + } + assertEquals("carrierName=" + carrierName + ", settingName=" + settingName + + ", expectedSwitchValue=" + settingInfo.mIsToggleAvailability, + settingInfo.mExpectedSwitchValue, itemSwitch.isChecked()); + } + sDevice.pressBack(); + } + + private void dismissKeyGuard() throws Exception { + logd("dismissKeyGuard"); + sDevice.wakeUp(); + sDevice.executeShellCommand("wm dismiss-keyguard"); + } + + private boolean checkForFullScreenGuide() { + logd("checkForFullScreenGuide"); + UiObject2 viewObject = sDevice.wait(Until.findObject(FULL_SCREEN_DIALOG), + UI_TIMEOUT); + if (viewObject != null) { + logd("Found full screen dialog, dismissing."); + UiObject2 okButton = sDevice.wait(Until.findObject(CLOSE_BUTTON), UI_TIMEOUT); + if (okButton != null) { + okButton.click(); + return true; + } else { + logd("Unable to dismiss full screen dialog"); + } + } + return false; + } + + private boolean isConfirmedForFullScreenGuide(Context context) { + logd("isConfirmedForFullScreenGuide"); + String value = null; + boolean isConfirmed = false; + try { + value = Settings.Secure.getString(context.getContentResolver(), + Settings.Secure.IMMERSIVE_MODE_CONFIRMATIONS); + isConfirmed = "confirmed".equals(value); + logd("Loaded isConfirmed = " + isConfirmed); + } catch (Throwable t) { + logd("Error loading confirmations, value=" + value); + } + return isConfirmed; + } + + private void changeLocale(CellBroadcastCarrierTestConfig info, + String packageName, boolean checkAlertUi) { + LocaleManager localeManager = getContext().getSystemService(LocaleManager.class); + if (info.mLanguageTag != null && (checkAlertUi || info.mCheckSettingWithMainLanguage)) { + logd("setApplicationLocales " + info.mLanguageTag); + localeManager.setApplicationLocales(packageName, + LocaleList.forLanguageTags(info.mLanguageTag)); + } else { + logd("setApplicationLocales to default"); + localeManager.setApplicationLocales(packageName, + LocaleList.forLanguageTags("en-US")); + } + } + + private void deleteMessageWithShellPermissionIdentity() { + UiAutomation uiAutomation = sInstrumentation.getUiAutomation(); + uiAutomation.adoptShellPermissionIdentity(); + try { + getContext().getContentResolver().delete(CONTENT_URI, + SELECT_BY_SERIAL_NUMBER, new String[]{String.valueOf(sSerialId)}); + } catch (SecurityException e) { + logd("runWithShellPermissionIdentity exception = " + e); + } finally { + uiAutomation.dropShellPermissionIdentity(); + } + } +} diff --git a/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/ITestConfig.java b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/ITestConfig.java new file mode 100644 index 000000000..d39cbd065 --- /dev/null +++ b/tests/compliancetests/src/com/android/cellbroadcastreceiver/compliancetests/ITestConfig.java @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.cellbroadcastreceiver.compliancetests; + +import org.json.JSONObject; + +public interface ITestConfig { + default String getObjectString(JSONObject object, String tagName) { + String objectString = null; + try { + objectString = object.getString(tagName); + } catch (Exception JSONException) { + } + return objectString; + } +} diff --git a/tests/testapp/src/com/android/cellbroadcastreceiver/tests/GsmSmsCbMessage.java b/tests/testapp/src/com/android/cellbroadcastreceiver/tests/GsmSmsCbMessage.java index 28ceed6a6..8d8180f3b 100644 --- a/tests/testapp/src/com/android/cellbroadcastreceiver/tests/GsmSmsCbMessage.java +++ b/tests/testapp/src/com/android/cellbroadcastreceiver/tests/GsmSmsCbMessage.java @@ -39,6 +39,7 @@ import com.android.cellbroadcastservice.GsmAlphabet; import com.android.cellbroadcastservice.SmsCbHeader; import com.android.cellbroadcastservice.SmsCbHeader.DataCodingScheme; import com.android.internal.telephony.SmsConstants; +import com.android.modules.utils.build.SdkLevel; import java.io.UnsupportedEncodingException; import java.util.ArrayList; @@ -93,12 +94,19 @@ public class GsmSmsCbMessage { public static SmsCbMessage createSmsCbMessage(Context context, SmsCbHeader header, SmsCbLocation location, byte[][] pdus, int slotIndex) throws IllegalArgumentException { - SubscriptionManager sm = (SubscriptionManager) context.getSystemService( - Context.TELEPHONY_SUBSCRIPTION_SERVICE); - int subId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID; - int[] subIds = sm.getSubscriptionIds(slotIndex); - if (subIds != null && subIds.length > 0) { - subId = subIds[0]; + int subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + if (SdkLevel.isAtLeastU()) { + subId = SubscriptionManager.getSubscriptionId(slotIndex); + } else { + SubscriptionManager sm = context.getSystemService(SubscriptionManager.class); + int[] subIds = sm.getSubscriptionIds(slotIndex); + if (subIds != null && subIds.length > 0) { + subId = subIds[0]; + } + } + + if (!SubscriptionManager.isValidSubscriptionId(subId)) { + subId = SubscriptionManager.DEFAULT_SUBSCRIPTION_ID; } long receivedTimeMillis = System.currentTimeMillis(); diff --git a/tests/unit/Android.bp b/tests/unit/Android.bp index 5b165a032..d4ee061fa 100644 --- a/tests/unit/Android.bp +++ b/tests/unit/Android.bp @@ -98,6 +98,9 @@ android_test { defaults: ["CellBroadcastTestCommon"], instrumentation_for: "CellBroadcastAppPlatform", test_suites: ["device-tests"], + data: [ + ":CellBroadcastReceiverUnitTests", + ], } // used to share src with unit test app diff --git a/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastBootupConfigTest.java b/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastBootupConfigTest.java index 59bbbdd4d..77701787d 100644 --- a/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastBootupConfigTest.java +++ b/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastBootupConfigTest.java @@ -36,6 +36,8 @@ import static com.android.internal.telephony.gsm.SmsCbConstants.MESSAGE_ID_ETWS_ import static com.android.internal.telephony.gsm.SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING; import static com.android.internal.telephony.gsm.SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Matchers.anyInt; import static org.mockito.Matchers.anyString; import static org.mockito.Mockito.doReturn; @@ -44,6 +46,7 @@ import static org.mockito.Mockito.verify; import android.content.Intent; import android.os.IBinder; +import android.telephony.CellBroadcastIdRange; import android.telephony.SmsCbMessage; import androidx.test.filters.FlakyTest; @@ -51,6 +54,7 @@ import androidx.test.filters.FlakyTest; import com.android.cellbroadcastreceiver.CellBroadcastConfigService; import com.android.cellbroadcastreceiver.CellBroadcastSettings; import com.android.internal.telephony.ISms; +import com.android.modules.utils.build.SdkLevel; import org.junit.After; import org.junit.Before; @@ -58,6 +62,8 @@ import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.Mock; +import java.util.List; + public class CellBroadcastBootupConfigTest extends CellBroadcastServiceTestCase<CellBroadcastConfigService> { @@ -149,6 +155,8 @@ public class CellBroadcastBootupConfigTest extends for (String key : preferenceKeys) { enablePreference(key); } + doReturn("").when(mMockedSharedPreferences) + .getString(eq("roaming_operator_supported"), any()); Intent intent = new Intent(mContext, CellBroadcastConfigService.class); intent.setAction(CellBroadcastConfigService.ACTION_ENABLE_CHANNELS); @@ -200,14 +208,33 @@ public class CellBroadcastBootupConfigTest extends SmsCbMessage.MESSAGE_FORMAT_3GPP), }; - verify(mSmsService, timeout(10000).times(configs.length)) - .enableCellBroadcastRangeForSubscriber( - anyInt(), mStartIds.capture(), mEndIds.capture(), mTypes.capture()); - - for (int i = 0; i < configs.length; i++) { - assertEquals("i=" + i, configs[i].startId, mStartIds.getAllValues().get(i).intValue()); - assertEquals("i=" + i, configs[i].endId, mEndIds.getAllValues().get(i).intValue()); - assertEquals("i=" + i, configs[i].type, mTypes.getAllValues().get(i).intValue()); + if (SdkLevel.isAtLeastU()) { + ArgumentCaptor<List<CellBroadcastIdRange>> ranges = + ArgumentCaptor.forClass(List.class); + verify(mMockedTelephonyManager, timeout(10000).times(1)) + .setCellBroadcastIdRanges(ranges.capture(), any(), any()); + + for (int i = 0; i < configs.length; i++) { + assertEquals("i=" + i, configs[i].startId, ((CellBroadcastIdRange) + (ranges.getAllValues().get(0).get(i))).getStartId()); + assertEquals("i=" + i, configs[i].endId, ((CellBroadcastIdRange) + (ranges.getAllValues().get(0).get(i))).getEndId()); + assertEquals("i=" + i, configs[i].type, ((CellBroadcastIdRange) + (ranges.getAllValues().get(0).get(i))).getType()); + } + } else { + verify(mSmsService, timeout(10000).times(configs.length)) + .enableCellBroadcastRangeForSubscriber( + anyInt(), mStartIds.capture(), mEndIds.capture(), mTypes.capture()); + + for (int i = 0; i < configs.length; i++) { + assertEquals("i=" + i, configs[i].startId, + mStartIds.getAllValues().get(i).intValue()); + assertEquals("i=" + i, configs[i].endId, + mEndIds.getAllValues().get(i).intValue()); + assertEquals("i=" + i, configs[i].type, + mTypes.getAllValues().get(i).intValue()); + } } } }
\ No newline at end of file diff --git a/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastConfigServiceTest.java b/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastConfigServiceTest.java index ad3eed2a5..5e232188a 100644 --- a/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastConfigServiceTest.java +++ b/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastConfigServiceTest.java @@ -16,10 +16,15 @@ package com.android.cellbroadcastreceiver.unit; +import static com.android.cellbroadcastreceiver.CellBroadcastConfigService.CbConfig; + import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; import static org.mockito.Matchers.any; import static org.mockito.Matchers.anyInt; import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.eq; @@ -33,18 +38,20 @@ import android.content.Context; import android.content.ContextWrapper; import android.content.Intent; import android.content.SharedPreferences; +import android.os.RemoteException; +import android.telephony.CellBroadcastIdRange; import android.telephony.SmsCbMessage; import android.telephony.SubscriptionInfo; import android.telephony.SubscriptionManager; import android.telephony.TelephonyManager; import android.test.suitebuilder.annotation.SmallTest; -import com.android.cellbroadcastreceiver.CellBroadcastChannelManager.CellBroadcastChannelRange; import com.android.cellbroadcastreceiver.CellBroadcastConfigService; import com.android.cellbroadcastreceiver.CellBroadcastSettings; import com.android.internal.telephony.ISms; import com.android.internal.telephony.cdma.sms.SmsEnvelope; import com.android.internal.telephony.gsm.SmsCbConstants; +import com.android.modules.utils.build.SdkLevel; import org.junit.After; import org.junit.Before; @@ -83,6 +90,7 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { super.setUp(getClass().getSimpleName()); mConfigService = spy(new CellBroadcastConfigService()); TelephonyManager.disableServiceHandleCaching(); + doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(anyInt()); Class[] cArgs = new Class[1]; cArgs[0] = Context.class; @@ -168,20 +176,17 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { TelephonyManager.enableServiceHandleCaching(); } - private void setCellBroadcastRange(int subId, boolean isEnableOnly, - boolean enable, List<CellBroadcastChannelRange> ranges) throws Exception { + private void setCellBroadcastRange(int subId, List<CbConfig> ranges) throws Exception { - Class[] cArgs = new Class[4]; + Class[] cArgs = new Class[2]; cArgs[0] = Integer.TYPE; - cArgs[1] = Boolean.TYPE; - cArgs[2] = Boolean.TYPE; - cArgs[3] = List.class; + cArgs[1] = List.class; Method method = CellBroadcastConfigService.class.getDeclaredMethod("setCellBroadcastRange", cArgs); method.setAccessible(true); - method.invoke(mConfigService, subId, isEnableOnly, enable, ranges); + method.invoke(mConfigService, subId, ranges); } /** @@ -190,28 +195,22 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { @Test @SmallTest public void testEnableCellBroadcastRange() throws Exception { - ArrayList<CellBroadcastChannelRange> result = new ArrayList<>(); - result.add(new CellBroadcastChannelRange(mContext, - SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, mResources, "10-20")); - setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, false, true, result); + List<CbConfig> ranges = new ArrayList<>(); + ranges.add(new CbConfig(10, 20, 1, true)); + setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, ranges); ArgumentCaptor<Integer> captorStart = ArgumentCaptor.forClass(Integer.class); ArgumentCaptor<Integer> captorEnd = ArgumentCaptor.forClass(Integer.class); ArgumentCaptor<Integer> captorType = ArgumentCaptor.forClass(Integer.class); - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber(anyInt(), - captorStart.capture(), captorEnd.capture(), captorType.capture()); - - assertEquals(10, captorStart.getValue().intValue()); - assertEquals(20, captorEnd.getValue().intValue()); - assertEquals(1, captorType.getValue().intValue()); + CbConfig[] configs = new CbConfig[]{new CbConfig(10, 20, 1, true)}; + verifySetRanges(configs, 1, 1); - setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, true, true, result); + ranges.clear(); + ranges.add(new CbConfig(10, 20, 1, true)); + setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, ranges); - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber(anyInt(), - captorStart.capture(), captorEnd.capture(), captorType.capture()); - assertEquals(10, captorStart.getValue().intValue()); - assertEquals(20, captorEnd.getValue().intValue()); - assertEquals(1, captorType.getValue().intValue()); + configs = new CbConfig[]{new CbConfig(10, 20, 1, true)}; + verifySetRanges(configs, 2, 2); } /** @@ -220,25 +219,29 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { @Test @SmallTest public void testDisableCellBroadcastRange() throws Exception { - ArrayList<CellBroadcastChannelRange> result = new ArrayList<>(); - result.add(new CellBroadcastChannelRange(mContext, - SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, mResources, "10-20")); - setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, false, false, result); + List<CbConfig> ranges = new ArrayList<>(); + ranges.add(new CbConfig(10, 20, 1, false)); + setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, ranges); ArgumentCaptor<Integer> captorStart = ArgumentCaptor.forClass(Integer.class); ArgumentCaptor<Integer> captorEnd = ArgumentCaptor.forClass(Integer.class); ArgumentCaptor<Integer> captorType = ArgumentCaptor.forClass(Integer.class); - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber(anyInt(), - captorStart.capture(), captorEnd.capture(), captorType.capture()); - - assertEquals(10, captorStart.getValue().intValue()); - assertEquals(20, captorEnd.getValue().intValue()); - assertEquals(1, captorType.getValue().intValue()); - - setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, true, false, result); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber(anyInt(), - captorStart.capture(), captorEnd.capture(), captorType.capture()); + CbConfig[] configs = new CbConfig[]{new CbConfig(10, 20, 1, false)}; + verifySetRanges(configs, 1, 1); + + ranges.clear(); + setCellBroadcastRange(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, ranges); + if (SdkLevel.isAtLeastU()) { + ArgumentCaptor<List<CellBroadcastIdRange>> captorRanges = + ArgumentCaptor.forClass(List.class); + verify(mTelephonyManager, times(2)).setCellBroadcastIdRanges( + captorRanges.capture(), any(), any()); + List<CellBroadcastIdRange> outputs = captorRanges.getAllValues().get(1); + assertFalse(outputs.contains(new CellBroadcastIdRange(10, 20, 1, false))); + } else { + verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber(anyInt(), + captorStart.capture(), captorEnd.capture(), captorType.capture()); + } } private void setPreference(String pref, boolean value) { @@ -256,112 +259,67 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true); + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE, + SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, false), + + // GSM + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING, + SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE, + SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXERCISE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXERCISE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PUBLIC_SAFETY, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PUBLIC_SAFETY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER, + SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - - // GSM - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE), - eq(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXERCISE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXERCISE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PUBLIC_SAFETY), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PUBLIC_SAFETY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER), - eq(SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 1, 1); } /** @@ -371,68 +329,28 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { @SmallTest public void testEnablingPresidential() throws Exception { setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 1, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, false); mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 2, 2); setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(3)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(3)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(3)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - + verifySetRanges(configs, 3, 3); } /** @@ -443,68 +361,53 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { public void testEnablingExtreme() throws Exception { setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true); - mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig( + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); + verifySetRanges(configs, 1, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, false); + configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, false), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig( + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 2, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true); + configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig( + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - + verifySetRanges(configs, 3, 2); } /** @@ -515,67 +418,52 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { public void testEnablingSevere() throws Exception { setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true); + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig( + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 1, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, false); + configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, false), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig( + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 2, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true); + configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig( + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 3, 2); } /** @@ -586,67 +474,52 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { public void testEnablingAmber() throws Exception { setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true); + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig( + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 1, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, false); + configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, false), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig( + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 2, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true); + configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig( + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY_LANGUAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 3, 2); } /** @@ -656,49 +529,40 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { @SmallTest public void testEnablingETWS() throws Exception { setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING, + SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 1, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, false); + configs = new CbConfig[]{ + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING, + SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 2, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); + configs = new CbConfig[]{ + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING, + SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 3, 2); } /** @@ -707,24 +571,44 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { @Test @SmallTest public void testEnablingGeoFencingTriggeredChannel() throws Exception { + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER, + SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); + verifySetRanges(configs, 1, 1); + } - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER), - eq(SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - + /** + * Test disabling channels for geo-fencing message + */ + @Test + @SmallTest + public void testDisablingGeoFencingTriggeredChannel() throws Exception { putResources(com.android.cellbroadcastreceiver.R.array .geo_fencing_trigger_messages_range_strings, new String[]{ }); - + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER, + SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - verify(mMockedSmsService, times(0)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER), - eq(SmsCbConstants.MESSAGE_ID_CMAS_GEO_FENCING_TRIGGER), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + if (SdkLevel.isAtLeastU()) { + ArgumentCaptor<List<CellBroadcastIdRange>> captorRanges = + ArgumentCaptor.forClass(List.class); + verify(mTelephonyManager, times(1)).setCellBroadcastIdRanges( + captorRanges.capture(), any(), any()); + List<CellBroadcastIdRange> ranges = captorRanges.getAllValues().get(0); + assertFalse(ranges.contains(new CellBroadcastIdRange(configs[0].mStartId, + configs[0].mEndId, configs[0].mRanType, configs[0].mEnable))); + } else { + verify(mMockedSmsService, times(0)) + .disableCellBroadcastRangeForSubscriber(eq(0), + eq(configs[0].mStartId), eq(configs[0].mEndId), + eq(configs[0].mRanType)); + } } /** @@ -739,23 +623,21 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { }); setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); setPreference(CellBroadcastSettings.KEY_ENABLE_EMERGENCY_ALERTS, true); + CbConfig[] configs = new CbConfig[]{ + new CbConfig(0xA000, 0xA000, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(0xA000), - eq(0xA000), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 1, 1); setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, true); setPreference(CellBroadcastSettings.KEY_ENABLE_EMERGENCY_ALERTS, false); + configs = new CbConfig[]{ + new CbConfig(0xA000, 0xA000, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(0xA000), - eq(0xA000), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 2, 1); } /** @@ -771,26 +653,24 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { doReturn(true).when(mMockedSharedPreferences).getBoolean( eq(CellBroadcastSettings.KEY_ENABLE_AREA_UPDATE_INFO_ALERTS), eq(false)); doReturn(mResources).when(mConfigService).getResources(anyInt(), anyString()); + CbConfig[] configs = new CbConfig[]{ + new CbConfig(0x032, 0x032, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; putResources(com.android.cellbroadcastreceiver.R.bool.config_showAreaUpdateInfoSettings, true); mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(0x032), - eq(0x032), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 1, 1); doReturn(false).when(mMockedSharedPreferences).getBoolean( eq(CellBroadcastSettings.KEY_ENABLE_AREA_UPDATE_INFO_ALERTS), eq(false)); + configs = new CbConfig[]{ + new CbConfig(0x032, 0x032, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(0x032), - eq(0x032), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 2, 1); } /** @@ -808,13 +688,13 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { putResources(com.android.cellbroadcastreceiver.R.bool .state_local_test_alerts_enabled_default, true); + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST, + SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 1, 1); // check disable when setting is not shown and default preference is false putResources(com.android.cellbroadcastreceiver.R.bool @@ -823,12 +703,7 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { .state_local_test_alerts_enabled_default, false); mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(2)).disableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 2, 2); // check enable when setting is not shown and default preference is true putResources(com.android.cellbroadcastreceiver.R.bool @@ -836,13 +711,13 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { putResources(com.android.cellbroadcastreceiver.R.bool .state_local_test_alerts_enabled_default, true); + configs = new CbConfig[]{ + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + verifySetRanges(configs, 3, 1); // check enable when setting is shown and preference is true doReturn(true).when(mMockedSharedPreferences).getBoolean( @@ -853,13 +728,7 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { .state_local_test_alerts_enabled_default, false); mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - - verify(mMockedSmsService, times(2)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_STATE_LOCAL_TEST), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - + verifySetRanges(configs, 4, 2); } /** @@ -873,11 +742,11 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { doReturn(SubscriptionManager.INVALID_SUBSCRIPTION_ID).when( mMockSubscriptionInfo).getSubscriptionId(); doReturn(mContext).when(mConfigService).getApplicationContext(); - doReturn(mMockSubscriptionManager).when(mContext).getSystemService(anyString()); + doReturn(mMockSubscriptionManager).when(mContext).getSystemService( + Context.TELEPHONY_SUBSCRIPTION_SERVICE); doReturn(sl).when(mMockSubscriptionManager).getActiveSubscriptionInfoList(); doReturn(CellBroadcastConfigService.ACTION_ENABLE_CHANNELS).when(mIntent).getAction(); doNothing().when(mConfigService).enableCellBroadcastChannels(anyInt()); - doNothing().when(mConfigService).enableCellBroadcastRoamingChannelsAsNeeded(anyInt()); Method method = CellBroadcastConfigService.class.getDeclaredMethod( "onHandleIntent", new Class[]{Intent.class}); @@ -886,16 +755,73 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { verify(mConfigService, times(1)).enableCellBroadcastChannels( eq(SubscriptionManager.INVALID_SUBSCRIPTION_ID)); - verify(mConfigService, times(1)).enableCellBroadcastRoamingChannelsAsNeeded( - eq(SubscriptionManager.INVALID_SUBSCRIPTION_ID)); - doReturn(true).when(mConfigService).isMockModemRunning(); - method.invoke(mConfigService, mIntent); - verify(mContext, times(1)).sendBroadcast(any(), anyString()); + if (!SdkLevel.isAtLeastU()) { + doReturn(true).when(mConfigService).isMockModemRunning(); + method.invoke(mConfigService, mIntent); + verify(mContext, times(1)).sendBroadcast(any(), anyString()); - doReturn(false).when(mConfigService).isMockModemRunning(); - method.invoke(mConfigService, mIntent); - verify(mContext, times(1)).sendBroadcast(any(), anyString()); + doReturn(false).when(mConfigService).isMockModemRunning(); + method.invoke(mConfigService, mIntent); + verify(mContext, times(1)).sendBroadcast(any(), anyString()); + } + } + + /** + * Test resetting cell broadcast channels before enabling channels + */ + @Test + @SmallTest + public void testResetChannelsOnEnableCellBroadcastChannels() { + mConfigService.enableCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); + verify(mConfigService, times(1)) + .resetCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); + } + + /** + * Test to call Telephony API for resetting cell broadcast channels + */ + @Test + @SmallTest + public void testResetCellBroadcastChannels() throws Exception { + mConfigService.resetCellBroadcastChannels(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); + if (SdkLevel.isAtLeastU()) { + verify(mTelephonyManager, never()) + .setCellBroadcastIdRanges(any(), any(), any()); + } else { + verify(mMockedSmsService, times(1)) + .resetAllCellBroadcastRanges(anyInt()); + } + } + + private void verifySetRanges(CbConfig[] configs, int invocationNumForU, int invocationNum) + throws RemoteException { + if (SdkLevel.isAtLeastU()) { + ArgumentCaptor<List<CellBroadcastIdRange>> captorRanges = + ArgumentCaptor.forClass(List.class); + verify(mTelephonyManager, times(invocationNumForU)).setCellBroadcastIdRanges( + captorRanges.capture(), any(), any()); + List<CellBroadcastIdRange> ranges = captorRanges.getAllValues() + .get(invocationNumForU - 1); + for (int i = 0; i < configs.length; i++) { + assertTrue(ranges.contains(new CellBroadcastIdRange(configs[i].mStartId, + configs[i].mEndId, configs[i].mRanType, configs[i].mEnable))); + } + } else { + for (int i = 0; i < configs.length; i++) { + if (configs[i].mEnable) { + verify(mMockedSmsService, times(invocationNum)) + .enableCellBroadcastRangeForSubscriber(eq(0), + eq(configs[i].mStartId), eq(configs[i].mEndId), + eq(configs[i].mRanType)); + } else { + verify(mMockedSmsService, times(invocationNum)) + .disableCellBroadcastRangeForSubscriber(eq(0), + eq(configs[i].mStartId), eq(configs[i].mEndId), + eq(configs[i].mRanType)); + } + } + } } /** @@ -904,9 +830,15 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { @Test @SmallTest public void testEnableCellBroadcastRoamingChannelsAsNeeded() throws Exception { + setPreference(CellBroadcastSettings.KEY_ENABLE_ALERTS_MASTER_TOGGLE, false); + setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, false); + setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, false); + setPreference(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, false); + setPreference(CellBroadcastSettings.KEY_ENABLE_EMERGENCY_ALERTS, false); + setPreference(CellBroadcastSettings.KEY_ENABLE_STATE_LOCAL_TEST_ALERTS, false); doReturn("").when(mMockedSharedPreferences).getString(anyString(), anyString()); - mConfigService.enableCellBroadcastRoamingChannelsAsNeeded( + mConfigService.enableCellBroadcastChannels( SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); //do nothing if operator is empty @@ -938,103 +870,312 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { putResources(com.android.cellbroadcastreceiver.R.bool .emergency_alerts_enabled_default, true); - mConfigService.enableCellBroadcastRoamingChannelsAsNeeded( + CbConfig[] configs = new CbConfig[]{ + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE, + SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING, + SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE, + SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE, + SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_OPERATOR_DEFINED_USE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_OPERATOR_DEFINED_USE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXERCISE, + SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXERCISE, + SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; + mConfigService.enableCellBroadcastChannels( SubscriptionManager.DEFAULT_SUBSCRIPTION_ID); - // should not disable channel - verify(mMockedSmsService, never()).disableCellBroadcastRangeForSubscriber( - anyInt(), anyInt(), anyInt(), anyInt()); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_EXTREME_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_SEVERE_THREAT), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE), - eq(SmsEnvelope.SERVICE_CATEGORY_CMAS_TEST_MESSAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP2)); - - // GSM - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_WARNING), - eq(SmsCbConstants.MESSAGE_ID_ETWS_EARTHQUAKE_AND_TSUNAMI_WARNING), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbConstants.MESSAGE_ID_ETWS_OTHER_EMERGENCY_TYPE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_PRESIDENTIAL_LEVEL), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_IMMEDIATE_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXTREME_EXPECTED_OBSERVED), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_SEVERE_EXPECTED_LIKELY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_CHILD_ABDUCTION_EMERGENCY), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_REQUIRED_MONTHLY_TEST), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE), - eq(SmsCbConstants.MESSAGE_ID_ETWS_TEST_MESSAGE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_OPERATOR_DEFINED_USE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_OPERATOR_DEFINED_USE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); - - verify(mMockedSmsService, times(1)).enableCellBroadcastRangeForSubscriber( - eq(0), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXERCISE), - eq(SmsCbConstants.MESSAGE_ID_CMAS_ALERT_EXERCISE), - eq(SmsCbMessage.MESSAGE_FORMAT_3GPP)); + if (SdkLevel.isAtLeastU()) { + ArgumentCaptor<List<CellBroadcastIdRange>> captorRanges = + ArgumentCaptor.forClass(List.class); + verify(mTelephonyManager, times(2)).setCellBroadcastIdRanges( + captorRanges.capture(), any(), any()); + List<CellBroadcastIdRange> ranges = captorRanges.getAllValues().get(1); + for (int i = 0; i < configs.length; i++) { + boolean result = false; + for (int j = 0; j < ranges.size(); j++) { + if (configs[i].mStartId >= ranges.get(j).getStartId() + && configs[i].mEndId <= ranges.get(j).getEndId()) { + result = true; + break; + } + } + assertTrue(result); + } + } else { + ArgumentCaptor<Integer> startIds = ArgumentCaptor.forClass(Integer.class); + ArgumentCaptor<Integer> endIds = ArgumentCaptor.forClass(Integer.class); + ArgumentCaptor<Integer> types = ArgumentCaptor.forClass(Integer.class); + verify(mMockedSmsService, atLeastOnce()) + .enableCellBroadcastRangeForSubscriber( + anyInt(), startIds.capture(), endIds.capture(), types.capture()); + for (int i = 0; i < configs.length; i++) { + boolean result = false; + for (int j = 0; j < startIds.getAllValues().size(); j++) { + if (configs[i].mStartId >= startIds.getAllValues().get(j).intValue() + && configs[i].mEndId <= endIds.getAllValues().get(j).intValue()) { + result = true; + break; + } + } + assertTrue(result); + } + } + } + + @Test + public void testMergeRangesAsNeeded() { + // Verify that there is no conflict channel. Conflicted channel means that there is overlap + // between the ranges of disabled and the ranges of enabled. + int[][] enableChannels = new int[][]{ + {0, 999}, {1000, 1003}, {1004, 0x0FFF}, {0x1000, 0x10FF}}; + int[][] disableChannels = new int[][]{}; + CbConfig[] expectedRanges = new CbConfig[]{ + new CbConfig(0, 999, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(1000, 1003, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(1004, 0x0FFF, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(0x1000, 0x10FF, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(0, 999, SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(1000, 1003, SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(1004, 0x0FFF, SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + new CbConfig(0x1000, 0x10FF, SmsCbMessage.MESSAGE_FORMAT_3GPP2, true), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, true, expectedRanges); + + enableChannels = new int[][]{{500, 1050}, {1500, 1800}}; + disableChannels = new int[][]{{0, 999}, {1000, 2000}}; + expectedRanges = new CbConfig[]{ + new CbConfig(0, 499, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(500, 1050, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(1051, 1499, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(1500, 1800, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(1801, 2000, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{0, 1050}, {1200, 1500}}; + disableChannels = new int[][]{{0, 999}, {1200, 2000}}; + expectedRanges = new CbConfig[]{ + new CbConfig(0, 1050, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(1200, 1500, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(1501, 2000, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{0, 500}, {1000, 1500}}; + disableChannels = new int[][]{{0, 999}, {1200, 2000}}; + expectedRanges = new CbConfig[]{ + new CbConfig(0, 500, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(501, 999, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(1000, 1500, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(1501, 2000, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{0, 999}, {1200, 2000}}; + disableChannels = new int[][]{{0, 500}, {1000, 1500}}; + expectedRanges = new CbConfig[]{ + new CbConfig(0, 999, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(1000, 1199, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(1200, 2000, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{0, 500}}; + disableChannels = new int[][]{{200, 700}, {300, 800}}; + expectedRanges = new CbConfig[]{ + new CbConfig(0, 500, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(501, 800, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{200, 700}, {300, 800}}; + disableChannels = new int[][]{{0, 500}}; + expectedRanges = new CbConfig[]{ + new CbConfig(0, 199, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(200, 800, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{0, 500}}; + disableChannels = new int[][]{{200, 700}, {300, 800}}; + expectedRanges = new CbConfig[]{ + new CbConfig(0, 500, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(501, 800, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{100, 130}, {140, 160}}; + disableChannels = new int[][]{{120, 200}}; + expectedRanges = new CbConfig[]{ + new CbConfig(100, 130, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(131, 139, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(140, 160, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(161, 200, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{120, 200}}; + disableChannels = new int[][]{{100, 130}, {140, 160}}; + expectedRanges = new CbConfig[]{ + new CbConfig(100, 119, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(120, 200, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{100, 140}, {120, 200}}; + disableChannels = new int[][]{{150, 170}, {160, 250}}; + expectedRanges = new CbConfig[]{ + new CbConfig(100, 200, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(201, 250, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{200, 250}, {270, 290}}; + disableChannels = new int[][]{{100, 300}, {260, 280}}; + expectedRanges = new CbConfig[]{ + new CbConfig(100, 199, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(200, 250, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(251, 269, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(270, 290, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(291, 300, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{4370, 4370}, {4372, 4372}}; + disableChannels = new int[][]{{4370, 4370}, {4372, 4372}}; + expectedRanges = new CbConfig[]{ + new CbConfig(4370, 4370, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(4372, 4372, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{0, 100}, {150, 300}}; + disableChannels = new int[][]{{80, 200}}; + expectedRanges = new CbConfig[]{ + new CbConfig(0, 100, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(101, 149, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(150, 300, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{100, 200}, {400, 700}}; + disableChannels = new int[][]{{100, 300}, {400, 500}}; + expectedRanges = new CbConfig[]{ + new CbConfig(100, 200, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(201, 300, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(400, 700, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{100, 200}, {601, 601}}; + disableChannels = new int[][]{{100, 201}, {300, 400}, {500, 600}}; + expectedRanges = new CbConfig[]{ + new CbConfig(100, 200, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(201, 201, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(300, 400, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(500, 600, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(601, 601, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{100, 200}, {150, 300}}; + disableChannels = new int[][]{{250, 400}, {270, 500}}; + expectedRanges = new CbConfig[]{ + new CbConfig(100, 300, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(301, 500, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{100, 200}, {150, 300}, {350, 370}}; + disableChannels = new int[][]{{250, 400}, {270, 500}}; + expectedRanges = new CbConfig[]{ + new CbConfig(100, 300, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(301, 349, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + new CbConfig(350, 370, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(371, 500, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + + enableChannels = new int[][]{{0, 200}, {50, 150}}; + disableChannels = new int[][]{{170, 300}}; + expectedRanges = new CbConfig[]{ + new CbConfig(0, 200, SmsCbMessage.MESSAGE_FORMAT_3GPP, true), + new CbConfig(201, 300, SmsCbMessage.MESSAGE_FORMAT_3GPP, false), + }; + verifyRangesAfterMerging(enableChannels, disableChannels, expectedRanges); + } + + private void verifyRangesAfterMerging(int[][] enableChannels, int[][] disableChannels, + CbConfig[] expectedRanges) { + verifyRangesAfterMerging(enableChannels, disableChannels, false, expectedRanges); + } + private void verifyRangesAfterMerging(int[][] enableChannels, int[][] disableChannels, + boolean differentType, CbConfig[] expectedRanges) { + List<CbConfig> config = new ArrayList<>(); + for (int i = 0; i < enableChannels.length; i++) { + config.add(new CbConfig(enableChannels[i][0], enableChannels[i][1], + SmsCbMessage.MESSAGE_FORMAT_3GPP, true)); + if (differentType) { + config.add(new CbConfig(enableChannels[i][0], enableChannels[i][1], + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true)); + } + } + for (int i = 0; i < disableChannels.length; i++) { + config.add(new CbConfig(disableChannels[i][0], disableChannels[i][1], + SmsCbMessage.MESSAGE_FORMAT_3GPP, false)); + if (differentType) { + config.add(new CbConfig(enableChannels[i][0], enableChannels[i][1], + SmsCbMessage.MESSAGE_FORMAT_3GPP2, true)); + } + } + List<CbConfig> ranges = mConfigService.mergeConfigAsNeeded(config); + assertEquals(expectedRanges.length, ranges.size()); + for (int i = 0; i < expectedRanges.length; i++) { + assertEquals(expectedRanges[i].mStartId, ranges.get(i).mStartId); + assertEquals(expectedRanges[i].mEndId, ranges.get(i).mEndId); + assertEquals(expectedRanges[i].mEnable, ranges.get(i).mEnable); + assertEquals(expectedRanges[i].mRanType, ranges.get(i).mRanType); + } } /** @@ -1052,7 +1193,7 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { // The settings are changed by the user {true, true, true}, {true, true, false}, {true, false, true}, {true, false, false}, // The master toggle values of preferences and config are same - {false, true, true}, { false, false, false}}; + {false, true, true}, {false, false, false}}; Method method = CellBroadcastConfigService.class.getDeclaredMethod( "onHandleIntent", new Class[]{Intent.class}); @@ -1072,7 +1213,7 @@ public class CellBroadcastConfigServiceTest extends CellBroadcastTest { verify(mConfigService, never()).resetAllPreferences(); } - boolean[][] combResetting = {{false, true, false}, { false, false, true}}; + boolean[][] combResetting = {{false, true, false}, {false, false, true}}; // Verify the settings preference to be reset for (int i = 0, c = 0; i < combResetting.length; i++) { diff --git a/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastServiceTestCase.java b/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastServiceTestCase.java index 67573ef47..d1d6fc51e 100644 --- a/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastServiceTestCase.java +++ b/tests/unit/src/com/android/cellbroadcastreceiver/unit/CellBroadcastServiceTestCase.java @@ -168,6 +168,14 @@ public abstract class CellBroadcastServiceTestCase<T extends Service> extends Se } @Override + public String getSystemServiceName(Class<?> serviceClass) { + if (TelephonyManager.class.equals(serviceClass)) { + return Context.TELEPHONY_SERVICE; + } + return super.getSystemServiceName(serviceClass); + } + + @Override public SharedPreferences getSharedPreferences(String name, int mode) { return mMockedSharedPreferences; } |