| /* |
| * Copyright (C) 2009 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 android.telephony.cts; |
| |
| import static androidx.test.InstrumentationRegistry.getContext; |
| import static androidx.test.InstrumentationRegistry.getInstrumentation; |
| |
| import static com.android.compatibility.common.util.BlockedNumberUtil.deleteBlockedNumber; |
| import static com.android.compatibility.common.util.BlockedNumberUtil.insertBlockedNumber; |
| |
| import static org.hamcrest.Matchers.anyOf; |
| import static org.hamcrest.Matchers.emptyString; |
| import static org.hamcrest.Matchers.equalTo; |
| import static org.hamcrest.Matchers.greaterThan; |
| import static org.hamcrest.Matchers.startsWith; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertThat; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| import static org.junit.Assume.assumeNoException; |
| import static org.junit.Assume.assumeTrue; |
| |
| import android.Manifest; |
| import android.annotation.Nullable; |
| import android.app.AppOpsManager; |
| import android.app.PendingIntent; |
| import android.app.UiAutomation; |
| import android.app.role.RoleManager; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.ContentResolver; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.PackageManager; |
| import android.net.Uri; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.os.ParcelFileDescriptor; |
| import android.os.RemoteCallback; |
| import android.os.SystemClock; |
| import android.provider.Telephony; |
| import android.telephony.SmsCbMessage; |
| import android.telephony.SmsManager; |
| import android.telephony.SmsMessage; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyManager; |
| import android.telephony.cdma.CdmaSmsCbProgramData; |
| import android.telephony.cts.util.DefaultSmsAppHelper; |
| import android.telephony.cts.util.TelephonyUtils; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import androidx.test.InstrumentationRegistry; |
| |
| import com.android.compatibility.common.util.ApiTest; |
| import com.android.compatibility.common.util.ShellIdentityUtils; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| import java.io.BufferedReader; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.nio.charset.StandardCharsets; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.List; |
| import java.util.concurrent.Callable; |
| import java.util.concurrent.CompletableFuture; |
| import java.util.concurrent.TimeUnit; |
| |
| /** |
| * Tests for {@link android.telephony.SmsManager}. |
| * |
| * Structured so tests can be reused to test {@link android.telephony.gsm.SmsManager} |
| */ |
| public class SmsManagerTest { |
| |
| private static final String TAG = "SmsManagerTest"; |
| private static final String LONG_TEXT = |
| "This is a very long text. This text should be broken into three " + |
| "separate messages.This is a very long text. This text should be broken into " + |
| "three separate messages.This is a very long text. This text should be broken " + |
| "into three separate messages.This is a very long text. This text should be " + |
| "broken into three separate messages.";; |
| private static final String LONG_TEXT_WITH_32BIT_CHARS = |
| "Long dkkshsh jdjsusj kbsksbdf jfkhcu hhdiwoqiwyrygrvn?*?*!\";:'/,." |
| + "__?9#9292736&4;\"$+$+((]\\[\\℅©℅™^®°¥°¥=¢£}}£∆~¶~÷|√×." |
| + " 😯😆😉😇😂😀👕🎓😀👙🐕🐀🐶🐰🐩⛪⛲ "; |
| |
| private static final String SMS_SEND_ACTION = "CTS_SMS_SEND_ACTION"; |
| private static final String SMS_DELIVERY_ACTION = "CTS_SMS_DELIVERY_ACTION"; |
| private static final String DATA_SMS_RECEIVED_ACTION = "android.intent.action.DATA_SMS_RECEIVED"; |
| public static final String SMS_DELIVER_DEFAULT_APP_ACTION = "CTS_SMS_DELIVERY_ACTION_DEFAULT_APP"; |
| public static final String LEGACY_SMS_APP = "android.telephony.cts.sms23"; |
| public static final String MODERN_SMS_APP = "android.telephony.cts.sms"; |
| private static final String SMS_RETRIEVER_APP = "android.telephony.cts.smsretriever"; |
| private static final String SMS_RETRIEVER_ACTION = "CTS_SMS_RETRIEVER_ACTION"; |
| private static final String FINANCIAL_SMS_APP = "android.telephony.cts.financialsms"; |
| |
| private TelephonyManager mTelephonyManager; |
| private SubscriptionManager mSubscriptionManager; |
| private String mDestAddr; |
| private String mText; |
| private SmsBroadcastReceiver mSendReceiver; |
| private SmsBroadcastReceiver mDeliveryReceiver; |
| private SmsBroadcastReceiver mDataSmsReceiver; |
| private SmsBroadcastReceiver mSmsDeliverReceiver; |
| private SmsBroadcastReceiver mSmsReceivedReceiver; |
| private SmsBroadcastReceiver mSmsRetrieverReceiver; |
| private PendingIntent mSentIntent; |
| private PendingIntent mDeliveredIntent; |
| private Intent mSendIntent; |
| private Intent mDeliveryIntent; |
| private Context mContext; |
| private Uri mBlockedNumberUri; |
| private boolean mTestAppSetAsDefaultSmsApp; |
| private boolean mDeliveryReportSupported; |
| private static boolean mReceivedDataSms; |
| private static String mReceivedText; |
| @Nullable |
| private String mOriginalDefaultSmsApp; |
| private static boolean sHasShellPermissionIdentity = false; |
| private static long sMessageId = 0L; |
| |
| private static final int TIME_OUT = 1000 * 60 * 10; |
| private static final int NO_CALLS_TIMEOUT_MILLIS = 1000; // 1 second |
| |
| @Before |
| public void setUp() throws Exception { |
| assumeTrue(getContext().getPackageManager().hasSystemFeature( |
| PackageManager.FEATURE_TELEPHONY_MESSAGING)); |
| |
| mContext = getContext(); |
| mTelephonyManager = mContext.getSystemService(TelephonyManager.class); |
| mSubscriptionManager = mContext.getSystemService(SubscriptionManager.class); |
| mText = "This is a test message"; |
| |
| executeWithShellPermissionIdentity(() -> { |
| mDestAddr = mSubscriptionManager.getPhoneNumber(mTelephonyManager.getSubscriptionId()); |
| }); |
| |
| // exclude the networks that don't support SMS delivery report |
| String mccmnc = mTelephonyManager.getSimOperator(); |
| mDeliveryReportSupported = !(CarrierCapability.NO_DELIVERY_REPORTS.contains(mccmnc)); |
| |
| // register receivers |
| mSendIntent = new Intent(SMS_SEND_ACTION).setPackage(mContext.getPackageName()); |
| mDeliveryIntent = new Intent(SMS_DELIVERY_ACTION).setPackage(mContext.getPackageName()); |
| |
| IntentFilter sendIntentFilter = new IntentFilter(SMS_SEND_ACTION); |
| IntentFilter deliveryIntentFilter = new IntentFilter(SMS_DELIVERY_ACTION); |
| IntentFilter dataSmsReceivedIntentFilter = new IntentFilter(DATA_SMS_RECEIVED_ACTION); |
| IntentFilter smsDeliverIntentFilter = new IntentFilter(SMS_DELIVER_DEFAULT_APP_ACTION); |
| IntentFilter smsReceivedIntentFilter = |
| new IntentFilter(Telephony.Sms.Intents.SMS_RECEIVED_ACTION); |
| IntentFilter smsRetrieverIntentFilter = new IntentFilter(SMS_RETRIEVER_ACTION); |
| dataSmsReceivedIntentFilter.addDataScheme("sms"); |
| dataSmsReceivedIntentFilter.addDataAuthority("localhost", "19989"); |
| |
| mSendReceiver = new SmsBroadcastReceiver(SMS_SEND_ACTION); |
| mDeliveryReceiver = new SmsBroadcastReceiver(SMS_DELIVERY_ACTION); |
| mDataSmsReceiver = new SmsBroadcastReceiver(DATA_SMS_RECEIVED_ACTION); |
| mSmsDeliverReceiver = new SmsBroadcastReceiver(SMS_DELIVER_DEFAULT_APP_ACTION); |
| mSmsReceivedReceiver = new SmsBroadcastReceiver(Telephony.Sms.Intents.SMS_RECEIVED_ACTION); |
| mSmsRetrieverReceiver = new SmsBroadcastReceiver(SMS_RETRIEVER_ACTION); |
| |
| mContext.registerReceiver(mSendReceiver, sendIntentFilter, |
| Context.RECEIVER_EXPORTED_UNAUDITED); |
| mContext.registerReceiver(mDeliveryReceiver, deliveryIntentFilter, |
| Context.RECEIVER_EXPORTED_UNAUDITED); |
| mContext.registerReceiver(mDataSmsReceiver, dataSmsReceivedIntentFilter, |
| Context.RECEIVER_EXPORTED_UNAUDITED); |
| mContext.registerReceiver(mSmsDeliverReceiver, smsDeliverIntentFilter, |
| Context.RECEIVER_EXPORTED_UNAUDITED); |
| mContext.registerReceiver(mSmsReceivedReceiver, smsReceivedIntentFilter); |
| mContext.registerReceiver(mSmsRetrieverReceiver, smsRetrieverIntentFilter, |
| Context.RECEIVER_EXPORTED_UNAUDITED); |
| |
| mOriginalDefaultSmsApp = DefaultSmsAppHelper.getDefaultSmsApp(getContext()); |
| DefaultSmsAppHelper.stopBeingDefaultSmsApp(); |
| } |
| |
| @After |
| public void tearDown() throws Exception { |
| if (mBlockedNumberUri != null) { |
| unblockNumber(mBlockedNumberUri); |
| mBlockedNumberUri = null; |
| } |
| if (mTestAppSetAsDefaultSmsApp) { |
| setDefaultSmsApp(false); |
| } |
| |
| // unregister receivers |
| if (mSendReceiver != null) { |
| mContext.unregisterReceiver(mSendReceiver); |
| } |
| if (mDeliveryReceiver != null) { |
| mContext.unregisterReceiver(mDeliveryReceiver); |
| } |
| if (mDataSmsReceiver != null) { |
| mContext.unregisterReceiver(mDataSmsReceiver); |
| } |
| if (mSmsDeliverReceiver != null) { |
| mContext.unregisterReceiver(mSmsDeliverReceiver); |
| } |
| if (mSmsReceivedReceiver != null) { |
| mContext.unregisterReceiver(mSmsReceivedReceiver); |
| } |
| if (mSmsRetrieverReceiver != null) { |
| mContext.unregisterReceiver(mSmsRetrieverReceiver); |
| } |
| if (!TextUtils.isEmpty(mOriginalDefaultSmsApp)) { |
| assertTrue(DefaultSmsAppHelper.setDefaultSmsApp(getContext(), mOriginalDefaultSmsApp)); |
| } |
| } |
| |
| @Test |
| public void testDivideMessage() { |
| ArrayList<String> dividedMessages = divideMessage(LONG_TEXT); |
| assertNotNull(dividedMessages); |
| if (TelephonyUtils.isSkt(mTelephonyManager)) { |
| assertTrue(isComplete(dividedMessages, 5, LONG_TEXT) |
| || isComplete(dividedMessages, 3, LONG_TEXT)); |
| } else if (TelephonyUtils.isKt(mTelephonyManager)) { |
| assertTrue(isComplete(dividedMessages, 4, LONG_TEXT) |
| || isComplete(dividedMessages, 3, LONG_TEXT)); |
| } else { |
| assertTrue(isComplete(dividedMessages, 3, LONG_TEXT)); |
| } |
| } |
| |
| @Test |
| public void testDivideUnicodeMessage() { |
| ArrayList<String> dividedMessages = divideMessage(LONG_TEXT_WITH_32BIT_CHARS); |
| assertNotNull(dividedMessages); |
| assertTrue(isComplete(dividedMessages, 3, LONG_TEXT_WITH_32BIT_CHARS)); |
| for (String messagePiece : dividedMessages) { |
| assertFalse(Character.isHighSurrogate( |
| messagePiece.charAt(messagePiece.length() - 1))); |
| } |
| } |
| |
| private boolean isComplete(List<String> dividedMessages, int numParts, String longText) { |
| if (dividedMessages.size() != numParts) { |
| return false; |
| } |
| |
| String actualMessage = ""; |
| for (int i = 0; i < numParts; i++) { |
| actualMessage += dividedMessages.get(i); |
| } |
| return longText.equals(actualMessage); |
| } |
| |
| @Test |
| public void testSmsRetriever() throws Exception { |
| assertFalse("[RERUN] SIM card does not provide phone number. Use a suitable SIM Card.", |
| TextUtils.isEmpty(mDestAddr)); |
| |
| String mccmnc = mTelephonyManager.getSimOperator(); |
| int carrierId = mTelephonyManager.getSimCarrierId(); |
| assertFalse("[RERUN] Carrier [carrier-id: " + carrierId + "] does not support " |
| + "loop back messages. Use another carrier.", |
| CarrierCapability.UNSUPPORT_LOOP_BACK_MESSAGES.contains(carrierId)); |
| |
| init(); |
| |
| CompletableFuture<Bundle> callbackResult = new CompletableFuture<>(); |
| |
| mContext.startActivity(new Intent() |
| .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK) |
| .setComponent(new ComponentName( |
| SMS_RETRIEVER_APP, SMS_RETRIEVER_APP + ".MainActivity")) |
| .putExtra("callback", new RemoteCallback(callbackResult::complete))); |
| |
| |
| Bundle bundle = callbackResult.get(200, TimeUnit.SECONDS); |
| String token = bundle.getString("token"); |
| assertThat(bundle.getString("class"), startsWith(SMS_RETRIEVER_APP)); |
| assertNotNull(token); |
| |
| String composedText = "testprefix1" + mText + token; |
| sendTextMessage(mDestAddr, composedText, null, null); |
| |
| assertTrue("[RERUN] SMS retriever message not received. Check signal.", |
| mSmsRetrieverReceiver.waitForCalls(1, TIME_OUT)); |
| } |
| |
| private void sendAndReceiveSms(boolean addMessageId, boolean defaultSmsApp) throws Exception { |
| // send single text sms |
| init(); |
| if (addMessageId) { |
| long fakeMessageId = 19812L; |
| sendTextMessageWithMessageId(mDestAddr, |
| String.valueOf(SystemClock.elapsedRealtimeNanos()), mSentIntent, |
| mDeliveredIntent, fakeMessageId); |
| } else { |
| sendTextMessage(mDestAddr, String.valueOf(SystemClock.elapsedRealtimeNanos()), |
| mSentIntent, mDeliveredIntent); |
| } |
| assertTrue("[RERUN] Could not send SMS. Check signal.", |
| mSendReceiver.waitForCalls(1, TIME_OUT)); |
| if (mDeliveryReportSupported) { |
| assertTrue("[RERUN] SMS message delivery notification not received. Check signal.", |
| mDeliveryReceiver.waitForCalls(1, TIME_OUT)); |
| } |
| |
| assertTrue(mSmsReceivedReceiver.waitForCalls(1, TIME_OUT)); |
| // Received SMS should always contain a generated messageId |
| assertNotEquals(0L, sMessageId); |
| |
| if (defaultSmsApp) { |
| // default app should receive SMS_DELIVER_ACTION |
| assertTrue(mSmsDeliverReceiver.waitForCalls(1, TIME_OUT)); |
| } else { |
| // non-default app should receive only SMS_RECEIVED_ACTION |
| assertTrue(mSmsDeliverReceiver.verifyNoCalls(NO_CALLS_TIMEOUT_MILLIS)); |
| } |
| } |
| |
| private void sendAndReceiveMultipartSms(String mccmnc, boolean addMessageId, |
| boolean defaultSmsApp) throws Exception { |
| sMessageId = 0L; |
| int numPartsSent = sendMultipartTextMessageIfSupported(mccmnc, addMessageId); |
| if (numPartsSent > 0) { |
| assertTrue("[RERUN] Could not send multi part SMS. Check signal.", |
| mSendReceiver.waitForCalls(numPartsSent, TIME_OUT)); |
| if (mDeliveryReportSupported) { |
| assertTrue("[RERUN] Multi part SMS message delivery notification not received. " |
| + "Check signal.", mDeliveryReceiver.waitForCalls(numPartsSent, TIME_OUT)); |
| } |
| |
| assertTrue(mSmsReceivedReceiver.waitForCalls(1, TIME_OUT)); |
| // Received SMS should contain a generated messageId |
| assertNotEquals(0L, sMessageId); |
| |
| if (defaultSmsApp) { |
| // default app should receive SMS_DELIVER_ACTION |
| assertTrue(mSmsDeliverReceiver.waitForCalls(1, TIME_OUT)); |
| } else { |
| // non-default app should receive only SMS_RECEIVED_ACTION |
| assertTrue(mSmsDeliverReceiver.verifyNoCalls(NO_CALLS_TIMEOUT_MILLIS)); |
| } |
| } else { |
| // This GSM network doesn't support Multipart SMS message. |
| // Skip the test. |
| } |
| } |
| |
| private void sendDataSms(String mccmnc) throws Exception { |
| if (sendDataMessageIfSupported(mccmnc)) { |
| assertTrue("[RERUN] Could not send data SMS. Check signal.", |
| mSendReceiver.waitForCalls(1, TIME_OUT)); |
| if (mDeliveryReportSupported) { |
| assertTrue("[RERUN] Data SMS message delivery notification not received. " + |
| "Check signal.", mDeliveryReceiver.waitForCalls(1, TIME_OUT)); |
| } |
| mDataSmsReceiver.waitForCalls(1, TIME_OUT); |
| assertTrue("[RERUN] Data SMS message not received. Check signal.", mReceivedDataSms); |
| assertEquals(mReceivedText, mText); |
| } else { |
| // This GSM network doesn't support Data(binary) SMS message. |
| // Skip the test. |
| } |
| } |
| |
| @Test(timeout = 10 * 60 * 1000) |
| @ApiTest(apis = { |
| "android.telephony.SmsManager#sendTextMessage", |
| "android.telephony.SmsManager#sendDataMessage", |
| "android.telephony.SmsManager#sendMultipartTextMessage"}) |
| public void testSendAndReceiveMessages() throws Exception { |
| // Test non-default SMS app |
| testSendAndReceiveMessages(false); |
| |
| // Test default SMS app |
| DefaultSmsAppHelper.ensureDefaultSmsApp(); |
| testSendAndReceiveMessages(true); |
| DefaultSmsAppHelper.stopBeingDefaultSmsApp(); |
| } |
| |
| private void testSendAndReceiveMessages(boolean defaultSmsApp) throws Exception { |
| assertFalse("[RERUN] SIM card does not provide phone number. Use a suitable SIM Card.", |
| TextUtils.isEmpty(mDestAddr)); |
| |
| String mccmnc = mTelephonyManager.getSimOperator(); |
| int carrierId = mTelephonyManager.getSimCarrierId(); |
| assertFalse("[RERUN] Carrier [carrier-id: " + carrierId + "] does not support " |
| + "loop back messages. Use another carrier.", |
| CarrierCapability.UNSUPPORT_LOOP_BACK_MESSAGES.contains(carrierId)); |
| |
| // send/receive single text sms with and without messageId |
| sendAndReceiveSms(/* addMessageId= */ true, defaultSmsApp); |
| sendAndReceiveSms(/* addMessageId= */ false, defaultSmsApp); |
| |
| |
| if (mTelephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_CDMA) { |
| // TODO: temp workaround, OCTET encoding for EMS not properly supported |
| return; |
| } |
| |
| // send/receive data sms |
| sendDataSms(mccmnc); |
| |
| // send/receive multi part text sms with and without messageId |
| sendAndReceiveMultipartSms(mccmnc, /* addMessageId= */ true, defaultSmsApp); |
| sendAndReceiveMultipartSms(mccmnc, /* addMessageId= */ false, defaultSmsApp); |
| } |
| |
| @Test |
| public void testSmsBlocking() throws Exception { |
| assertFalse("[RERUN] SIM card does not provide phone number. Use a suitable SIM Card.", |
| TextUtils.isEmpty(mDestAddr)); |
| |
| // disable suppressing blocking. |
| TelephonyUtils.endBlockSuppression(getInstrumentation()); |
| |
| String mccmnc = mTelephonyManager.getSimOperator(); |
| // Setting default SMS App is needed to be able to block numbers. |
| setDefaultSmsApp(true); |
| blockNumber(mDestAddr); |
| |
| // single-part SMS blocking |
| init(); |
| sendTextMessage(mDestAddr, String.valueOf(SystemClock.elapsedRealtimeNanos()), |
| mSentIntent, mDeliveredIntent); |
| assertTrue("[RERUN] Could not send SMS. Check signal.", |
| mSendReceiver.waitForCalls(1, TIME_OUT)); |
| assertTrue("Expected no messages to be received due to number blocking.", |
| mSmsReceivedReceiver.verifyNoCalls(NO_CALLS_TIMEOUT_MILLIS)); |
| assertTrue("Expected no messages to be delivered due to number blocking.", |
| mSmsDeliverReceiver.verifyNoCalls(NO_CALLS_TIMEOUT_MILLIS)); |
| |
| // send data sms |
| if (!sendDataMessageIfSupported(mccmnc)) { |
| assertTrue("[RERUN] Could not send data SMS. Check signal.", |
| mSendReceiver.waitForCalls(1, TIME_OUT)); |
| if (mDeliveryReportSupported) { |
| assertTrue("[RERUN] Data SMS message delivery notification not received. " + |
| "Check signal.", mDeliveryReceiver.waitForCalls(1, TIME_OUT)); |
| } |
| assertTrue("Expected no messages to be delivered due to number blocking.", |
| mSmsDeliverReceiver.verifyNoCalls(NO_CALLS_TIMEOUT_MILLIS)); |
| } else { |
| // This GSM network doesn't support Data(binary) SMS message. |
| // Skip the test. |
| } |
| |
| // multi-part SMS blocking |
| int numPartsSent = sendMultipartTextMessageIfSupported(mccmnc, /* addMessageId= */ false); |
| if (numPartsSent > 0) { |
| assertTrue("[RERUN] Could not send multi part SMS. Check signal.", |
| mSendReceiver.waitForCalls(numPartsSent, TIME_OUT)); |
| |
| assertTrue("Expected no messages to be received due to number blocking.", |
| mSmsReceivedReceiver.verifyNoCalls(NO_CALLS_TIMEOUT_MILLIS)); |
| assertTrue("Expected no messages to be delivered due to number blocking.", |
| mSmsDeliverReceiver.verifyNoCalls(NO_CALLS_TIMEOUT_MILLIS)); |
| } else { |
| // This GSM network doesn't support Multipart SMS message. |
| // Skip the test. |
| } |
| } |
| |
| @Test |
| public void testGetSmsMessagesForFinancialAppPermissionRequestedNotGranted() throws Exception { |
| CompletableFuture<Bundle> callbackResult = new CompletableFuture<>(); |
| |
| mContext.startActivity(new Intent() |
| .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK) |
| .setComponent(new ComponentName(FINANCIAL_SMS_APP, FINANCIAL_SMS_APP + ".MainActivity")) |
| .putExtra("callback", new RemoteCallback(callbackResult::complete))); |
| |
| Bundle bundle = callbackResult.get(500, TimeUnit.SECONDS); |
| |
| assertThat(bundle.getString("class"), startsWith(FINANCIAL_SMS_APP)); |
| assertThat(bundle.getInt("rowNum"), equalTo(-1)); |
| } |
| |
| @Test |
| public void testGetSmsMessagesForFinancialAppPermissionRequestedGranted() throws Exception { |
| CompletableFuture<Bundle> callbackResult = new CompletableFuture<>(); |
| String ctsPackageName = getInstrumentation().getContext().getPackageName(); |
| |
| executeWithShellPermissionIdentity(() -> { |
| setModeForOps(FINANCIAL_SMS_APP, |
| AppOpsManager.MODE_ALLOWED, |
| AppOpsManager.OPSTR_SMS_FINANCIAL_TRANSACTIONS); |
| }); |
| mContext.startActivity(new Intent() |
| .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK) |
| .setComponent(new ComponentName(FINANCIAL_SMS_APP, FINANCIAL_SMS_APP + ".MainActivity")) |
| .putExtra("callback", new RemoteCallback(callbackResult::complete))); |
| |
| |
| Bundle bundle = callbackResult.get(500, TimeUnit.SECONDS); |
| |
| assertThat(bundle.getString("class"), startsWith(FINANCIAL_SMS_APP)); |
| assertThat(bundle.getInt("rowNum"), equalTo(-1)); |
| } |
| |
| @Test |
| public void testSmsNotPersisted_failsWithoutCarrierPermissions() throws Exception { |
| assertFalse("[RERUN] SIM card does not provide phone number. Use a suitable SIM Card.", |
| TextUtils.isEmpty(mDestAddr)); |
| |
| try { |
| getSmsManager().sendTextMessageWithoutPersisting(mDestAddr, null /*scAddress */, |
| mDestAddr, mSentIntent, mDeliveredIntent); |
| fail("We should get a SecurityException due to not having carrier privileges"); |
| } catch (SecurityException e) { |
| // Success |
| } |
| } |
| |
| @Test |
| public void testContentProviderAccessRestriction() throws Exception { |
| Uri dummySmsUri = null; |
| Context context = getInstrumentation().getContext(); |
| ContentResolver contentResolver = context.getContentResolver(); |
| int originalWriteSmsMode = -1; |
| String ctsPackageName = context.getPackageName(); |
| try { |
| // Insert some test sms |
| originalWriteSmsMode = context.getSystemService(AppOpsManager.class) |
| .unsafeCheckOpNoThrow(AppOpsManager.OPSTR_WRITE_SMS, |
| getPackageUid(ctsPackageName), ctsPackageName); |
| setModeForOps(ctsPackageName, |
| AppOpsManager.MODE_ALLOWED, AppOpsManager.OPSTR_WRITE_SMS); |
| ContentValues contentValues = new ContentValues(); |
| contentValues.put(Telephony.TextBasedSmsColumns.ADDRESS, "addr"); |
| contentValues.put(Telephony.TextBasedSmsColumns.READ, 1); |
| contentValues.put(Telephony.TextBasedSmsColumns.SUBJECT, "subj"); |
| contentValues.put(Telephony.TextBasedSmsColumns.BODY, "created_at_" |
| + new Date().toString().replace(" ", "_")); |
| |
| dummySmsUri = contentResolver.insert(Telephony.Sms.CONTENT_URI, contentValues); |
| assertNotNull("Failed to insert test sms", dummySmsUri); |
| assertNotEquals("Failed to insert test sms", "0", dummySmsUri.getLastPathSegment()); |
| testSmsAccessAboutDefaultApp(LEGACY_SMS_APP); |
| testSmsAccessAboutDefaultApp(MODERN_SMS_APP); |
| } finally { |
| if (dummySmsUri != null && !"/0".equals(dummySmsUri.getLastPathSegment())) { |
| final Uri finalDummySmsUri = dummySmsUri; |
| executeWithShellPermissionIdentity(() -> contentResolver.delete(finalDummySmsUri, |
| null, null)); |
| } |
| if (originalWriteSmsMode >= 0) { |
| int finalOriginalWriteSmsMode = originalWriteSmsMode; |
| executeWithShellPermissionIdentity(() -> |
| setModeForOps(ctsPackageName, |
| finalOriginalWriteSmsMode, AppOpsManager.OPSTR_WRITE_SMS)); |
| } |
| } |
| } |
| |
| private void testSmsAccessAboutDefaultApp(String pkg) |
| throws Exception { |
| String originalSmsApp = getSmsApp(); |
| assertNotEquals(pkg, originalSmsApp); |
| assertCanAccessSms(pkg); |
| try { |
| setSmsApp(pkg); |
| assertCanAccessSms(pkg); |
| } finally { |
| resetReadWriteSmsAppOps(pkg); |
| setSmsApp(originalSmsApp); |
| } |
| } |
| |
| private void resetReadWriteSmsAppOps(String pkg) throws Exception { |
| setModeForOps(pkg, AppOpsManager.MODE_DEFAULT, |
| AppOpsManager.OPSTR_READ_SMS, AppOpsManager.OPSTR_WRITE_SMS); |
| } |
| |
| private void setModeForOps(String pkg, int mode, String... ops) throws Exception { |
| // We cannot reset these app ops to DEFAULT via current API, so we reset them manually here |
| // temporarily as we will rewrite how the default SMS app is setup later. |
| executeWithShellPermissionIdentity(() -> { |
| int uid = getPackageUid(pkg); |
| AppOpsManager appOpsManager = |
| getInstrumentation().getContext().getSystemService(AppOpsManager.class); |
| for (String op : ops) { |
| appOpsManager.setUidMode(op, uid, mode); |
| } |
| }); |
| } |
| |
| private int getPackageUid(String pkg) throws PackageManager.NameNotFoundException { |
| return getInstrumentation().getContext().getPackageManager().getPackageUid(pkg, 0); |
| } |
| |
| private String getSmsApp() throws Exception { |
| return executeWithShellPermissionIdentity(() -> getInstrumentation() |
| .getContext() |
| .getSystemService(RoleManager.class) |
| .getRoleHolders(RoleManager.ROLE_SMS) |
| .get(0)); |
| } |
| |
| private void setSmsApp(String pkg) throws Exception { |
| executeWithShellPermissionIdentity(() -> { |
| Context context = getInstrumentation().getContext(); |
| RoleManager roleManager = context.getSystemService(RoleManager.class); |
| CompletableFuture<Boolean> result = new CompletableFuture<>(); |
| if (roleManager.getRoleHoldersAsUser(RoleManager.ROLE_SMS, |
| context.getUser()).contains(pkg)) { |
| result.complete(true); |
| } else { |
| roleManager.addRoleHolderAsUser(RoleManager.ROLE_SMS, pkg, |
| RoleManager.MANAGE_HOLDERS_FLAG_DONT_KILL_APP, context.getUser(), |
| AsyncTask.THREAD_POOL_EXECUTOR, result::complete); |
| } |
| assertTrue(result.get(5, TimeUnit.SECONDS)); |
| }); |
| } |
| |
| private <T> T executeWithShellPermissionIdentity(Callable<T> callable) throws Exception { |
| if (sHasShellPermissionIdentity) { |
| return callable.call(); |
| } |
| UiAutomation uiAutomation = getInstrumentation().getUiAutomation( |
| UiAutomation.FLAG_DONT_SUPPRESS_ACCESSIBILITY_SERVICES); |
| uiAutomation.adoptShellPermissionIdentity(); |
| try { |
| sHasShellPermissionIdentity = true; |
| return callable.call(); |
| } finally { |
| uiAutomation.dropShellPermissionIdentity(); |
| sHasShellPermissionIdentity = false; |
| } |
| } |
| |
| private void executeWithShellPermissionIdentity(RunnableWithException runnable) |
| throws Exception { |
| executeWithShellPermissionIdentity(() -> { |
| runnable.run(); |
| return null; |
| }); |
| } |
| |
| private interface RunnableWithException { |
| void run() throws Exception; |
| } |
| |
| private void assertCanAccessSms(String pkg) throws Exception { |
| CompletableFuture<Bundle> callbackResult = new CompletableFuture<>(); |
| mContext.startActivity(new Intent() |
| .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK) |
| .setComponent(new ComponentName(pkg, pkg + ".MainActivity")) |
| .putExtra("callback", new RemoteCallback(callbackResult::complete))); |
| |
| Bundle bundle = callbackResult.get(20, TimeUnit.SECONDS); |
| |
| assertThat(bundle.getString("class"), startsWith(pkg)); |
| assertThat(bundle.getString("exceptionMessage"), anyOf(equalTo(null), emptyString())); |
| assertThat(bundle.getInt("queryCount"), greaterThan(0)); |
| } |
| |
| private void init() { |
| mSendReceiver.reset(); |
| mDeliveryReceiver.reset(); |
| mDataSmsReceiver.reset(); |
| mSmsDeliverReceiver.reset(); |
| mSmsReceivedReceiver.reset(); |
| mSmsRetrieverReceiver.reset(); |
| mReceivedDataSms = false; |
| sMessageId = 0L; |
| mSentIntent = PendingIntent.getBroadcast(mContext, 0, mSendIntent, |
| PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_MUTABLE_UNAUDITED); |
| mDeliveredIntent = PendingIntent.getBroadcast(mContext, 0, mDeliveryIntent, |
| PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_MUTABLE_UNAUDITED); |
| } |
| |
| /** |
| * Returns the number of parts sent in the message. If Multi-part SMS is not supported, |
| * returns 0. |
| */ |
| private int sendMultipartTextMessageIfSupported(String mccmnc, boolean addMessageId) { |
| int numPartsSent = 0; |
| if (!CarrierCapability.UNSUPPORT_MULTIPART_SMS_MESSAGES.contains(mccmnc)) { |
| init(); |
| ArrayList<String> parts = divideMessage(LONG_TEXT); |
| numPartsSent = parts.size(); |
| ArrayList<PendingIntent> sentIntents = new ArrayList<PendingIntent>(); |
| ArrayList<PendingIntent> deliveryIntents = new ArrayList<PendingIntent>(); |
| for (int i = 0; i < numPartsSent; i++) { |
| sentIntents.add(PendingIntent.getBroadcast(mContext, 0, mSendIntent, PendingIntent.FLAG_MUTABLE_UNAUDITED)); |
| deliveryIntents.add(PendingIntent.getBroadcast(mContext, 0, mDeliveryIntent, PendingIntent.FLAG_MUTABLE_UNAUDITED)); |
| } |
| sendMultiPartTextMessage(mDestAddr, parts, sentIntents, deliveryIntents, addMessageId); |
| } |
| return numPartsSent; |
| } |
| |
| private boolean sendDataMessageIfSupported(String mccmnc) { |
| if (!CarrierCapability.UNSUPPORT_DATA_SMS_MESSAGES.contains(mccmnc)) { |
| byte[] data = mText.getBytes(); |
| short port = 19989; |
| |
| init(); |
| sendDataMessage(mDestAddr, port, data, mSentIntent, mDeliveredIntent); |
| return true; |
| } |
| return false; |
| } |
| |
| @Test |
| public void testGetDefault() { |
| assertNotNull(getSmsManager()); |
| } |
| |
| @Test |
| public void testGetSetSmscAddress() { |
| String smsc = null; |
| try { |
| smsc = getSmsManager().getSmscAddress(); |
| fail("SmsManager.getSmscAddress() should throw a SecurityException"); |
| } catch (SecurityException e) { |
| // expected |
| } |
| |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity("android.permission.READ_PRIVILEGED_PHONE_STATE"); |
| try { |
| smsc = getSmsManager().getSmscAddress(); |
| } catch (SecurityException se) { |
| fail("Caller with READ_PRIVILEGED_PHONE_STATE should be able to call API"); |
| } finally { |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .dropShellPermissionIdentity(); |
| } |
| |
| try { |
| getSmsManager().setSmscAddress(smsc); |
| fail("SmsManager.setSmscAddress() should throw a SecurityException"); |
| } catch (SecurityException e) { |
| // expected |
| } |
| |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity("android.permission.MODIFY_PHONE_STATE"); |
| try { |
| getSmsManager().setSmscAddress(smsc); |
| } catch (SecurityException se) { |
| fail("Caller with MODIFY_PHONE_STATE should be able to call API"); |
| } finally { |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .dropShellPermissionIdentity(); |
| } |
| } |
| |
| @Test |
| public void testGetPremiumSmsConsent() { |
| try { |
| getSmsManager().getPremiumSmsConsent("fake package name"); |
| fail("SmsManager.getPremiumSmsConsent() should throw a SecurityException"); |
| } catch (SecurityException e) { |
| // expected |
| } |
| |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity("android.permission.READ_PRIVILEGED_PHONE_STATE"); |
| try { |
| getSmsManager().getPremiumSmsConsent("fake package name"); |
| fail("Caller with permission but only phone/system uid is allowed"); |
| } catch (SecurityException se) { |
| // expected |
| } finally { |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .dropShellPermissionIdentity(); |
| } |
| } |
| |
| @Test |
| public void testSetPremiumSmsConsent() { |
| try { |
| getSmsManager().setPremiumSmsConsent("fake package name", 0); |
| fail("SmsManager.setPremiumSmsConsent() should throw a SecurityException"); |
| } catch (SecurityException e) { |
| // expected |
| } |
| |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity("android.permission.MODIFY_PHONE_STATE"); |
| try { |
| getSmsManager().setPremiumSmsConsent("fake package name", 0); |
| fail("Caller with permission but only phone/system uid is allowed"); |
| } catch (SecurityException se) { |
| // expected |
| } finally { |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .dropShellPermissionIdentity(); |
| } |
| } |
| |
| /** |
| * Verify that SmsManager.getSmsCapacityOnIcc requires Permission. |
| * <p> |
| * Requires Permission: |
| * {@link android.Manifest.permission#READ_PHONE_STATE}. |
| */ |
| @Test |
| public void testGetSmsCapacityOnIcc() { |
| try { |
| getSmsManager().getSmsCapacityOnIcc(); |
| } catch (SecurityException e) { |
| fail("Caller with READ_PHONE_STATE should be able to call API"); |
| } |
| } |
| |
| @Test |
| public void testDisableCellBroadcastRange() { |
| try { |
| int ranType = SmsCbMessage.MESSAGE_FORMAT_3GPP; |
| executeWithShellPermissionIdentity(() -> { |
| getSmsManager().disableCellBroadcastRange( |
| CdmaSmsCbProgramData.CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, |
| CdmaSmsCbProgramData.CATEGORY_CMAS_EXTREME_THREAT, |
| ranType); |
| }); |
| } catch (Exception e) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testEnableCellBroadcastRange() { |
| try { |
| int ranType = SmsCbMessage.MESSAGE_FORMAT_3GPP; |
| executeWithShellPermissionIdentity(() -> { |
| getSmsManager().enableCellBroadcastRange( |
| CdmaSmsCbProgramData.CATEGORY_CMAS_PRESIDENTIAL_LEVEL_ALERT, |
| CdmaSmsCbProgramData.CATEGORY_CMAS_EXTREME_THREAT, |
| ranType); |
| }); |
| } catch (Exception e) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testResetAllCellBroadcastRanges() { |
| try { |
| executeWithShellPermissionIdentity(() -> { |
| getSmsManager().resetAllCellBroadcastRanges(); |
| }); |
| } catch (Exception e) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testCreateForSubscriptionId() { |
| int testSubId = 123; |
| SmsManager smsManager = mContext.getSystemService(SmsManager.class) |
| .createForSubscriptionId(testSubId); |
| assertEquals("getSubscriptionId() should be " + testSubId, testSubId, |
| smsManager.getSubscriptionId()); |
| } |
| |
| /** |
| * Verify the API will not throw any exception when READ_PRIVILEGED_PHONE_STATE is granted. |
| */ |
| @Test |
| public void testGetSmscIdentity() { |
| try { |
| mTelephonyManager.getHalVersion(TelephonyManager.HAL_SERVICE_RADIO); |
| } catch (IllegalStateException e) { |
| assumeNoException("Skipping test because Telephony service is null", e); |
| } |
| SmsManager smsManager = getSmsManager(); |
| ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(smsManager, |
| SmsManager::getSmscIdentity, Manifest.permission.READ_PRIVILEGED_PHONE_STATE); |
| } |
| |
| /** |
| * Verify the API will throw the SecurityException or not when no permissions are granted. |
| */ |
| @Test |
| public void testGetSmscIdentity_Exception() { |
| try { |
| mTelephonyManager.getHalVersion(TelephonyManager.HAL_SERVICE_RADIO); |
| } catch (IllegalStateException e) { |
| assumeNoException("Skipping test because Telephony service is null", e); |
| } |
| dropShellIdentity(); |
| try { |
| getSmsManager().getSmscIdentity(); |
| fail(); |
| } catch (SecurityException se) { |
| // API will throw SecurityException as no permission is granted to the caller |
| } |
| adoptShellIdentity(); |
| } |
| |
| protected ArrayList<String> divideMessage(String text) { |
| return getSmsManager().divideMessage(text); |
| } |
| |
| private android.telephony.SmsManager getSmsManager() { |
| return android.telephony.SmsManager.getDefault(); |
| } |
| |
| protected void sendMultiPartTextMessage(String destAddr, ArrayList<String> parts, |
| ArrayList<PendingIntent> sentIntents, ArrayList<PendingIntent> deliveryIntents, |
| boolean addMessageId) { |
| if (addMessageId) { |
| long fakeMessageId = 1278; |
| getSmsManager().sendMultipartTextMessage(destAddr, null, parts, sentIntents, |
| deliveryIntents, fakeMessageId); |
| } else if (mContext.getOpPackageName() != null) { |
| getSmsManager().sendMultipartTextMessage(destAddr, null, parts, sentIntents, |
| deliveryIntents, mContext.getOpPackageName(), mContext.getAttributionTag()); |
| } else { |
| getSmsManager().sendMultipartTextMessage(destAddr, null, parts, sentIntents, |
| deliveryIntents); |
| } |
| } |
| |
| protected void sendDataMessage(String destAddr,short port, byte[] data, PendingIntent sentIntent, PendingIntent deliveredIntent) { |
| getSmsManager().sendDataMessage(destAddr, null, port, data, sentIntent, deliveredIntent); |
| } |
| |
| protected void sendTextMessage(String destAddr, String text, PendingIntent sentIntent, |
| PendingIntent deliveredIntent) { |
| getSmsManager().sendTextMessage(destAddr, null, text, sentIntent, deliveredIntent); |
| } |
| |
| protected void sendTextMessageWithMessageId(String destAddr, String text, |
| PendingIntent sentIntent, PendingIntent deliveredIntent, long messageId) { |
| getSmsManager().sendTextMessage(destAddr, null, text, sentIntent, deliveredIntent, |
| messageId); |
| } |
| |
| private void blockNumber(String number) { |
| mBlockedNumberUri = insertBlockedNumber(mContext, number); |
| if (mBlockedNumberUri == null) { |
| fail("Failed to insert into blocked number provider."); |
| } |
| } |
| |
| private void unblockNumber(Uri uri) { |
| deleteBlockedNumber(mContext, uri); |
| } |
| |
| private void setDefaultSmsApp(boolean setToSmsApp) |
| throws Exception { |
| String command = String.format( |
| "appops set --user 0 %s WRITE_SMS %s", |
| mContext.getPackageName(), |
| setToSmsApp ? "allow" : "default"); |
| assertTrue("Setting default SMS app failed : " + setToSmsApp, |
| executeShellCommand(command).isEmpty()); |
| mTestAppSetAsDefaultSmsApp = setToSmsApp; |
| } |
| |
| private String executeShellCommand(String command) |
| throws IOException { |
| ParcelFileDescriptor pfd = |
| getInstrumentation().getUiAutomation().executeShellCommand(command); |
| BufferedReader br = null; |
| try (InputStream in = new FileInputStream(pfd.getFileDescriptor());) { |
| br = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8)); |
| String str; |
| StringBuilder out = new StringBuilder(); |
| while ((str = br.readLine()) != null) { |
| out.append(str); |
| } |
| return out.toString(); |
| } finally { |
| if (br != null) { |
| br.close(); |
| } |
| } |
| } |
| |
| private static class SmsBroadcastReceiver extends BroadcastReceiver { |
| private int mCalls; |
| private int mExpectedCalls; |
| private String mAction; |
| private Object mLock; |
| |
| SmsBroadcastReceiver(String action) { |
| mAction = action; |
| reset(); |
| mLock = new Object(); |
| } |
| |
| void reset() { |
| mExpectedCalls = Integer.MAX_VALUE; |
| mCalls = 0; |
| } |
| |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| if(mAction.equals(DATA_SMS_RECEIVED_ACTION)){ |
| StringBuilder sb = new StringBuilder(); |
| Bundle bundle = intent.getExtras(); |
| if (bundle != null) { |
| Object[] obj = (Object[]) bundle.get("pdus"); |
| String format = bundle.getString("format"); |
| SmsMessage[] message = new SmsMessage[obj.length]; |
| for (int i = 0; i < obj.length; i++) { |
| message[i] = SmsMessage.createFromPdu((byte[]) obj[i], format); |
| } |
| |
| for (SmsMessage currentMessage : message) { |
| byte[] binaryContent = currentMessage.getUserData(); |
| String readableContent = new String(binaryContent); |
| sb.append(readableContent); |
| } |
| } |
| mReceivedDataSms = true; |
| mReceivedText=sb.toString(); |
| } |
| if (mAction.equals(Telephony.Sms.Intents.SMS_RECEIVED_ACTION)) { |
| sMessageId = intent.getLongExtra("messageId", 0L); |
| } |
| Log.i(TAG, "onReceive " + intent.getAction() + ", mAction " + mAction); |
| if (intent.getAction().equals(mAction)) { |
| synchronized (mLock) { |
| mCalls += 1; |
| mLock.notify(); |
| } |
| } |
| } |
| |
| public boolean verifyNoCalls(long timeout) throws InterruptedException { |
| synchronized(mLock) { |
| mLock.wait(timeout); |
| return mCalls == 0; |
| } |
| } |
| |
| public boolean waitForCalls(int expectedCalls, long timeout) throws InterruptedException { |
| synchronized(mLock) { |
| mExpectedCalls = expectedCalls; |
| long startTime = SystemClock.elapsedRealtime(); |
| |
| while (mCalls < mExpectedCalls) { |
| long waitTime = timeout - (SystemClock.elapsedRealtime() - startTime); |
| if (waitTime > 0) { |
| mLock.wait(waitTime); |
| } else { |
| return false; // timed out |
| } |
| } |
| return true; // success |
| } |
| } |
| } |
| |
| /** |
| * Adopts shell permission identity |
| */ |
| private static void adoptShellIdentity() { |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .adoptShellPermissionIdentity(); |
| } |
| |
| /** |
| * Drop shell permission identity |
| */ |
| private static void dropShellIdentity() { |
| InstrumentationRegistry.getInstrumentation().getUiAutomation() |
| .dropShellPermissionIdentity(); |
| } |
| } |
