Snap for 10447354 from 0a1ab1245ef3f64593d270f8cd5217a823e51c0c to mainline-networking-release
Change-Id: I86df64110ca453c97195d8a288c08b60de74f050
diff --git a/Android.bp b/Android.bp
index e7e78ae..b586dc6 100644
--- a/Android.bp
+++ b/Android.bp
@@ -19,6 +19,21 @@
default_applicable_licenses: ["Android-Apache-2.0"],
}
+genrule {
+ name: "statslog-mms-java-gen",
+ tools: ["stats-log-api-gen"],
+ cmd: "$(location stats-log-api-gen) --java $(out) --module mms"
+ + " --javaPackage com.android.mms --javaClass MmsStatsLog",
+ out: ["com/android/mms/MmsStatsLog.java"],
+}
+
+java_library {
+ name: "mms-statsd",
+ srcs: [
+ ":statslog-mms-java-gen",
+ ],
+}
+
android_app {
name: "MmsService",
platform_apis: true,
@@ -30,4 +45,16 @@
proguard_flags_files: ["proguard.flags"],
},
certificate: "platform",
+ static_libs: [
+ "mms-protos-lite",
+ "mms-statsd",
+ "androidx.annotation_annotation",
+ ],
+}
+
+filegroup {
+ name: "mms-service-srcs",
+ srcs: [
+ "src/com/android/mms/service/**/*.java",
+ ],
}
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 87e7947..a19a11a 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -26,6 +26,10 @@
<uses-permission android:name="android.permission.BROADCAST_WAP_PUSH"/>
<uses-permission android:name="android.permission.BIND_CARRIER_SERVICES"/>
<uses-permission android:name="android.permission.INTERACT_ACROSS_USERS"/>
+ <!-- Needed to check if subscription is active. -->
+ <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
+ <!-- Needed to query user associated with a subscription. -->
+ <uses-permission android:name="android.permission.MANAGE_SUBSCRIPTION_USER_ASSOCIATION"/>
<protected-broadcast android:name="android.settings.ENABLE_MMS_DATA_REQUEST"/>
diff --git a/proto/Android.bp b/proto/Android.bp
new file mode 100644
index 0000000..b55e987
--- /dev/null
+++ b/proto/Android.bp
@@ -0,0 +1,29 @@
+/*
+ * 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 {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+ }
+
+ java_library_static {
+ name: "mms-protos-lite",
+ proto: {
+ type: "lite",
+ },
+ sdk_version: "system_current",
+ min_sdk_version: "33",
+ srcs: ["src/persist_mms_atoms.proto"],
+ }
\ No newline at end of file
diff --git a/proto/src/persist_mms_atoms.proto b/proto/src/persist_mms_atoms.proto
new file mode 100644
index 0000000..bde1cb9
--- /dev/null
+++ b/proto/src/persist_mms_atoms.proto
@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+
+syntax = "proto2";
+
+package com.android.mms;
+option java_package = "com.android.mms";
+option java_outer_classname = "PersistMmsAtomsProto";
+option java_multiple_files = true;
+
+message PersistMmsAtoms {
+ /* Last Android build fingerprint. This usually changes after system OTA. */
+ optional string build_fingerprint = 1;
+
+ /* Incoming MMS statistics and information. */
+ repeated IncomingMms incoming_mms = 2;
+
+ /* Timestamp of last incoming_mms pull. */
+ optional int64 incoming_mms_pull_timestamp_millis = 3;
+
+ /* Outgoing MMS statistics and information. */
+ repeated OutgoingMms outgoing_mms = 4;
+
+ /* Timestamp of last outgoing_mms pull. */
+ optional int64 outgoing_mms_pull_timestamp_millis = 5;
+}
+
+message IncomingMms {
+ optional int32 rat = 1;
+ optional int32 result = 2;
+ optional int32 roaming = 3;
+ optional int32 sim_slot_index = 4;
+ optional bool is_multi_sim = 5;
+ optional bool is_esim = 6;
+ optional int32 carrier_id = 7;
+ optional int64 avg_interval_millis = 8;
+ optional int64 mms_count = 9;
+ optional int32 retry_id = 10;
+ optional bool handled_by_carrier_app = 11;
+ optional bool is_managed_profile = 12;
+}
+
+message OutgoingMms {
+ optional int32 rat = 1;
+ optional int32 result = 2;
+ optional int32 roaming = 3;
+ optional int32 sim_slot_index = 4;
+ optional bool is_multi_sim = 5;
+ optional bool is_esim = 6;
+ optional int32 carrier_id = 7;
+ optional int64 avg_interval_millis = 8;
+ optional int64 mms_count = 9;
+ optional bool is_from_default_app = 10;
+ optional int32 retry_id = 11;
+ optional bool handled_by_carrier_app = 12;
+ optional bool is_managed_profile = 13;
+}
diff --git a/src/com/android/mms/service/DownloadRequest.java b/src/com/android/mms/service/DownloadRequest.java
index 0f12415..62fa9e6 100644
--- a/src/com/android/mms/service/DownloadRequest.java
+++ b/src/com/android/mms/service/DownloadRequest.java
@@ -38,6 +38,8 @@
import android.text.TextUtils;
import com.android.mms.service.exception.MmsHttpException;
+import com.android.mms.service.metrics.MmsStats;
+
import com.google.android.mms.MmsException;
import com.google.android.mms.pdu.GenericPdu;
import com.google.android.mms.pdu.PduHeaders;
@@ -59,8 +61,8 @@
public DownloadRequest(RequestManager manager, int subId, String locationUrl,
Uri contentUri, PendingIntent downloadedIntent, String creator,
- Bundle configOverrides, Context context, long messageId) {
- super(manager, subId, creator, configOverrides, context, messageId);
+ Bundle configOverrides, Context context, long messageId, MmsStats mmsStats) {
+ super(manager, subId, creator, configOverrides, context, messageId, mmsStats);
mLocationUrl = locationUrl;
mDownloadedIntent = downloadedIntent;
mContentUri = contentUri;
@@ -296,10 +298,12 @@
if (mCarrierMessagingServiceWrapper.bindToCarrierMessagingService(
context, carrierMessagingServicePackage, Runnable::run,
()->onServiceReady())) {
- LogUtil.v("bindService() for carrier messaging service succeeded. "
+ LogUtil.v("bindService() for carrier messaging service: "
+ + carrierMessagingServicePackage + " succeeded. "
+ MmsService.formatCrossStackMessageId(mMessageId));
} else {
- LogUtil.e("bindService() for carrier messaging service failed. "
+ LogUtil.e("bindService() for carrier messaging service: "
+ + carrierMessagingServicePackage + " failed. "
+ MmsService.formatCrossStackMessageId(mMessageId));
carrierDownloadCallback.onDownloadMmsComplete(
CarrierMessagingService.DOWNLOAD_STATUS_RETRY_ON_CARRIER_NETWORK);
diff --git a/src/com/android/mms/service/MmsConstants.java b/src/com/android/mms/service/MmsConstants.java
new file mode 100644
index 0000000..57ef5df
--- /dev/null
+++ b/src/com/android/mms/service/MmsConstants.java
@@ -0,0 +1,25 @@
+/*
+ * 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.mms.service;
+
+import java.util.UUID;
+
+public class MmsConstants {
+ // MMS anomaly uuid
+ public static final UUID MMS_ANOMALY_UUID = UUID.fromString(
+ "e4330975-17be-43b7-87d6-d9f281d33278");
+}
diff --git a/src/com/android/mms/service/MmsHttpClient.java b/src/com/android/mms/service/MmsHttpClient.java
index 5cec66f..b54b1aa 100644
--- a/src/com/android/mms/service/MmsHttpClient.java
+++ b/src/com/android/mms/service/MmsHttpClient.java
@@ -52,6 +52,8 @@
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import com.android.internal.annotations.VisibleForTesting;
+
/**
* MMS HTTP client for sending and downloading MMS messages
*/
@@ -452,6 +454,21 @@
return sb.toString();
}
+ private static String getPhoneNumberForMacroLine1(TelephonyManager telephonyManager,
+ Context context, int subId) {
+ String phoneNo = telephonyManager.getLine1Number();
+ if (TextUtils.isEmpty(phoneNo)) {
+ SubscriptionManager subscriptionManager = context.getSystemService(
+ SubscriptionManager.class);
+ if (subscriptionManager != null) {
+ phoneNo = subscriptionManager.getPhoneNumber(subId);
+ } else {
+ LogUtil.e("subscriptionManager is null");
+ }
+ }
+ return phoneNo;
+ }
+
/*
* Macro names
*/
@@ -471,15 +488,16 @@
* @param subId The subscription ID used to get line number, etc.
* @return The value of the defined macro
*/
- private static String getMacroValue(Context context, String macro, Bundle mmsConfig,
- int subId) {
+ @VisibleForTesting
+ public static String getMacroValue(Context context, String macro, Bundle mmsConfig,
+ int subId) {
final TelephonyManager telephonyManager = ((TelephonyManager) context.getSystemService(
Context.TELEPHONY_SERVICE)).createForSubscriptionId(subId);
if (MACRO_LINE1.equals(macro)) {
- return telephonyManager.getLine1Number();
+ return getPhoneNumberForMacroLine1(telephonyManager, context, subId);
} else if (MACRO_LINE1NOCOUNTRYCODE.equals(macro)) {
return PhoneUtils.getNationalNumber(telephonyManager,
- telephonyManager.getLine1Number());
+ getPhoneNumberForMacroLine1(telephonyManager, context, subId));
} else if (MACRO_NAI.equals(macro)) {
return getNai(telephonyManager, mmsConfig);
}
diff --git a/src/com/android/mms/service/MmsNetworkManager.java b/src/com/android/mms/service/MmsNetworkManager.java
index 6799d29..f21e510 100644
--- a/src/com/android/mms/service/MmsNetworkManager.java
+++ b/src/com/android/mms/service/MmsNetworkManager.java
@@ -26,11 +26,16 @@
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.net.TelephonyNetworkSpecifier;
+import android.os.Binder;
import android.os.Handler;
import android.os.Looper;
+import android.os.Message;
+import android.os.PersistableBundle;
import android.provider.DeviceConfig;
+import android.telephony.CarrierConfigManager;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
+import android.util.Log;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.PhoneConstants;
@@ -52,9 +57,8 @@
// timeout to make sure we don't bail prematurely.
private static final int ADDITIONAL_NETWORK_ACQUIRE_TIMEOUT_MILLIS = (5 * 1000);
- // Waiting time used before releasing a network prematurely. This allows the MMS download
- // acknowledgement messages to be sent using the same network that was used to download the data
- private static final int NETWORK_RELEASE_TIMEOUT_MILLIS = 5 * 1000;
+ /* Event created when receiving ACTION_CARRIER_CONFIG_CHANGED */
+ private static final int EVENT_CARRIER_CONFIG_CHANGED = 1;
private final Context mContext;
@@ -88,17 +92,43 @@
private int mPhoneId;
// If ACTION_SIM_CARD_STATE_CHANGED intent receiver is registered
- private boolean mReceiverRegistered;
+ private boolean mSimCardStateChangedReceiverRegistered;
private final Dependencies mDeps;
+ private int mNetworkReleaseTimeoutMillis;
+ private EventHandler mEventHandler;
+
+ private final class EventHandler extends Handler {
+ EventHandler() {
+ super(Looper.getMainLooper());
+ }
+
+ /**
+ * Handles events coming from the phone stack. Overridden from handler.
+ *
+ * @param msg the message to handle
+ */
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case EVENT_CARRIER_CONFIG_CHANGED:
+ // Reload mNetworkReleaseTimeoutMillis from CarrierConfigManager.
+ handleCarrierConfigChanged();
+ break;
+ default:
+ LogUtil.e("MmsNetworkManager: ignoring message of unexpected type " + msg.what);
+ }
+ }
+ }
+
/**
* This receiver listens to ACTION_SIM_CARD_STATE_CHANGED after starting a new NetworkRequest.
* If ACTION_SIM_CARD_STATE_CHANGED with SIM_STATE_ABSENT for a SIM card corresponding to the
* current NetworkRequest is received, it just releases the NetworkRequest without waiting for
* timeout.
*/
- private final BroadcastReceiver mReceiver =
+ private final BroadcastReceiver mSimCardStateChangedReceiver =
new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
@@ -140,6 +170,35 @@
}
/**
+ * This receiver listens to ACTION_CARRIER_CONFIG_CHANGED. Whenever receiving this event,
+ * mNetworkReleaseTimeoutMillis needs to be reloaded from CarrierConfigManager.
+ */
+ private final BroadcastReceiver mCarrierConfigChangedReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ final String action = intent.getAction();
+ if (CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED.equals(action)
+ && mSubId == intent.getIntExtra(
+ CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX,
+ SubscriptionManager.DEFAULT_SUBSCRIPTION_ID)) {
+ mEventHandler.sendMessage(mEventHandler.obtainMessage(
+ EVENT_CARRIER_CONFIG_CHANGED));
+ }
+ }
+ };
+
+ private void handleCarrierConfigChanged() {
+ final CarrierConfigManager configManager =
+ (CarrierConfigManager)
+ mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE);
+ final PersistableBundle config = configManager.getConfigForSubId(mSubId);
+ mNetworkReleaseTimeoutMillis =
+ config.getInt(CarrierConfigManager.KEY_MMS_NETWORK_RELEASE_TIMEOUT_MILLIS_INT);
+ LogUtil.d("MmsNetworkManager: handleCarrierConfigChanged() mNetworkReleaseTimeoutMillis "
+ + mNetworkReleaseTimeoutMillis);
+ }
+
+ /**
* Network callback for our network request
*/
private class NetworkRequestCallback extends ConnectivityManager.NetworkCallback {
@@ -245,6 +304,13 @@
}
}
};
+
+ mEventHandler = new EventHandler();
+ // Register a receiver to listen to ACTION_CARRIER_CONFIG_CHANGED
+ mContext.registerReceiver(
+ mCarrierConfigChangedReceiver,
+ new IntentFilter(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED));
+ handleCarrierConfigChanged();
}
public MmsNetworkManager(Context context, int subId) {
@@ -270,7 +336,7 @@
return;
}
- if (!mReceiverRegistered) {
+ if (!mSimCardStateChangedReceiverRegistered) {
mPhoneId = mDeps.getPhoneId(mSubId);
if (mPhoneId == SubscriptionManager.INVALID_PHONE_INDEX
|| mPhoneId == SubscriptionManager.DEFAULT_PHONE_INDEX) {
@@ -279,9 +345,9 @@
// Register a receiver to listen to ACTION_SIM_CARD_STATE_CHANGED
mContext.registerReceiver(
- mReceiver,
+ mSimCardStateChangedReceiver,
new IntentFilter(TelephonyManager.ACTION_SIM_CARD_STATE_CHANGED));
- mReceiverRegistered = true;
+ mSimCardStateChangedReceiverRegistered = true;
}
// Not available, so start a new request if not done yet
@@ -297,10 +363,10 @@
LogUtil.w(requestId, "MmsNetworkManager: acquire network wait interrupted");
}
- if (mReceiverRegistered) {
+ if (mSimCardStateChangedReceiverRegistered) {
// Unregister the receiver.
- mContext.unregisterReceiver(mReceiver);
- mReceiverRegistered = false;
+ mContext.unregisterReceiver(mSimCardStateChangedReceiver);
+ mSimCardStateChangedReceiverRegistered = false;
}
if (mNetwork != null) {
@@ -328,10 +394,11 @@
/**
* Release the MMS network when nobody is holding on to it.
*
- * @param requestId request ID for logging
- * @param shouldDelayRelease whether the release should be delayed for 5 seconds, the regular
- * use case is to delay this for DownloadRequests to use the network
- * for sending an acknowledgement on the same network
+ * @param requestId request ID for logging.
+ * @param shouldDelayRelease whether the release should be delayed for a carrier-configured
+ * timeout (default 5 seconds), the regular use case is to delay this
+ * for DownloadRequests to use the network for sending an
+ * acknowledgement on the same network.
*/
public void releaseNetwork(final String requestId, final boolean shouldDelayRelease) {
synchronized (this) {
@@ -344,7 +411,7 @@
// handler to release the network
mReleaseHandler.removeCallbacks(mNetworkReleaseTask);
mReleaseHandler.postDelayed(mNetworkReleaseTask,
- NETWORK_RELEASE_TIMEOUT_MILLIS);
+ mNetworkReleaseTimeoutMillis);
} else {
releaseRequestLocked(mNetworkCallback);
}
@@ -443,4 +510,9 @@
}
return apnName;
}
+
+ @VisibleForTesting
+ protected int getNetworkReleaseTimeoutMillis() {
+ return mNetworkReleaseTimeoutMillis;
+ }
}
diff --git a/src/com/android/mms/service/MmsRequest.java b/src/com/android/mms/service/MmsRequest.java
index dfef1cc..dca77df 100644
--- a/src/com/android/mms/service/MmsRequest.java
+++ b/src/com/android/mms/service/MmsRequest.java
@@ -39,6 +39,7 @@
import com.android.mms.service.exception.ApnException;
import com.android.mms.service.exception.MmsHttpException;
import com.android.mms.service.exception.MmsNetworkException;
+import com.android.mms.service.metrics.MmsStats;
import java.util.UUID;
@@ -49,8 +50,6 @@
private static final int RETRY_TIMES = 3;
// Signal level threshold for both wifi and cellular
private static final int SIGNAL_LEVEL_THRESHOLD = 2;
- // MMS anomaly uuid
- private final UUID mAnomalyUUID = UUID.fromString("e4330975-17be-43b7-87d6-d9f281d33278");
public static final String EXTRA_LAST_CONNECTION_FAILURE_CAUSE_CODE
= "android.telephony.extra.LAST_CONNECTION_FAILURE_CAUSE_CODE";
public static final String EXTRA_HANDLED_BY_CARRIER_APP
@@ -101,6 +100,7 @@
protected Context mContext;
protected long mMessageId;
protected int mLastConnectionFailure;
+ private MmsStats mMmsStats;
class MonitorTelephonyCallback extends TelephonyCallback implements
TelephonyCallback.PreciseDataConnectionStateListener {
@@ -121,13 +121,14 @@
}
public MmsRequest(RequestManager requestManager, int subId, String creator,
- Bundle mmsConfig, Context context, long messageId) {
+ Bundle mmsConfig, Context context, long messageId, MmsStats mmsStats) {
mRequestManager = requestManager;
mSubId = subId;
mCreator = creator;
mMmsConfig = mmsConfig;
mContext = context;
mMessageId = messageId;
+ mMmsStats = mmsStats;
}
public int getSubId() {
@@ -146,6 +147,7 @@
int result = SmsManager.MMS_ERROR_UNSPECIFIED;
int httpStatusCode = 0;
byte[] response = null;
+ int retryId = 0;
// TODO: add mms data channel check back to fast fail if no way to send mms,
// when telephony provides such API.
if (!prepareForHttpRequest()) { // Prepare request, like reading pdu data from user
@@ -154,7 +156,7 @@
} else { // Execute
long retryDelaySecs = 2;
// Try multiple times of MMS HTTP request, depending on the error.
- for (int i = 0; i < RETRY_TIMES; i++) {
+ for (retryId = 0; retryId < RETRY_TIMES; retryId++) {
httpStatusCode = 0; // Clear for retry.
MonitorTelephonyCallback connectionStateCallback = new MonitorTelephonyCallback();
try {
@@ -212,7 +214,8 @@
retryDelaySecs <<= 1;
}
}
- processResult(context, result, response, httpStatusCode, /* handledByCarrierApp= */ false);
+ processResult(context, result, response, httpStatusCode, /* handledByCarrierApp= */ false,
+ retryId);
}
private void listenToDataConnectionState(MonitorTelephonyCallback connectionStateCallback) {
@@ -240,6 +243,11 @@
*/
public void processResult(Context context, int result, byte[] response, int httpStatusCode,
boolean handledByCarrierApp) {
+ processResult(context, result, response, httpStatusCode, handledByCarrierApp, 0);
+ }
+
+ private void processResult(Context context, int result, byte[] response, int httpStatusCode,
+ boolean handledByCarrierApp, int retryId) {
final Uri messageUri = persistIfRequired(context, result, response);
final String requestId = this.getRequestId();
@@ -276,6 +284,7 @@
}
reportPossibleAnomaly(result, httpStatusCode);
pendingIntent.send(context, result, fillIn);
+ mMmsStats.addAtomToStorage(result, retryId, handledByCarrierApp);
} catch (PendingIntent.CanceledException e) {
LogUtil.e(requestId, "Sending pending intent canceled", e);
}
@@ -314,8 +323,9 @@
private UUID generateUUID(int result, int httpStatusCode) {
long lresult = result;
long lhttpStatusCode = httpStatusCode;
- return new UUID(mAnomalyUUID.getMostSignificantBits(),
- mAnomalyUUID.getLeastSignificantBits() + ((lhttpStatusCode << 32) + lresult));
+ return new UUID(MmsConstants.MMS_ANOMALY_UUID.getMostSignificantBits(),
+ MmsConstants.MMS_ANOMALY_UUID.getLeastSignificantBits()
+ + ((lhttpStatusCode << 32) + lresult));
}
private boolean isPoorSignal() {
diff --git a/src/com/android/mms/service/MmsService.java b/src/com/android/mms/service/MmsService.java
index d227b3c..ee88f09 100644
--- a/src/com/android/mms/service/MmsService.java
+++ b/src/com/android/mms/service/MmsService.java
@@ -41,6 +41,7 @@
import android.provider.Telephony;
import android.security.NetworkSecurityPolicy;
import android.service.carrier.CarrierMessagingService;
+import android.telephony.AnomalyReporter;
import android.telephony.SmsManager;
import android.telephony.SubscriptionInfo;
import android.telephony.SubscriptionManager;
@@ -51,6 +52,8 @@
import android.util.SparseArray;
import com.android.internal.telephony.IMms;
+import com.android.mms.service.metrics.MmsMetricsCollector;
+import com.android.mms.service.metrics.MmsStats;
import com.google.android.mms.MmsException;
import com.google.android.mms.pdu.DeliveryInd;
@@ -138,6 +141,8 @@
// 1: download queue
private final ExecutorService[] mRunningRequestExecutors = new ExecutorService[2];
+ private static MmsMetricsCollector mMmsMetricsCollector;
+
private MmsNetworkManager getNetworkManager(int subId) {
synchronized (mNetworkManagerCache) {
MmsNetworkManager manager = mNetworkManagerCache.get(subId);
@@ -179,6 +184,8 @@
List<String> carrierPackages = telephonyManager.getCarrierPackageNamesForIntent(intent);
if (carrierPackages == null || carrierPackages.size() != 1) {
+ LogUtil.d("getCarrierMessagingServicePackageIfExists - multiple ("
+ + carrierPackages.size() + ") carrier apps installed, not using any.");
return null;
} else {
return carrierPackages.get(0);
@@ -211,19 +218,24 @@
LogUtil.d("sendMessage " + formatCrossStackMessageId(messageId));
enforceSystemUid();
+ MmsStats mmsStats = new MmsStats(MmsService.this,
+ mMmsMetricsCollector.getAtomsStorage(), subId, getTelephonyManager(subId),
+ callingPkg, false);
+
// Make sure the subId is correct
if (!SubscriptionManager.isValidSubscriptionId(subId)) {
LogUtil.e("Invalid subId " + subId);
- sendErrorInPendingIntent(sentIntent, SmsManager.MMS_ERROR_INVALID_SUBSCRIPTION_ID);
+ handleError(sentIntent, SmsManager.MMS_ERROR_INVALID_SUBSCRIPTION_ID, mmsStats);
return;
}
if (subId == SubscriptionManager.DEFAULT_SUBSCRIPTION_ID) {
subId = SubscriptionManager.getDefaultSmsSubscriptionId();
+ mmsStats.updateSubId(subId, getTelephonyManager(subId));
}
// Make sure the subId is active
if (!isActiveSubId(subId)) {
- sendErrorInPendingIntent(sentIntent, SmsManager.MMS_ERROR_INACTIVE_SUBSCRIPTION);
+ handleError(sentIntent, SmsManager.MMS_ERROR_INACTIVE_SUBSCRIPTION, mmsStats);
return;
}
@@ -231,7 +243,7 @@
Bundle mmsConfig = loadMmsConfig(subId);
if (mmsConfig == null) {
LogUtil.e("MMS config is not loaded yet for subId " + subId);
- sendErrorInPendingIntent(sentIntent, SmsManager.MMS_ERROR_CONFIGURATION_ERROR);
+ handleError(sentIntent, SmsManager.MMS_ERROR_CONFIGURATION_ERROR, mmsStats);
return;
}
@@ -243,19 +255,21 @@
// Make sure MMS is enabled
if (!mmsConfig.getBoolean(SmsManager.MMS_CONFIG_MMS_ENABLED)) {
LogUtil.e("MMS is not enabled for subId " + subId);
- sendErrorInPendingIntent(sentIntent, SmsManager.MMS_ERROR_CONFIGURATION_ERROR);
+ handleError(sentIntent, SmsManager.MMS_ERROR_CONFIGURATION_ERROR, mmsStats);
return;
}
final SendRequest request = new SendRequest(MmsService.this, subId, contentUri,
- locationUrl, sentIntent, callingPkg, mmsConfig, MmsService.this, messageId);
+ locationUrl, sentIntent, callingPkg, mmsConfig, MmsService.this,
+ messageId, mmsStats);
final String carrierMessagingServicePackage =
getCarrierMessagingServicePackageIfExists(subId);
if (carrierMessagingServicePackage != null) {
- LogUtil.d(request.toString(), "sending message by carrier app "
- + formatCrossStackMessageId(messageId));
+ LogUtil.d(request.toString(), "sending message by carrier app: "
+ + carrierMessagingServicePackage
+ + " " + formatCrossStackMessageId(messageId));
request.trySendingByCarrierApp(MmsService.this, carrierMessagingServicePackage);
return;
}
@@ -269,7 +283,7 @@
// AcknowledgeInd and NotifyRespInd are parts of downloading sequence.
// TODO: Should consider ReadRecInd(Read Report)?
sendSettingsIntentForFailedMms(!isRawPduSendReq(contentUri), subId);
- sendErrorInPendingIntent(sentIntent, SmsManager.MMS_ERROR_NO_DATA_NETWORK);
+ handleError(sentIntent, SmsManager.MMS_ERROR_NO_DATA_NETWORK, mmsStats);
return;
}
@@ -288,22 +302,27 @@
enforceSystemUid();
+ MmsStats mmsStats = new MmsStats(MmsService.this,
+ mMmsMetricsCollector.getAtomsStorage(), subId, getTelephonyManager(subId),
+ callingPkg, true);
+
// Make sure the subId is correct
if (!SubscriptionManager.isValidSubscriptionId(subId)) {
LogUtil.e("Invalid subId " + subId);
- sendErrorInPendingIntent(downloadedIntent,
- SmsManager.MMS_ERROR_INVALID_SUBSCRIPTION_ID);
+ handleError(downloadedIntent, SmsManager.MMS_ERROR_INVALID_SUBSCRIPTION_ID,
+ mmsStats);
return;
}
if (subId == SubscriptionManager.DEFAULT_SUBSCRIPTION_ID) {
subId = SubscriptionManager.getDefaultSmsSubscriptionId();
+ mmsStats.updateSubId(subId, getTelephonyManager(subId));
}
if (!isActiveSubId(subId)) {
List<SubscriptionInfo> activeSubList = getActiveSubscriptionsInGroup(subId);
if (activeSubList.isEmpty()) {
- sendErrorInPendingIntent(downloadedIntent,
- SmsManager.MMS_ERROR_INACTIVE_SUBSCRIPTION);
+ handleError(downloadedIntent, SmsManager.MMS_ERROR_INACTIVE_SUBSCRIPTION,
+ mmsStats);
return;
}
@@ -317,13 +336,13 @@
}
}
}
+ mmsStats.updateSubId(subId, getTelephonyManager(subId));
// Load MMS config
Bundle mmsConfig = loadMmsConfig(subId);
if (mmsConfig == null) {
LogUtil.e("MMS config is not loaded yet for subId " + subId);
- sendErrorInPendingIntent(
- downloadedIntent, SmsManager.MMS_ERROR_CONFIGURATION_ERROR);
+ handleError(downloadedIntent, SmsManager.MMS_ERROR_CONFIGURATION_ERROR, mmsStats);
return;
}
@@ -335,21 +354,21 @@
// Make sure MMS is enabled
if (!mmsConfig.getBoolean(SmsManager.MMS_CONFIG_MMS_ENABLED)) {
LogUtil.e("MMS is not enabled for subId " + subId);
- sendErrorInPendingIntent(
- downloadedIntent, SmsManager.MMS_ERROR_CONFIGURATION_ERROR);
+ handleError(downloadedIntent, SmsManager.MMS_ERROR_CONFIGURATION_ERROR, mmsStats);
return;
}
final DownloadRequest request = new DownloadRequest(MmsService.this, subId, locationUrl,
contentUri, downloadedIntent, callingPkg, mmsConfig, MmsService.this,
- messageId);
+ messageId, mmsStats);
final String carrierMessagingServicePackage =
getCarrierMessagingServicePackageIfExists(subId);
if (carrierMessagingServicePackage != null) {
- LogUtil.d(request.toString(), "downloading message by carrier app "
- + formatCrossStackMessageId(messageId));
+ LogUtil.d(request.toString(), "downloading message by carrier app: "
+ + carrierMessagingServicePackage
+ + " " + formatCrossStackMessageId(messageId));
request.tryDownloadingByCarrierApp(MmsService.this, carrierMessagingServicePackage);
return;
}
@@ -357,7 +376,7 @@
// Make sure subId has MMS data
if (!getTelephonyManager(subId).isDataEnabledForApn(ApnSetting.TYPE_MMS)) {
sendSettingsIntentForFailedMms(/*isIncoming=*/ true, subId);
- sendErrorInPendingIntent(downloadedIntent, SmsManager.MMS_ERROR_DATA_DISABLED);
+ handleError(downloadedIntent, SmsManager.MMS_ERROR_DATA_DISABLED, mmsStats);
return;
}
@@ -577,6 +596,14 @@
}
return false;
}
+
+ private void handleError(@Nullable PendingIntent pendingIntent, int resultCode,
+ MmsStats mmsStats) {
+ sendErrorInPendingIntent(pendingIntent, resultCode);
+ mmsStats.addAtomToStorage(resultCode);
+ String message = "MMS failed" + " with error " + resultCode;
+ AnomalyReporter.reportAnomaly(MmsConstants.MMS_ANOMALY_UUID, message);
+ }
};
@Override
@@ -703,6 +730,9 @@
NetworkSecurityPolicy.getInstance().setCleartextTrafficPermitted(true);
+ // Registers statsd pullers
+ mMmsMetricsCollector = new MmsMetricsCollector(this);
+
// Initialize running request state
for (int i = 0; i < mRunningRequestExecutors.length; i++) {
mRunningRequestExecutors[i] = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
diff --git a/src/com/android/mms/service/SendRequest.java b/src/com/android/mms/service/SendRequest.java
index 67c368d..4f97d84 100644
--- a/src/com/android/mms/service/SendRequest.java
+++ b/src/com/android/mms/service/SendRequest.java
@@ -25,17 +25,21 @@
import android.os.AsyncTask;
import android.os.Binder;
import android.os.Bundle;
+import android.os.UserHandle;
import android.provider.BlockedNumberContract;
import android.provider.Telephony;
import android.service.carrier.CarrierMessagingService;
import android.service.carrier.CarrierMessagingServiceWrapper;
import android.telephony.SmsManager;
+import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import com.android.internal.telephony.SmsApplication;
import com.android.internal.telephony.SmsNumberUtils;
import com.android.mms.service.exception.MmsHttpException;
+import com.android.mms.service.metrics.MmsStats;
+
import com.google.android.mms.MmsException;
import com.google.android.mms.pdu.EncodedStringValue;
import com.google.android.mms.pdu.GenericPdu;
@@ -58,8 +62,8 @@
public SendRequest(RequestManager manager, int subId, Uri contentUri, String locationUrl,
PendingIntent sentIntent, String creator, Bundle configOverrides, Context context,
- long messageId) {
- super(manager, subId, creator, configOverrides, context, messageId);
+ long messageId, MmsStats mmsStats) {
+ super(manager, subId, creator, configOverrides, context, messageId, mmsStats);
mPduUri = contentUri;
mPduData = null;
mLocationUrl = locationUrl;
@@ -172,10 +176,22 @@
@Override
protected Uri persistIfRequired(Context context, int result, byte[] response) {
final String requestId = getRequestId();
- if (!SmsApplication.shouldWriteMessageForPackage(mCreator, context)) {
- // Not required to persist
+
+ SubscriptionManager subManager = context.getSystemService(SubscriptionManager.class);
+ UserHandle userHandle = null;
+ long identity = Binder.clearCallingIdentity();
+ try {
+ if ((subManager != null) && (subManager.isActiveSubscriptionId(mSubId))) {
+ userHandle = subManager.getSubscriptionUserHandle(mSubId);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+
+ if (!SmsApplication.shouldWriteMessageForPackageAsUser(mCreator, context, userHandle)) {
return null;
}
+
LogUtil.d(requestId, "persistIfRequired. "
+ MmsService.formatCrossStackMessageId(mMessageId));
if (mPduData == null) {
@@ -183,7 +199,7 @@
+ MmsService.formatCrossStackMessageId(mMessageId));
return null;
}
- final long identity = Binder.clearCallingIdentity();
+ identity = Binder.clearCallingIdentity();
try {
final boolean supportContentDisposition =
mMmsConfig.getBoolean(SmsManager.MMS_CONFIG_SUPPORT_MMS_CONTENT_DISPOSITION);
@@ -417,10 +433,12 @@
if (mCarrierMessagingServiceWrapper.bindToCarrierMessagingService(
context, carrierMessagingServicePackage, Runnable::run,
() -> onServiceReady())) {
- LogUtil.v("bindService() for carrier messaging service succeeded. "
+ LogUtil.v("bindService() for carrier messaging service: "
+ + carrierMessagingServicePackage + " succeeded. "
+ MmsService.formatCrossStackMessageId(mMessageId));
} else {
- LogUtil.e("bindService() for carrier messaging service failed. "
+ LogUtil.e("bindService() for carrier messaging service: "
+ + carrierMessagingServicePackage + " failed. "
+ MmsService.formatCrossStackMessageId(mMessageId));
carrierSendCompleteCallback.onSendMmsComplete(
CarrierMessagingService.SEND_STATUS_RETRY_ON_CARRIER_NETWORK,
diff --git a/src/com/android/mms/service/metrics/MmsMetricsCollector.java b/src/com/android/mms/service/metrics/MmsMetricsCollector.java
new file mode 100644
index 0000000..8da61ba
--- /dev/null
+++ b/src/com/android/mms/service/metrics/MmsMetricsCollector.java
@@ -0,0 +1,162 @@
+/*
+ * 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.mms.service.metrics;
+
+import static com.android.mms.MmsStatsLog.INCOMING_MMS;
+import static com.android.mms.MmsStatsLog.OUTGOING_MMS;
+
+import android.app.StatsManager;
+import android.content.Context;
+import android.util.Log;
+import android.util.StatsEvent;
+
+import androidx.annotation.VisibleForTesting;
+
+import com.android.mms.IncomingMms;
+import com.android.mms.MmsStatsLog;
+import com.android.mms.OutgoingMms;
+import com.android.internal.util.ConcurrentUtils;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.concurrent.Executor;
+
+/**
+ * Implements statsd pullers for Mms.
+ *
+ * <p>This class registers pullers to statsd, which will be called once a day to obtain mms
+ * statistics that cannot be sent to statsd in real time.
+ */
+public class MmsMetricsCollector implements StatsManager.StatsPullAtomCallback {
+ private static final String TAG = MmsMetricsCollector.class.getSimpleName();
+ /** Disables various restrictions to ease debugging during development. */
+ private static final boolean DBG = false; // STOPSHIP if true
+ private static final long MILLIS_PER_HOUR = Duration.ofHours(1).toMillis();
+ private static final long MILLIS_PER_SECOND = Duration.ofSeconds(1).toMillis();
+ /**
+ * Sets atom pull cool down to 23 hours to help enforcing privacy requirement.
+ *
+ * <p>Applies to certain atoms. The interval of 23 hours leaves some margin for pull operations
+ * that occur once a day.
+ */
+ private static final long MIN_COOLDOWN_MILLIS =
+ DBG ? 10L * MILLIS_PER_SECOND : 23L * MILLIS_PER_HOUR;
+ private final PersistMmsAtomsStorage mStorage;
+ private final StatsManager mStatsManager;
+
+
+ public MmsMetricsCollector(Context context) {
+ this(context, new PersistMmsAtomsStorage(context));
+ }
+
+ @VisibleForTesting
+ public MmsMetricsCollector(Context context, PersistMmsAtomsStorage storage) {
+ mStorage = storage;
+ mStatsManager = context.getSystemService(StatsManager.class);
+ if (mStatsManager != null) {
+ registerAtom(INCOMING_MMS);
+ registerAtom(OUTGOING_MMS);
+ Log.d(TAG, "[MmsMetricsCollector]: registered atoms");
+ } else {
+ Log.e(TAG, "[MmsMetricsCollector]: could not get StatsManager, "
+ + "atoms not registered");
+ }
+ }
+
+ private static StatsEvent buildStatsEvent(IncomingMms mms) {
+ return MmsStatsLog.buildStatsEvent(
+ INCOMING_MMS,
+ mms.getRat(),
+ mms.getResult(),
+ mms.getRoaming(),
+ mms.getSimSlotIndex(),
+ mms.getIsMultiSim(),
+ mms.getIsEsim(),
+ mms.getCarrierId(),
+ mms.getAvgIntervalMillis(),
+ mms.getMmsCount(),
+ mms.getRetryId(),
+ mms.getHandledByCarrierApp(),
+ mms.getIsManagedProfile());
+ }
+
+ private static StatsEvent buildStatsEvent(OutgoingMms mms) {
+ return MmsStatsLog.buildStatsEvent(
+ OUTGOING_MMS,
+ mms.getRat(),
+ mms.getResult(),
+ mms.getRoaming(),
+ mms.getSimSlotIndex(),
+ mms.getIsMultiSim(),
+ mms.getIsEsim(),
+ mms.getCarrierId(),
+ mms.getAvgIntervalMillis(),
+ mms.getMmsCount(),
+ mms.getIsFromDefaultApp(),
+ mms.getRetryId(),
+ mms.getHandledByCarrierApp(),
+ mms.getIsManagedProfile());
+ }
+
+ @Override
+ public int onPullAtom(int atomTag, List<StatsEvent> data) {
+ switch (atomTag) {
+ case INCOMING_MMS:
+ return pullIncomingMms(data);
+ case OUTGOING_MMS:
+ return pullOutgoingMms(data);
+ default:
+ Log.e(TAG, String.format("unexpected atom ID %d", atomTag));
+ return StatsManager.PULL_SKIP;
+ }
+ }
+
+ private int pullIncomingMms(List<StatsEvent> data) {
+ List<IncomingMms> incomingMmsList = mStorage.getIncomingMms(MIN_COOLDOWN_MILLIS);
+ if (incomingMmsList != null) {
+ // MMS List is already shuffled when MMS were inserted.
+ incomingMmsList.forEach(mms -> data.add(buildStatsEvent(mms)));
+ return StatsManager.PULL_SUCCESS;
+ } else {
+ Log.w(TAG, "INCOMING_MMS pull too frequent, skipping");
+ return StatsManager.PULL_SKIP;
+ }
+ }
+
+ private int pullOutgoingMms(List<StatsEvent> data) {
+ List<OutgoingMms> outgoingMmsList = mStorage.getOutgoingMms(MIN_COOLDOWN_MILLIS);
+ if (outgoingMmsList != null) {
+ // MMS List is already shuffled when MMS were inserted.
+ outgoingMmsList.forEach(mms -> data.add(buildStatsEvent(mms)));
+ return StatsManager.PULL_SUCCESS;
+ } else {
+ Log.w(TAG, "OUTGOING_MMS pull too frequent, skipping");
+ return StatsManager.PULL_SKIP;
+ }
+ }
+
+ /** Registers a pulled atom ID {@code atomId}. */
+ private void registerAtom(int atomId) {
+ mStatsManager.setPullAtomCallback(atomId, /* metadata= */ null,
+ ConcurrentUtils.DIRECT_EXECUTOR, this);
+ }
+
+ /** Returns the {@link PersistMmsAtomsStorage} backing the puller. */
+ public PersistMmsAtomsStorage getAtomsStorage() {
+ return mStorage;
+ }
+}
diff --git a/src/com/android/mms/service/metrics/MmsStats.java b/src/com/android/mms/service/metrics/MmsStats.java
new file mode 100644
index 0000000..7e98b0b
--- /dev/null
+++ b/src/com/android/mms/service/metrics/MmsStats.java
@@ -0,0 +1,232 @@
+/*
+ * 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.mms.service.metrics;
+
+import static com.android.mms.MmsStatsLog.INCOMING_MMS__RESULT__MMS_RESULT_ERROR_UNSPECIFIED;
+import static com.android.mms.MmsStatsLog.INCOMING_MMS__RESULT__MMS_RESULT_SUCCESS;
+import static com.android.mms.MmsStatsLog.OUTGOING_MMS__RESULT__MMS_RESULT_ERROR_UNSPECIFIED;
+import static com.android.mms.MmsStatsLog.OUTGOING_MMS__RESULT__MMS_RESULT_SUCCESS;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Binder;
+import android.os.SystemClock;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.telephony.ServiceState;
+import android.telephony.SmsManager;
+import android.telephony.SubscriptionInfo;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+import android.telephony.UiccCardInfo;
+
+import com.android.internal.telephony.SmsApplication;
+import com.android.mms.IncomingMms;
+import com.android.mms.OutgoingMms;
+
+import java.util.List;
+
+/** Collects mms events for the pulled atom. */
+public class MmsStats {
+ private static final String TAG = MmsStats.class.getSimpleName();
+
+ private final Context mContext;
+ private final PersistMmsAtomsStorage mPersistMmsAtomsStorage;
+ private final String mCallingPkg;
+ private final boolean mIsIncomingMms;
+ private final long mTimestamp;
+ private int mSubId;
+ private TelephonyManager mTelephonyManager;
+
+ public MmsStats(Context context, PersistMmsAtomsStorage persistMmsAtomsStorage, int subId,
+ TelephonyManager telephonyManager, String callingPkg, boolean isIncomingMms) {
+ mContext = context;
+ mPersistMmsAtomsStorage = persistMmsAtomsStorage;
+ mSubId = subId;
+ mTelephonyManager = telephonyManager;
+ mCallingPkg = callingPkg;
+ mIsIncomingMms = isIncomingMms;
+ mTimestamp = SystemClock.elapsedRealtime();
+ }
+
+ /** Updates subId and corresponding telephonyManager. */
+ public void updateSubId(int subId, TelephonyManager telephonyManager) {
+ mSubId = subId;
+ mTelephonyManager = telephonyManager;
+ }
+
+ /** Adds incoming or outgoing mms atom to storage. */
+ public void addAtomToStorage(int result) {
+ addAtomToStorage(result, 0, false);
+ }
+
+ /** Adds incoming or outgoing mms atom to storage. */
+ public void addAtomToStorage(int result, int retryId, boolean handledByCarrierApp) {
+ long identity = Binder.clearCallingIdentity();
+ try {
+ if (mIsIncomingMms) {
+ onIncomingMms(result, retryId, handledByCarrierApp);
+ } else {
+ onOutgoingMms(result, retryId, handledByCarrierApp);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ }
+
+ /** Creates a new atom when MMS is received. */
+ private void onIncomingMms(int result, int retryId, boolean handledByCarrierApp) {
+ IncomingMms incomingMms = IncomingMms.newBuilder()
+ .setRat(getDataNetworkType())
+ .setResult(getIncomingMmsResult(result))
+ .setRoaming(getDataRoamingType())
+ .setSimSlotIndex(getSlotIndex())
+ .setIsMultiSim(getIsMultiSim())
+ .setIsEsim(getIsEuicc())
+ .setCarrierId(getSimCarrierId())
+ .setAvgIntervalMillis(getInterval())
+ .setMmsCount(1)
+ .setRetryId(retryId)
+ .setHandledByCarrierApp(handledByCarrierApp)
+ .setIsManagedProfile(isManagedProfile())
+ .build();
+ mPersistMmsAtomsStorage.addIncomingMms(incomingMms);
+ }
+
+ /** Creates a new atom when MMS is sent. */
+ private void onOutgoingMms(int result, int retryId, boolean handledByCarrierApp) {
+ OutgoingMms outgoingMms = OutgoingMms.newBuilder()
+ .setRat(getDataNetworkType())
+ .setResult(getOutgoingMmsResult(result))
+ .setRoaming(getDataRoamingType())
+ .setSimSlotIndex(getSlotIndex())
+ .setIsMultiSim(getIsMultiSim())
+ .setIsEsim(getIsEuicc())
+ .setCarrierId(getSimCarrierId())
+ .setAvgIntervalMillis(getInterval())
+ .setMmsCount(1)
+ .setIsFromDefaultApp(isDefaultMmsApp())
+ .setRetryId(retryId)
+ .setHandledByCarrierApp(handledByCarrierApp)
+ .setIsManagedProfile(isManagedProfile())
+ .build();
+ mPersistMmsAtomsStorage.addOutgoingMms(outgoingMms);
+ }
+
+ /** @return {@code true} if this SIM is dedicated to work profile */
+ private boolean isManagedProfile() {
+ SubscriptionManager subManager = mContext.getSystemService(SubscriptionManager.class);
+ if (subManager == null || !subManager.isActiveSubscriptionId(mSubId)) return false;
+ UserHandle userHandle = subManager.getSubscriptionUserHandle(mSubId);
+ UserManager userManager = mContext.getSystemService(UserManager.class);
+ if (userHandle == null || userManager == null) return false;
+ return userManager.isManagedProfile(userHandle.getIdentifier());
+ }
+
+ /** Returns data network type of current subscription. */
+ private int getDataNetworkType() {
+ return mTelephonyManager.getDataNetworkType();
+ }
+
+ /** Returns incoming mms result. */
+ private int getIncomingMmsResult(int result) {
+ switch (result) {
+ case SmsManager.MMS_ERROR_UNSPECIFIED:
+ // SmsManager.MMS_ERROR_UNSPECIFIED(1) -> MMS_RESULT_ERROR_UNSPECIFIED(0)
+ return INCOMING_MMS__RESULT__MMS_RESULT_ERROR_UNSPECIFIED;
+ case Activity.RESULT_OK:
+ // Activity.RESULT_OK -> MMS_RESULT_SUCCESS(1)
+ return INCOMING_MMS__RESULT__MMS_RESULT_SUCCESS;
+ default:
+ // Int value of other SmsManager.MMS_ERROR matches MMS_RESULT_ERROR
+ return result;
+ }
+ }
+
+ /** Returns outgoing mms result. */
+ private int getOutgoingMmsResult(int result) {
+ switch (result) {
+ case SmsManager.MMS_ERROR_UNSPECIFIED:
+ // SmsManager.MMS_ERROR_UNSPECIFIED(1) -> MMS_RESULT_ERROR_UNSPECIFIED(0)
+ return OUTGOING_MMS__RESULT__MMS_RESULT_ERROR_UNSPECIFIED;
+ case Activity.RESULT_OK:
+ // Activity.RESULT_OK -> MMS_RESULT_SUCCESS(1)
+ return OUTGOING_MMS__RESULT__MMS_RESULT_SUCCESS;
+ default:
+ // Int value of other SmsManager.MMS_ERROR matches MMS_RESULT_ERROR
+ return result;
+ }
+ }
+
+ /** Returns data network roaming type of current subscription. */
+ private int getDataRoamingType() {
+ ServiceState serviceState = mTelephonyManager.getServiceState();
+ return (serviceState != null) ? serviceState.getDataRoamingType() :
+ ServiceState.ROAMING_TYPE_NOT_ROAMING;
+ }
+
+ /** Returns slot index associated with the subscription. */
+ private int getSlotIndex() {
+ return SubscriptionManager.getSlotIndex(mSubId);
+ }
+
+ /** Returns whether the device has multiple active SIM profiles. */
+ private boolean getIsMultiSim() {
+ SubscriptionManager subManager = mContext.getSystemService(SubscriptionManager.class);
+ if(subManager == null) {
+ return false;
+ }
+
+ List<SubscriptionInfo> activeSubscriptionInfo = subManager.getActiveSubscriptionInfoList();
+ return (activeSubscriptionInfo.size() > 1);
+ }
+
+ /** Returns if current subscription is embedded subscription. */
+ private boolean getIsEuicc() {
+ List<UiccCardInfo> uiccCardInfoList = mTelephonyManager.getUiccCardsInfo();
+ for (UiccCardInfo card : uiccCardInfoList) {
+ if (card.getPhysicalSlotIndex() == getSlotIndex()) {
+ return card.isEuicc();
+ }
+ }
+ return false;
+ }
+
+ /** Returns carrier id of the current subscription used by MMS. */
+ private int getSimCarrierId() {
+ return mTelephonyManager.getSimCarrierId();
+ }
+
+ /** Returns if the MMS was originated from the default MMS application. */
+ private boolean isDefaultMmsApp() {
+ UserHandle userHandle = null;
+ SubscriptionManager subManager = mContext.getSystemService(SubscriptionManager.class);
+ if ((subManager != null) && (subManager.isActiveSubscriptionId(mSubId))) {
+ userHandle = subManager.getSubscriptionUserHandle(mSubId);
+ }
+ return SmsApplication.isDefaultMmsApplicationAsUser(mContext, mCallingPkg, userHandle);
+ }
+
+ /**
+ * Returns the interval in milliseconds between sending/receiving MMS message and current time.
+ * Calculates the time taken to send message to the network
+ * or download message from the network.
+ */
+ private long getInterval() {
+ return (SystemClock.elapsedRealtime() - mTimestamp);
+ }
+}
diff --git a/src/com/android/mms/service/metrics/PersistMmsAtomsStorage.java b/src/com/android/mms/service/metrics/PersistMmsAtomsStorage.java
new file mode 100644
index 0000000..4e9ffc7
--- /dev/null
+++ b/src/com/android/mms/service/metrics/PersistMmsAtomsStorage.java
@@ -0,0 +1,370 @@
+/*
+ * 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.mms.service.metrics;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+import com.android.mms.IncomingMms;
+import com.android.mms.OutgoingMms;
+import com.android.mms.PersistMmsAtoms;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class PersistMmsAtomsStorage {
+ private static final String TAG = PersistMmsAtomsStorage.class.getSimpleName();
+
+ /** Name of the file where cached statistics are saved to. */
+ private static final String FILENAME = "persist_mms_atoms.pb";
+
+ /** Delay to store atoms to persistent storage to bundle multiple operations together. */
+ private static final int SAVE_TO_FILE_DELAY_FOR_UPDATE_MILLIS = 30000;
+
+ /**
+ * Delay to store atoms to persistent storage during pulls to avoid unnecessary operations.
+ *
+ * <p>This delay should be short to avoid duplicating atoms or losing pull timestamp in case of
+ * crash or power loss.
+ */
+ private static final int SAVE_TO_FILE_DELAY_FOR_GET_MILLIS = 500;
+ private static final SecureRandom sRandom = new SecureRandom();
+ /**
+ * Maximum number of MMS to store between pulls.
+ * Incoming MMS and outgoing MMS are counted separately.
+ */
+ private final int mMaxNumMms;
+ private final Context mContext;
+ private final Handler mHandler;
+ private final HandlerThread mHandlerThread;
+ /** Stores persist atoms and persist states of the puller. */
+ @VisibleForTesting
+ protected PersistMmsAtoms mPersistMmsAtoms;
+ private final Runnable mSaveRunnable =
+ new Runnable() {
+ @Override
+ public void run() {
+ saveAtomsToFileNow();
+ }
+ };
+ /** Whether atoms should be saved immediately, skipping the delay. */
+ @VisibleForTesting
+ protected boolean mSaveImmediately;
+
+ public PersistMmsAtomsStorage(Context context) {
+ mContext = context;
+
+ if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_RAM_LOW)) {
+ Log.i(TAG, "[PersistMmsAtomsStorage]: Low RAM device");
+ mMaxNumMms = 5;
+ } else {
+ mMaxNumMms = 25;
+ }
+ mPersistMmsAtoms = loadAtomsFromFile();
+ mHandlerThread = new HandlerThread("PersistMmsAtomsThread");
+ mHandlerThread.start();
+ mHandler = new Handler(mHandlerThread.getLooper());
+ mSaveImmediately = false;
+ }
+
+ /** Loads {@link PersistMmsAtoms} from a file in private storage. */
+ private PersistMmsAtoms loadAtomsFromFile() {
+ try {
+ PersistMmsAtoms atoms = PersistMmsAtoms.parseFrom(
+ Files.readAllBytes(mContext.getFileStreamPath(FILENAME).toPath()));
+
+ // Start from scratch if build changes, since mixing atoms from different builds could
+ // produce strange results.
+ if (!Build.FINGERPRINT.equals(atoms.getBuildFingerprint())) {
+ Log.d(TAG, "[loadAtomsFromFile]: Build changed");
+ return makeNewPersistMmsAtoms();
+ }
+ // check all the fields in case of situations such as OTA or crash during saving.
+ List<IncomingMms> incomingMms = sanitizeAtoms(atoms.getIncomingMmsList(), mMaxNumMms);
+ List<OutgoingMms> outgoingMms = sanitizeAtoms(atoms.getOutgoingMmsList(), mMaxNumMms);
+ long incomingMmsPullTimestamp = sanitizeTimestamp(
+ atoms.getIncomingMmsPullTimestampMillis());
+ long outgoingMmsPullTimestamp = sanitizeTimestamp(
+ atoms.getOutgoingMmsPullTimestampMillis());
+
+ // Rebuild atoms after sanitizing.
+ atoms = atoms.toBuilder()
+ .clearIncomingMms()
+ .clearOutgoingMms()
+ .addAllIncomingMms(incomingMms)
+ .addAllOutgoingMms(outgoingMms)
+ .setIncomingMmsPullTimestampMillis(incomingMmsPullTimestamp)
+ .setOutgoingMmsPullTimestampMillis(outgoingMmsPullTimestamp)
+ .build();
+ return atoms;
+ } catch (NoSuchFileException e) {
+ Log.e(TAG, "[loadAtomsFromFile]: PersistMmsAtoms file not found");
+ } catch (IOException | NullPointerException e) {
+ Log.e(TAG, "[loadAtomsFromFile]: cannot load/parse PersistMmsAtoms", e);
+ }
+ return makeNewPersistMmsAtoms();
+ }
+
+ /** Adds an IncomingMms to the storage. */
+ public synchronized void addIncomingMms(IncomingMms mms) {
+ int existingMmsIndex = findIndex(mms);
+ if (existingMmsIndex != -1) {
+ // Update mmsCount and avgIntervalMillis of existingMms.
+ IncomingMms existingMms = mPersistMmsAtoms.getIncomingMms(existingMmsIndex);
+ long updatedMmsCount = existingMms.getMmsCount() + 1;
+ long updatedAvgIntervalMillis =
+ (((existingMms.getAvgIntervalMillis() * existingMms.getMmsCount())
+ + mms.getAvgIntervalMillis()) / updatedMmsCount);
+ existingMms = existingMms.toBuilder()
+ .setMmsCount(updatedMmsCount)
+ .setAvgIntervalMillis(updatedAvgIntervalMillis)
+ .build();
+
+ mPersistMmsAtoms = mPersistMmsAtoms.toBuilder()
+ .setIncomingMms(existingMmsIndex, existingMms)
+ .build();
+ } else {
+ // Insert new mms at random place.
+ List<IncomingMms> incomingMmsList = insertAtRandomPlace(
+ mPersistMmsAtoms.getIncomingMmsList(), mms, mMaxNumMms);
+ mPersistMmsAtoms = mPersistMmsAtoms.toBuilder()
+ .clearIncomingMms()
+ .addAllIncomingMms(incomingMmsList)
+ .build();
+ }
+ saveAtomsToFile(SAVE_TO_FILE_DELAY_FOR_UPDATE_MILLIS);
+ }
+
+ /** Adds an OutgoingMms to the storage. */
+ public synchronized void addOutgoingMms(OutgoingMms mms) {
+ int existingMmsIndex = findIndex(mms);
+ if (existingMmsIndex != -1) {
+ // Update mmsCount and avgIntervalMillis of existingMms.
+ OutgoingMms existingMms = mPersistMmsAtoms.getOutgoingMms(existingMmsIndex);
+ long updatedMmsCount = existingMms.getMmsCount() + 1;
+ long updatedAvgIntervalMillis =
+ (((existingMms.getAvgIntervalMillis() * existingMms.getMmsCount())
+ + mms.getAvgIntervalMillis()) / updatedMmsCount);
+ existingMms = existingMms.toBuilder()
+ .setMmsCount(updatedMmsCount)
+ .setAvgIntervalMillis(updatedAvgIntervalMillis)
+ .build();
+
+ mPersistMmsAtoms = mPersistMmsAtoms.toBuilder()
+ .setOutgoingMms(existingMmsIndex, existingMms)
+ .build();
+ } else {
+ // Insert new mms at random place.
+ List<OutgoingMms> outgoingMmsList = insertAtRandomPlace(
+ mPersistMmsAtoms.getOutgoingMmsList(), mms, mMaxNumMms);
+ mPersistMmsAtoms = mPersistMmsAtoms.toBuilder()
+ .clearOutgoingMms()
+ .addAllOutgoingMms(outgoingMmsList)
+ .build();
+ }
+ saveAtomsToFile(SAVE_TO_FILE_DELAY_FOR_UPDATE_MILLIS);
+ }
+
+ /**
+ * Returns and clears the IncomingMms if last pulled longer than {@code minIntervalMillis} ago,
+ * otherwise returns {@code null}.
+ */
+ @Nullable
+ public synchronized List<IncomingMms> getIncomingMms(long minIntervalMillis) {
+ if ((getWallTimeMillis() - mPersistMmsAtoms.getIncomingMmsPullTimestampMillis())
+ > minIntervalMillis) {
+ List<IncomingMms> previousIncomingMmsList = mPersistMmsAtoms.getIncomingMmsList();
+ mPersistMmsAtoms = mPersistMmsAtoms.toBuilder()
+ .setIncomingMmsPullTimestampMillis(getWallTimeMillis())
+ .clearIncomingMms()
+ .build();
+ saveAtomsToFile(SAVE_TO_FILE_DELAY_FOR_GET_MILLIS);
+ return previousIncomingMmsList;
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Returns and clears the OutgoingMms if last pulled longer than {@code minIntervalMillis} ago,
+ * otherwise returns {@code null}.
+ */
+ @Nullable
+ public synchronized List<OutgoingMms> getOutgoingMms(long minIntervalMillis) {
+ if ((getWallTimeMillis() - mPersistMmsAtoms.getOutgoingMmsPullTimestampMillis())
+ > minIntervalMillis) {
+ List<OutgoingMms> previousOutgoingMmsList = mPersistMmsAtoms.getOutgoingMmsList();
+ mPersistMmsAtoms = mPersistMmsAtoms.toBuilder()
+ .setOutgoingMmsPullTimestampMillis(getWallTimeMillis())
+ .clearOutgoingMms()
+ .build();
+ saveAtomsToFile(SAVE_TO_FILE_DELAY_FOR_GET_MILLIS);
+ return previousOutgoingMmsList;
+ } else {
+ return null;
+ }
+ }
+
+ /** Saves a pending {@link PersistMmsAtoms} to a file in private storage immediately. */
+ public void flushAtoms() {
+ if (mHandler.hasCallbacks(mSaveRunnable)) {
+ mHandler.removeCallbacks(mSaveRunnable);
+ saveAtomsToFileNow();
+ }
+ }
+
+ /** Returns an empty PersistMmsAtoms with pull timestamp set to current time. */
+ private PersistMmsAtoms makeNewPersistMmsAtoms() {
+ // allow pulling only after some time so data are sufficiently aggregated.
+ long currentTime = getWallTimeMillis();
+ PersistMmsAtoms atoms = PersistMmsAtoms.newBuilder()
+ .setBuildFingerprint(Build.FINGERPRINT)
+ .setIncomingMmsPullTimestampMillis(currentTime)
+ .setOutgoingMmsPullTimestampMillis(currentTime)
+ .build();
+ return atoms;
+ }
+
+ /**
+ * Posts message to save a copy of {@link PersistMmsAtoms} to a file after a delay.
+ *
+ * <p>The delay is introduced to avoid too frequent operations to disk, which would negatively
+ * impact the power consumption.
+ */
+ private void saveAtomsToFile(int delayMillis) {
+ if (delayMillis > 0 && !mSaveImmediately) {
+ mHandler.removeCallbacks(mSaveRunnable);
+ if (mHandler.postDelayed(mSaveRunnable, delayMillis)) {
+ return;
+ }
+ }
+ // In case of error posting the event or if delay is 0, save immediately.
+ saveAtomsToFileNow();
+ }
+
+ /** Saves a copy of {@link PersistMmsAtoms} to a file in private storage. */
+ private synchronized void saveAtomsToFileNow() {
+ try (FileOutputStream stream = mContext.openFileOutput(FILENAME, Context.MODE_PRIVATE)) {
+ stream.write(mPersistMmsAtoms.toByteArray());
+ } catch (IOException e) {
+ Log.e(TAG, "[saveAtomsToFileNow]: Cannot save PersistMmsAtoms", e);
+ }
+ }
+
+ /**
+ * Inserts a new element in a random position.
+ */
+ private static <T> List<T> insertAtRandomPlace(List<T> storage, T instance, int maxSize) {
+ final int storage_size = storage.size();
+ List<T> result = new ArrayList<>(storage);
+ if (storage_size == 0) {
+ result.add(instance);
+ } else if (storage_size == maxSize) {
+ // Index of the item suitable for eviction is chosen randomly when the array is full.
+ int insertAt = sRandom.nextInt(maxSize);
+ result.set(insertAt, instance);
+ } else {
+ // Insert at random place (by moving the item at the random place to the end).
+ int insertAt = sRandom.nextInt(storage_size);
+ result.add(result.get(insertAt));
+ result.set(insertAt, instance);
+ }
+ return result;
+ }
+
+ /**
+ * Returns IncomingMms atom index that has the same dimension values with the given one,
+ * or {@code -1} if it does not exist.
+ */
+ private int findIndex(IncomingMms key) {
+ for (int i = 0; i < mPersistMmsAtoms.getIncomingMmsCount(); i++) {
+ IncomingMms mms = mPersistMmsAtoms.getIncomingMms(i);
+ if (mms.getRat() == key.getRat()
+ && mms.getResult() == key.getResult()
+ && mms.getRoaming() == key.getRoaming()
+ && mms.getSimSlotIndex() == key.getSimSlotIndex()
+ && mms.getIsMultiSim() == key.getIsMultiSim()
+ && mms.getIsEsim() == key.getIsEsim()
+ && mms.getCarrierId() == key.getCarrierId()
+ && mms.getRetryId() == key.getRetryId()
+ && mms.getHandledByCarrierApp() == key.getHandledByCarrierApp()) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Returns OutgoingMms atom index that has the same dimension values with the given one,
+ * or {@code -1} if it does not exist.
+ */
+ private int findIndex(OutgoingMms key) {
+ for (int i = 0; i < mPersistMmsAtoms.getOutgoingMmsCount(); i++) {
+ OutgoingMms mms = mPersistMmsAtoms.getOutgoingMms(i);
+ if (mms.getRat() == key.getRat()
+ && mms.getResult() == key.getResult()
+ && mms.getRoaming() == key.getRoaming()
+ && mms.getSimSlotIndex() == key.getSimSlotIndex()
+ && mms.getIsMultiSim() == key.getIsMultiSim()
+ && mms.getIsEsim() == key.getIsEsim()
+ && mms.getCarrierId() == key.getCarrierId()
+ && mms.getIsFromDefaultApp() == key.getIsFromDefaultApp()
+ && mms.getRetryId() == key.getRetryId()
+ && mms.getHandledByCarrierApp() == key.getHandledByCarrierApp()) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ /** Sanitizes the loaded list of atoms to avoid null values. */
+ private <T> List<T> sanitizeAtoms(List<T> list) {
+ return list == null ? Collections.emptyList() : list;
+ }
+
+ /** Sanitizes the loaded list of atoms loaded to avoid null values and enforce max length. */
+ private <T> List<T> sanitizeAtoms(List<T> list, int maxSize) {
+ list = sanitizeAtoms(list);
+ if (list.size() > maxSize) {
+ return list.subList(0, maxSize);
+ }
+ return list;
+ }
+
+ /** Sanitizes the timestamp of the last pull loaded from persistent storage. */
+ private long sanitizeTimestamp(long timestamp) {
+ return timestamp <= 0L ? getWallTimeMillis() : timestamp;
+ }
+
+ @VisibleForTesting
+ protected long getWallTimeMillis() {
+ // Epoch time in UTC, preserved across reboots, but can be adjusted e.g. by the user or NTP.
+ return System.currentTimeMillis();
+ }
+}
\ No newline at end of file
diff --git a/tests/robotests/src/com/android/mms/service/MmsNetworkManagerTest.java b/tests/robotests/src/com/android/mms/service/MmsNetworkManagerTest.java
index c2d3e05..dff2bab 100644
--- a/tests/robotests/src/com/android/mms/service/MmsNetworkManagerTest.java
+++ b/tests/robotests/src/com/android/mms/service/MmsNetworkManagerTest.java
@@ -36,6 +36,8 @@
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
+import android.os.PersistableBundle;
+import android.telephony.CarrierConfigManager;
import org.junit.Before;
import org.junit.Test;
@@ -70,7 +72,8 @@
@Mock Context mCtx;
@Mock ConnectivityManager mCm;
@Mock MmsNetworkManager.Dependencies mDeps;
-
+ @Mock CarrierConfigManager mCarrierConfigManager;
+ @Mock PersistableBundle mConfig;
private MmsNetworkManager mMnm;
private final ExecutorService mExecutor = Executors.newSingleThreadExecutor();
@@ -89,6 +92,8 @@
doReturn(MMS_APN2).when(mNetworkInfo2).getExtraInfo();
doReturn(NETWORK_ACQUIRE_TIMEOUT_MS).when(mDeps).getNetworkRequestTimeoutMillis();
doReturn(NETWORK_ACQUIRE_TIMEOUT_MS).when(mDeps).getAdditionalNetworkAcquireTimeoutMillis();
+ doReturn(mCarrierConfigManager).when(mCtx).getSystemService(Context.CARRIER_CONFIG_SERVICE);
+ doReturn(mConfig).when(mCarrierConfigManager).getConfigForSubId(TEST_SUBID);
mMnm = new MmsNetworkManager(mCtx, TEST_SUBID, mDeps);
}
@@ -201,6 +206,25 @@
assertEquals(null, mMnm.getApnName());
}
+ @Test
+ public void testHandleCarrierConfigChanged() throws Exception {
+ // Expect receiving default NETWORK_RELEASE_TIMEOUT of 5 seconds
+ int defaultNetworkReleaseTimeout = 5000;
+ doReturn(defaultNetworkReleaseTimeout).when(mConfig).getInt(
+ CarrierConfigManager.KEY_MMS_NETWORK_RELEASE_TIMEOUT_MILLIS_INT);
+ MmsNetworkManager mmsNetworkManager = new MmsNetworkManager(mCtx, TEST_SUBID, mDeps);
+ assertEquals(defaultNetworkReleaseTimeout,
+ mmsNetworkManager.getNetworkReleaseTimeoutMillis());
+
+ // Expect receiving a carrier-configured value
+ int configuredNetworkReleaseTimeout = 10000;
+ doReturn(configuredNetworkReleaseTimeout).when(mConfig).getInt(
+ CarrierConfigManager.KEY_MMS_NETWORK_RELEASE_TIMEOUT_MILLIS_INT);
+ mmsNetworkManager = new MmsNetworkManager(mCtx, TEST_SUBID, mDeps);
+ assertEquals(configuredNetworkReleaseTimeout,
+ mmsNetworkManager.getNetworkReleaseTimeoutMillis());
+ }
+
private NetworkCallback acquireAvailableNetworkAndGetCallback(
Network expectNetwork, String expectApn) throws Exception {
final ArgumentCaptor<NetworkCallback> callbackCaptor =
diff --git a/tests/unittests/Android.bp b/tests/unittests/Android.bp
new file mode 100644
index 0000000..595b4be
--- /dev/null
+++ b/tests/unittests/Android.bp
@@ -0,0 +1,27 @@
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+android_test {
+ name: "MmsServiceTests",
+ static_libs: [
+ "mms-protos-lite",
+ "mms-statsd",
+ "androidx.annotation_annotation",
+ "mockito-target",
+ "compatibility-device-util-axt",
+ "androidx.test.rules",
+ "truth-prebuilt",
+ ],
+ libs: [
+ "android.test.runner",
+ "android.test.base",
+ "android.test.mock",
+ ],
+ srcs: ["src/**/*.java", ":mms-service-srcs"],
+ platform_apis: true,
+ test_suites: ["device-tests"],
+ certificate: "platform",
+ instrumentation_for: "MmsService",
+}
diff --git a/tests/unittests/AndroidManifest.xml b/tests/unittests/AndroidManifest.xml
new file mode 100644
index 0000000..3b4b582
--- /dev/null
+++ b/tests/unittests/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.mms.service.tests"
+ android:debuggable="true"
+ android:sharedUserId="android.uid.phone">
+
+ <application>
+ <uses-library android:name="android.test.runner"/>
+ </application>
+
+ <instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
+ android:targetPackage="com.android.mms.service.tests"
+ android:label="MmsServiceTests"
+ android:debuggable="true">
+ </instrumentation>
+</manifest>
\ No newline at end of file
diff --git a/tests/unittests/AndroidTest.xml b/tests/unittests/AndroidTest.xml
new file mode 100644
index 0000000..61b3f5d
--- /dev/null
+++ b/tests/unittests/AndroidTest.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ 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.
+ -->
+<configuration description="Run MmsServiceTests.">
+ <target_preparer class="com.android.tradefed.targetprep.TestAppInstallSetup">
+ <option name="test-file-name" value="MmsServiceTests.apk"/>
+ </target_preparer>
+
+ <option name="test-suite-tag" value="apct"/>
+ <option name="test-tag" value="MmsServiceTests"/>
+ <test class="com.android.tradefed.testtype.AndroidJUnitTest">
+ <option name="package" value="com.android.mms.service.tests"/>
+ <option name="runner" value="androidx.test.runner.AndroidJUnitRunner"/>
+ <option name="hidden-api-checks" value="false"/>
+ </test>
+</configuration>
\ No newline at end of file
diff --git a/tests/unittests/src/com/android/mms/service/MmsHttpClientTest.java b/tests/unittests/src/com/android/mms/service/MmsHttpClientTest.java
new file mode 100644
index 0000000..dd126e8
--- /dev/null
+++ b/tests/unittests/src/com/android/mms/service/MmsHttpClientTest.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2023 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.mms.service;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.os.Bundle;
+import android.telephony.ServiceState;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+
+import androidx.test.core.app.ApplicationProvider;
+
+import org.junit.After;
+import org.junit.Before;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.junit.Test;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.reset;
+
+import android.util.Log;
+
+public class MmsHttpClientTest {
+ // Mocked classes
+ private Context mContext;
+ private TelephonyManager mTelephonyManager;
+ private SubscriptionManager mSubscriptionManager;
+
+ // The raw phone number from TelephonyManager.getLine1Number
+ private static final String MACRO_LINE1 = "LINE1";
+ // The phone number without country code
+ private static final String MACRO_LINE1NOCOUNTRYCODE = "LINE1NOCOUNTRYCODE";
+ private String line1Number = "1234567890";
+ private String subscriberPhoneNumber = "0987654321";
+ private int subId = 1;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ mContext = spy(ApplicationProvider.getApplicationContext());
+ mTelephonyManager = mock(TelephonyManager.class);
+ mSubscriptionManager = mock(SubscriptionManager.class);
+
+ when(mContext.getSystemService(Context.TELEPHONY_SERVICE))
+ .thenReturn(mTelephonyManager);
+ when(mTelephonyManager.createForSubscriptionId(anyInt()))
+ .thenReturn(mTelephonyManager);
+ when(mContext.getSystemService(SubscriptionManager.class))
+ .thenReturn(mSubscriptionManager);
+ }
+
+ @After
+ public void tearDown() {
+ mContext = null;
+ mTelephonyManager = null;
+ mSubscriptionManager = null;
+ }
+
+ @Test
+ public void getPhoneNumberForMacroLine1() {
+ String macro = MACRO_LINE1;
+ Bundle mmsConfig = new Bundle();
+ String emptyStr = "";
+ String phoneNo;
+
+ /* when getLine1Number returns valid number */
+ doReturn(line1Number).when(mTelephonyManager).getLine1Number();
+ phoneNo = MmsHttpClient.getMacroValue(mContext, macro, mmsConfig, subId);
+ assertThat(phoneNo).isEqualTo(line1Number);
+ // getLine1NumberAPI should be called
+ verify(mTelephonyManager).getLine1Number();
+ // getPhoneNumber should never be called
+ verify(mSubscriptionManager, never()).getPhoneNumber(subId);
+
+ /* when getLine1Number returns empty string */
+ doReturn(emptyStr).when(mTelephonyManager).getLine1Number();
+ when(mSubscriptionManager.getPhoneNumber(subId)).thenReturn(subscriberPhoneNumber);
+ phoneNo = MmsHttpClient.getMacroValue(mContext, macro, mmsConfig, subId);
+ assertThat(phoneNo).isEqualTo(subscriberPhoneNumber);
+ verify(mSubscriptionManager).getPhoneNumber(subId);
+
+ /* when getLine1Number returns null */
+ reset(mSubscriptionManager);
+ when(mSubscriptionManager.getPhoneNumber(subId)).thenReturn(subscriberPhoneNumber);
+ doReturn(null).when(mTelephonyManager).getLine1Number();
+ phoneNo = MmsHttpClient.getMacroValue(mContext, macro, mmsConfig, subId);
+ assertThat(phoneNo).isEqualTo(subscriberPhoneNumber);
+ verify(mSubscriptionManager).getPhoneNumber(subId);
+ }
+
+ @Test
+ public void getPhoneNumberForMacroLine1CountryCode() throws Exception {
+ String macro = MACRO_LINE1NOCOUNTRYCODE;
+ String emptyStr = "";
+ String phoneNo;
+ Bundle mmsConfig = new Bundle();
+
+ /* when getLine1Number returns valid number */
+ doReturn(line1Number).when(mTelephonyManager).getLine1Number();
+ phoneNo = MmsHttpClient.getMacroValue(mContext, macro, mmsConfig, subId);
+ assertThat(phoneNo).contains(line1Number);
+ // getLine1NumberAPI should be called
+ verify(mTelephonyManager).getLine1Number();
+ // getPhoneNumber should never be called
+ verify(mSubscriptionManager, never()).getPhoneNumber(subId);
+
+ /* when getLine1Number returns empty string */
+ doReturn(emptyStr).when(mTelephonyManager).getLine1Number();
+ when(mSubscriptionManager.getPhoneNumber(subId)).thenReturn(subscriberPhoneNumber);
+ phoneNo = MmsHttpClient.getMacroValue(mContext, macro, mmsConfig, subId);
+ assertThat(phoneNo).contains(subscriberPhoneNumber);
+ verify(mSubscriptionManager).getPhoneNumber(subId);
+
+ /* when getLine1Number returns null */
+ reset(mSubscriptionManager);
+ when(mSubscriptionManager.getPhoneNumber(subId)).thenReturn(subscriberPhoneNumber);
+ doReturn(null).when(mTelephonyManager).getLine1Number();
+ phoneNo = MmsHttpClient.getMacroValue(mContext, macro, mmsConfig, subId);
+ assertThat(phoneNo).contains(subscriberPhoneNumber);
+ verify(mSubscriptionManager).getPhoneNumber(subId);
+ }
+}
diff --git a/tests/unittests/src/com/android/mms/service/metrics/MmsMetricsCollectorTest.java b/tests/unittests/src/com/android/mms/service/metrics/MmsMetricsCollectorTest.java
new file mode 100644
index 0000000..8d93739
--- /dev/null
+++ b/tests/unittests/src/com/android/mms/service/metrics/MmsMetricsCollectorTest.java
@@ -0,0 +1,142 @@
+/*
+ * 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.mms.service.metrics;
+
+import static com.android.mms.MmsStatsLog.INCOMING_MMS;
+import static com.android.mms.MmsStatsLog.OUTGOING_MMS;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import android.app.StatsManager;
+import android.content.Context;
+import android.util.StatsEvent;
+
+import com.android.mms.IncomingMms;
+import com.android.mms.OutgoingMms;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class MmsMetricsCollectorTest {
+ private static final long MIN_COOLDOWN_MILLIS = 23L * 3600L * 1000L;
+ Context mContext;
+ private PersistMmsAtomsStorage mPersistMmsAtomsStorage;
+ private MmsMetricsCollector mMmsMetricsCollector;
+
+ @Before
+ public void setUp() {
+ mContext = mock(Context.class);
+ mPersistMmsAtomsStorage = mock(PersistMmsAtomsStorage.class);
+ mMmsMetricsCollector = new MmsMetricsCollector(mContext, mPersistMmsAtomsStorage);
+ }
+
+ @After
+ public void tearDown() {
+ mContext = null;
+ mPersistMmsAtomsStorage = null;
+ mMmsMetricsCollector = null;
+ }
+
+ @Test
+ public void onPullAtom_incomingMms_empty() {
+ doReturn(new ArrayList<>()).when(mPersistMmsAtomsStorage).getIncomingMms(anyLong());
+ List<StatsEvent> actualAtoms = new ArrayList<>();
+
+ int result = mMmsMetricsCollector.onPullAtom(INCOMING_MMS, actualAtoms);
+
+ assertThat(actualAtoms).hasSize(0);
+ assertThat(result).isEqualTo(StatsManager.PULL_SUCCESS);
+ }
+
+ @Test
+ public void onPullAtom_incomingMms_tooFrequent() {
+ doReturn(null).when(mPersistMmsAtomsStorage).getIncomingMms(anyLong());
+ List<StatsEvent> actualAtoms = new ArrayList<>();
+
+ int result = mMmsMetricsCollector.onPullAtom(INCOMING_MMS, actualAtoms);
+
+ assertThat(actualAtoms).hasSize(0);
+ assertThat(result).isEqualTo(StatsManager.PULL_SKIP);
+ verify(mPersistMmsAtomsStorage, times(1))
+ .getIncomingMms(eq(MIN_COOLDOWN_MILLIS));
+ verifyNoMoreInteractions(mPersistMmsAtomsStorage);
+ }
+
+ @Test
+ public void onPullAtom_incomingMms_multipleMms() {
+ IncomingMms incomingMms = IncomingMms.newBuilder().build();
+ doReturn(Arrays.asList(incomingMms, incomingMms, incomingMms, incomingMms))
+ .when(mPersistMmsAtomsStorage).getIncomingMms(anyLong());
+ List<StatsEvent> actualAtoms = new ArrayList<>();
+
+ int result = mMmsMetricsCollector.onPullAtom(INCOMING_MMS, actualAtoms);
+
+ assertThat(actualAtoms).hasSize(4);
+ assertThat(result).isEqualTo(StatsManager.PULL_SUCCESS);
+ }
+
+ @Test
+ public void onPullAtom_outgoingMms_empty() {
+ doReturn(new ArrayList<>()).when(mPersistMmsAtomsStorage).getOutgoingMms(anyLong());
+ List<StatsEvent> actualAtoms = new ArrayList<>();
+
+ int result = mMmsMetricsCollector.onPullAtom(OUTGOING_MMS, actualAtoms);
+
+ assertThat(actualAtoms).hasSize(0);
+ assertThat(result).isEqualTo(StatsManager.PULL_SUCCESS);
+ }
+
+ @Test
+ public void onPullAtom_outgoingMms_tooFrequent() {
+ doReturn(null).when(mPersistMmsAtomsStorage).getOutgoingMms(anyLong());
+ List<StatsEvent> actualAtoms = new ArrayList<>();
+
+ int result = mMmsMetricsCollector.onPullAtom(OUTGOING_MMS, actualAtoms);
+
+ assertThat(actualAtoms).hasSize(0);
+ assertThat(result).isEqualTo(StatsManager.PULL_SKIP);
+ verify(mPersistMmsAtomsStorage, times(1))
+ .getOutgoingMms(eq(MIN_COOLDOWN_MILLIS));
+ verifyNoMoreInteractions(mPersistMmsAtomsStorage);
+ }
+
+ @Test
+ public void onPullAtom_outgoingMms_multipleMms() {
+ OutgoingMms outgoingMms = OutgoingMms.newBuilder().build();
+ doReturn(Arrays.asList(outgoingMms, outgoingMms, outgoingMms, outgoingMms))
+ .when(mPersistMmsAtomsStorage).getOutgoingMms(anyLong());
+ List<StatsEvent> actualAtoms = new ArrayList<>();
+
+ int result = mMmsMetricsCollector.onPullAtom(OUTGOING_MMS, actualAtoms);
+
+ assertThat(actualAtoms).hasSize(4);
+ assertThat(result).isEqualTo(StatsManager.PULL_SUCCESS);
+ }
+}
\ No newline at end of file
diff --git a/tests/unittests/src/com/android/mms/service/metrics/MmsStatsTest.java b/tests/unittests/src/com/android/mms/service/metrics/MmsStatsTest.java
new file mode 100644
index 0000000..2b2cae5
--- /dev/null
+++ b/tests/unittests/src/com/android/mms/service/metrics/MmsStatsTest.java
@@ -0,0 +1,154 @@
+/*
+ * 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.mms.service.metrics;
+
+import static com.android.mms.MmsStatsLog.INCOMING_MMS__RESULT__MMS_RESULT_SUCCESS;
+import static com.android.mms.MmsStatsLog.OUTGOING_MMS__RESULT__MMS_RESULT_SUCCESS;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import android.app.Activity;
+import android.content.Context;
+import android.telephony.ServiceState;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+
+import com.android.mms.IncomingMms;
+import com.android.mms.OutgoingMms;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import org.mockito.ArgumentCaptor;
+
+public class MmsStatsTest {
+ // Mocked classes
+ private Context mContext;
+ private PersistMmsAtomsStorage mPersistMmsAtomsStorage;
+ private TelephonyManager mTelephonyManager;
+ private SubscriptionManager mSubscriptionManager;
+
+ @Before
+ public void setUp() {
+ mContext = mock(Context.class);
+ mPersistMmsAtomsStorage = mock(PersistMmsAtomsStorage.class);
+ mTelephonyManager = mock(TelephonyManager.class);
+ mSubscriptionManager = mock(SubscriptionManager.class);
+
+ doReturn(mSubscriptionManager).when(mContext).getSystemService(
+ Context.TELEPHONY_SUBSCRIPTION_SERVICE);
+ }
+
+ @After
+ public void tearDown() {
+ mContext = null;
+ mPersistMmsAtomsStorage = null;
+ mTelephonyManager = null;
+ }
+
+ @Test
+ public void addAtomToStorage_incomingMms_default() {
+ doReturn(null).when(mTelephonyManager).getServiceState();
+ doReturn(TelephonyManager.UNKNOWN_CARRIER_ID).when(mTelephonyManager).getSimCarrierId();
+ int inactiveSubId = 123;
+ MmsStats mmsStats = new MmsStats(mContext, mPersistMmsAtomsStorage, inactiveSubId,
+ mTelephonyManager, null, true);
+ mmsStats.addAtomToStorage(Activity.RESULT_OK);
+
+ ArgumentCaptor<IncomingMms> incomingMmsCaptor = ArgumentCaptor.forClass(IncomingMms.class);
+ verify(mPersistMmsAtomsStorage).addIncomingMms(incomingMmsCaptor.capture());
+ IncomingMms incomingMms = incomingMmsCaptor.getValue();
+ assertThat(incomingMms.getRat()).isEqualTo(TelephonyManager.NETWORK_TYPE_UNKNOWN);
+ assertThat(incomingMms.getResult()).isEqualTo(INCOMING_MMS__RESULT__MMS_RESULT_SUCCESS);
+ assertThat(incomingMms.getRoaming()).isEqualTo(ServiceState.ROAMING_TYPE_NOT_ROAMING);
+ assertThat(incomingMms.getSimSlotIndex()).isEqualTo(
+ SubscriptionManager.INVALID_SIM_SLOT_INDEX);
+ assertThat(incomingMms.getIsMultiSim()).isEqualTo(false);
+ assertThat(incomingMms.getIsEsim()).isEqualTo(false);
+ assertThat(incomingMms.getCarrierId()).isEqualTo(TelephonyManager.UNKNOWN_CARRIER_ID);
+ assertThat(incomingMms.getMmsCount()).isEqualTo(1);
+ assertThat(incomingMms.getRetryId()).isEqualTo(0);
+ assertThat(incomingMms.getHandledByCarrierApp()).isEqualTo(false);
+ assertThat(incomingMms.getIsManagedProfile()).isEqualTo(false);
+ verifyNoMoreInteractions(mPersistMmsAtomsStorage);
+ }
+
+ @Test
+ public void addAtomToStorage_outgoingMms_default() {
+ doReturn(null).when(mTelephonyManager).getServiceState();
+ doReturn(TelephonyManager.UNKNOWN_CARRIER_ID).when(mTelephonyManager).getSimCarrierId();
+ int inactiveSubId = 123;
+ MmsStats mmsStats = new MmsStats(mContext, mPersistMmsAtomsStorage, inactiveSubId,
+ mTelephonyManager, null, false);
+ mmsStats.addAtomToStorage(Activity.RESULT_OK);
+
+ ArgumentCaptor<OutgoingMms> outgoingMmsCaptor = ArgumentCaptor.forClass(OutgoingMms.class);
+ verify(mPersistMmsAtomsStorage).addOutgoingMms(outgoingMmsCaptor.capture());
+ OutgoingMms outgoingMms = outgoingMmsCaptor.getValue();
+ assertThat(outgoingMms.getRat()).isEqualTo(TelephonyManager.NETWORK_TYPE_UNKNOWN);
+ assertThat(outgoingMms.getResult()).isEqualTo(OUTGOING_MMS__RESULT__MMS_RESULT_SUCCESS);
+ assertThat(outgoingMms.getRoaming()).isEqualTo(ServiceState.ROAMING_TYPE_NOT_ROAMING);
+ assertThat(outgoingMms.getSimSlotIndex()).isEqualTo(
+ SubscriptionManager.INVALID_SIM_SLOT_INDEX);
+ assertThat(outgoingMms.getIsMultiSim()).isEqualTo(false);
+ assertThat(outgoingMms.getIsEsim()).isEqualTo(false);
+ assertThat(outgoingMms.getCarrierId()).isEqualTo(TelephonyManager.UNKNOWN_CARRIER_ID);
+ assertThat(outgoingMms.getMmsCount()).isEqualTo(1);
+ assertThat(outgoingMms.getRetryId()).isEqualTo(0);
+ assertThat(outgoingMms.getHandledByCarrierApp()).isEqualTo(false);
+ assertThat(outgoingMms.getIsFromDefaultApp()).isEqualTo(false);
+ assertThat(outgoingMms.getIsManagedProfile()).isEqualTo(false);
+ verifyNoMoreInteractions(mPersistMmsAtomsStorage);
+ }
+
+ @Test
+ public void getDataRoamingType_serviceState_notNull() {
+ ServiceState serviceState = mock(ServiceState.class);
+ doReturn(serviceState).when(mTelephonyManager).getServiceState();
+ MmsStats mmsStats = new MmsStats(mContext, mPersistMmsAtomsStorage, 1,
+ mTelephonyManager, null, true);
+ mmsStats.addAtomToStorage(Activity.RESULT_OK);
+
+ ArgumentCaptor<IncomingMms> incomingMmsCaptor = ArgumentCaptor.forClass(IncomingMms.class);
+ verify(mPersistMmsAtomsStorage).addIncomingMms(incomingMmsCaptor.capture());
+ IncomingMms incomingMms = incomingMmsCaptor.getValue();
+ assertThat(incomingMms.getRoaming()).isEqualTo(ServiceState.ROAMING_TYPE_NOT_ROAMING);
+ }
+
+
+ @Test
+ public void isDefaultMmsApp_subId_inactive() {
+ int inactiveSubId = 123;
+ doReturn(false).when(mSubscriptionManager)
+ .isActiveSubscriptionId(eq(inactiveSubId));
+
+ MmsStats mmsStats = new MmsStats(mContext, mPersistMmsAtomsStorage, inactiveSubId,
+ mTelephonyManager, null, false);
+ mmsStats.addAtomToStorage(Activity.RESULT_OK);
+
+ // getSubscriptionUserHandle should not be called if subID is inactive.
+ verify(mSubscriptionManager, never()).getSubscriptionUserHandle(eq(inactiveSubId));
+ }
+}
\ No newline at end of file
diff --git a/tests/unittests/src/com/android/mms/service/metrics/PersistMmsAtomsStorageTest.java b/tests/unittests/src/com/android/mms/service/metrics/PersistMmsAtomsStorageTest.java
new file mode 100644
index 0000000..7f604bc
--- /dev/null
+++ b/tests/unittests/src/com/android/mms/service/metrics/PersistMmsAtomsStorageTest.java
@@ -0,0 +1,734 @@
+/*
+ * 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.mms.service.metrics;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.anyInt;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.telephony.ServiceState;
+import android.telephony.TelephonyManager;
+import androidx.annotation.Nullable;
+
+import com.android.mms.IncomingMms;
+import com.android.mms.OutgoingMms;
+import com.android.mms.PersistMmsAtoms;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InOrder;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class PersistMmsAtomsStorageTest {
+ private static final String TEST_FILE = "PersistMmsAtomsStorageTest.pb";
+ @Rule
+ public TemporaryFolder mFolder = new TemporaryFolder();
+ private File mTestFile;
+ private static final long START_TIME_MILLIS = 2000L;
+ private static final int CARRIER1_ID = 1435;
+ private static final int CARRIER2_ID = 1187;
+ private TestablePersistMmsAtomsStorage mTestablePersistMmsAtomsStorage;
+ // IncomingMms
+ private List<IncomingMms> mIncomingMmsList;
+ private IncomingMms mIncomingMms1Proto;
+ private IncomingMms mIncomingMms2Proto;
+ // OutgoingMms
+ private List<OutgoingMms> mOutgoingMmsList;
+ private OutgoingMms mOutgoingMms1Proto;
+ private OutgoingMms mOutgoingMms2Proto;
+ // Mocked classes
+ private Context mContext;
+ private PackageManager mPackageManager;
+ private FileOutputStream mTestFileOutputStream;
+ // Comparator to compare proto objects
+ private static final Comparator<Object> sProtoComparator =
+ new Comparator<Object>() {
+ @Override
+ public int compare(Object o1, Object o2) {
+ if (o1 == o2) {
+ return 0;
+ }
+ if (o1 == null) {
+ return -1;
+ }
+ if (o2 == null) {
+ return 1;
+ }
+ assertEquals(o1.getClass(), o2.getClass());
+ return o1.toString().compareTo(o2.toString());
+ }
+ };
+
+
+ @Before
+ public void setUp() throws Exception {
+ mTestFileOutputStream = mock(FileOutputStream.class);
+ mContext = mock(Context.class);
+ mPackageManager = mock(PackageManager.class);
+ makeTestData();
+
+ // By default, test loading with real file IO and saving with mocks.
+ mTestFile = mFolder.newFile(TEST_FILE);
+ doReturn(false).when(mPackageManager).
+ hasSystemFeature(PackageManager.FEATURE_RAM_LOW);
+ doReturn(mPackageManager).when(mContext).getPackageManager();
+ doReturn(mTestFileOutputStream).when(mContext).openFileOutput(anyString(), anyInt());
+ doReturn(mTestFile).when(mContext).getFileStreamPath(anyString());
+ }
+
+ @After
+ public void tearDown() {
+ mTestFile.delete();
+ mTestFile = null;
+ mFolder = null;
+ mIncomingMmsList = null;
+ mIncomingMms1Proto = null;
+ mIncomingMms2Proto = null;
+ mOutgoingMmsList = null;
+ mOutgoingMms1Proto = null;
+ mOutgoingMms2Proto = null;
+ mTestablePersistMmsAtomsStorage = null;
+ mTestFileOutputStream = null;
+ mPackageManager = null;
+ mContext = null;
+ }
+
+ @Test
+ public void loadAtoms_fileNotExist() {
+ mTestFile.delete();
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // No exception should be thrown, storage should be empty, pull time should be start time.
+ assertAllPullTimestampEquals(START_TIME_MILLIS);
+ assertStorageIsEmptyForAllAtoms();
+ }
+
+ @Test
+ public void loadAtoms_unreadable() throws Exception {
+ createEmptyTestFile();
+ mTestFile.setReadable(false);
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // No exception should be thrown, storage should be empty, pull time should be start time.
+ assertAllPullTimestampEquals(START_TIME_MILLIS);
+ assertStorageIsEmptyForAllAtoms();
+ }
+
+ @Test
+ public void loadAtoms_emptyProto() throws Exception {
+ createEmptyTestFile();
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // No exception should be thrown, storage should be empty, pull time should be start time.
+ assertAllPullTimestampEquals(START_TIME_MILLIS);
+ assertStorageIsEmptyForAllAtoms();
+ }
+
+ @Test
+ public void loadAtoms_malformedFile() throws Exception {
+ FileOutputStream stream = new FileOutputStream(mTestFile);
+ stream.write("This is not a proto file.".getBytes(StandardCharsets.UTF_8));
+ stream.close();
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // No exception should be thrown, storage should be empty, pull time should be start time.
+ assertAllPullTimestampEquals(START_TIME_MILLIS);
+ assertStorageIsEmptyForAllAtoms();
+ }
+
+ @Test
+ public void loadAtoms_pullTimeMissing() throws Exception {
+ // Create test file with lastPullTimeMillis = 0L, i.e. default/unknown.
+ createTestFile(0L);
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // No exception should be thrown, storage should be match, pull time should be start time.
+ assertAllPullTimestampEquals(START_TIME_MILLIS);
+ assertProtoListEqualsIgnoringOrder(mIncomingMmsList,
+ mTestablePersistMmsAtomsStorage.getIncomingMms(0L));
+ assertProtoListEqualsIgnoringOrder(mOutgoingMmsList,
+ mTestablePersistMmsAtomsStorage.getOutgoingMms(0L));
+ }
+
+ @Test
+ public void loadAtoms_validContents() throws Exception {
+ createTestFile(100L);
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+
+ // No exception should be thrown, storage and pull time should match.
+ assertAllPullTimestampEquals(100L);
+ assertProtoListEqualsIgnoringOrder(mIncomingMmsList,
+ mTestablePersistMmsAtomsStorage.getIncomingMms(0L));
+ assertProtoListEqualsIgnoringOrder(mOutgoingMmsList,
+ mTestablePersistMmsAtomsStorage.getOutgoingMms(0L));
+ }
+
+ @Test
+ public void addIncomingMms_emptyProto() throws Exception {
+ createEmptyTestFile();
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.addIncomingMms(mIncomingMms1Proto);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // IncomingMms should be added successfully, there should not be any OutgoingMms,
+ // changes should be saved.
+ verifyCurrentStateSavedToFileOnce();
+ assertProtoListIsEmpty(mTestablePersistMmsAtomsStorage.getOutgoingMms(0L));
+ List<IncomingMms> expectedIncomingMmsList = new ArrayList<>();
+ expectedIncomingMmsList.add(mIncomingMms1Proto);
+ assertProtoListEquals(expectedIncomingMmsList,
+ mTestablePersistMmsAtomsStorage.getIncomingMms(0L));
+ }
+
+ @Test
+ public void addIncomingMms_withExistingEntries() throws Exception {
+ createEmptyTestFile();
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.addIncomingMms(mIncomingMms1Proto);
+ mTestablePersistMmsAtomsStorage.addIncomingMms(mIncomingMms2Proto);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // IncomingMms should be added successfully.
+ verifyCurrentStateSavedToFileOnce();
+ List<IncomingMms> expectedIncomingMmsList = Arrays.asList(mIncomingMms1Proto,
+ mIncomingMms2Proto);
+ assertProtoListEqualsIgnoringOrder(expectedIncomingMmsList,
+ mTestablePersistMmsAtomsStorage.getIncomingMms(0L));
+ }
+
+ @Test
+ public void addIncomingMms_updateExistingEntries() throws Exception {
+ createTestFile(START_TIME_MILLIS);
+
+ // Add copy of mIncomingMms1Proto.
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.addIncomingMms(copyOf(mIncomingMms1Proto));
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // mIncomingMms1Proto's mms count should be increased by 1 and avgIntervalMillis
+ // should be updated correctly.
+ verifyCurrentStateSavedToFileOnce();
+ IncomingMms newIncomingMm1Proto = copyOf(mIncomingMms1Proto);
+ newIncomingMm1Proto = newIncomingMm1Proto.toBuilder()
+ .setMmsCount(2)
+ .setAvgIntervalMillis(mIncomingMms1Proto.getAvgIntervalMillis())
+ .build();
+ List<IncomingMms> expectedIncomingMmsList = Arrays.asList(newIncomingMm1Proto,
+ mIncomingMms2Proto);
+ assertProtoListEqualsIgnoringOrder(expectedIncomingMmsList,
+ mTestablePersistMmsAtomsStorage.getIncomingMms(0L));
+ }
+
+ @Test
+ public void addIncomingMms_tooManyEntries() throws Exception {
+ createEmptyTestFile();
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ // Add 26 mms whereas max size is 25.
+ IncomingMms mms = IncomingMms.newBuilder()
+ .setRoaming(ServiceState.ROAMING_TYPE_DOMESTIC)
+ .setSimSlotIndex(0)
+ .setIsMultiSim(false)
+ .setIsEsim(false)
+ .setCarrierId(CARRIER1_ID)
+ .setMmsCount(1)
+ .setAvgIntervalMillis(500L)
+ .setRetryId(0)
+ .setHandledByCarrierApp(false)
+ .build();
+ for (int ratType = 0; ratType < 5; ratType++) {
+ for (int resultType = 0; resultType < 5; resultType++) {
+ mms = mms.toBuilder().setRat(ratType).setResult(resultType).build();
+ mTestablePersistMmsAtomsStorage.addIncomingMms(mms);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+ }
+ }
+
+ // Add 26th mms 5 times
+ IncomingMms lastMms = copyOf(mms);
+ lastMms = lastMms.toBuilder().setRat(6).setResult(6).build();
+ for (int i = 0; i < 5; i++) {
+ mTestablePersistMmsAtomsStorage.addIncomingMms(lastMms);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+ }
+
+ // Last mms should be present in storage.
+ assertHasMmsAndCountAvg(mTestablePersistMmsAtomsStorage.getIncomingMms(0L),
+ lastMms, 5L, lastMms.getAvgIntervalMillis());
+ }
+
+ @Test
+ public void getIncomingMms_tooFrequent() throws Exception {
+ createTestFile(START_TIME_MILLIS);
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ // Pull interval less than minimum.
+ mTestablePersistMmsAtomsStorage.incTimeMillis(50L);
+
+ List<IncomingMms> incomingMmsList = mTestablePersistMmsAtomsStorage
+ .getIncomingMms(100L);
+ // Should be denied.
+ assertNull(incomingMmsList);
+ }
+
+ @Test
+ public void getIncomingMms_withSavedAtoms() throws Exception {
+ createTestFile(START_TIME_MILLIS);
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+ List<IncomingMms> incomingMmsList1 = mTestablePersistMmsAtomsStorage
+ .getIncomingMms(50L);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+ List<IncomingMms> incomingMmsList2 = mTestablePersistMmsAtomsStorage
+ .getIncomingMms(50L);
+
+ // First set of results should be equal to file contents.
+ List<IncomingMms> expectedIncomingMmsList = Arrays.asList(mIncomingMms1Proto,
+ mIncomingMms2Proto);
+ assertProtoListEqualsIgnoringOrder(expectedIncomingMmsList, incomingMmsList1);
+ // Second set of results should be empty.
+ expectedIncomingMmsList = new ArrayList<>();
+ assertProtoListEqualsIgnoringOrder(expectedIncomingMmsList, incomingMmsList2);
+ // Corresponding pull timestamp should be updated and saved.
+ assertEquals(START_TIME_MILLIS + 200L, mTestablePersistMmsAtomsStorage
+ .getAtomsProto().getIncomingMmsPullTimestampMillis());
+ InOrder inOrder = inOrder(mTestFileOutputStream);
+ assertEquals(START_TIME_MILLIS + 100L,
+ getAtomsWritten(inOrder).getIncomingMmsPullTimestampMillis());
+ assertEquals(START_TIME_MILLIS + 200L,
+ getAtomsWritten(inOrder).getIncomingMmsPullTimestampMillis());
+ inOrder.verifyNoMoreInteractions();
+ }
+
+ @Test
+ public void addOutgoingMms_emptyProto() throws Exception {
+ createEmptyTestFile();
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.addOutgoingMms(mOutgoingMms1Proto);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // OutgoingMms should be added successfully, there should not be any IncomingMms,
+ // changes should be saved.
+ verifyCurrentStateSavedToFileOnce();
+ assertProtoListIsEmpty(mTestablePersistMmsAtomsStorage.getIncomingMms(0L));
+ List<OutgoingMms> expectedOutgoingMmsList = new ArrayList<>();
+ expectedOutgoingMmsList.add(mOutgoingMms1Proto);
+ assertProtoListEquals(expectedOutgoingMmsList,
+ mTestablePersistMmsAtomsStorage.getOutgoingMms(0L));
+ }
+
+ @Test
+ public void addOutgoingMms_withExistingEntries() throws Exception {
+ createEmptyTestFile();
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.addOutgoingMms(mOutgoingMms1Proto);
+ mTestablePersistMmsAtomsStorage.addOutgoingMms(mOutgoingMms2Proto);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // OutgoingMms should be added successfully
+ verifyCurrentStateSavedToFileOnce();
+ List<OutgoingMms> expectedOutgoingMmsList = Arrays.asList(mOutgoingMms1Proto,
+ mOutgoingMms2Proto);
+ assertProtoListEqualsIgnoringOrder(expectedOutgoingMmsList,
+ mTestablePersistMmsAtomsStorage.getOutgoingMms(0L));
+ }
+
+ @Test
+ public void addOutgoingMms_updateExistingEntries() throws Exception {
+ createTestFile(START_TIME_MILLIS);
+
+ // Add copy of mOutgoingMms1Proto
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.addOutgoingMms(copyOf(mOutgoingMms1Proto));
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+
+ // mOutgoingMms1Proto's mms count should be increased by 1 and avgIntervalMillis
+ // should be updated correctly.
+ verifyCurrentStateSavedToFileOnce();
+ OutgoingMms newOutgoingMm1Proto = copyOf(mOutgoingMms1Proto);
+ newOutgoingMm1Proto = newOutgoingMm1Proto.toBuilder()
+ .setMmsCount(2)
+ .setAvgIntervalMillis(mOutgoingMms1Proto.getAvgIntervalMillis())
+ .build();
+ List<OutgoingMms> expectedOutgoingMmsList = Arrays.asList(newOutgoingMm1Proto,
+ mOutgoingMms2Proto);
+ assertProtoListEqualsIgnoringOrder(expectedOutgoingMmsList,
+ mTestablePersistMmsAtomsStorage.getOutgoingMms(0L));
+ }
+
+ @Test
+ public void addOutgoingMms_tooManyEntries() throws Exception {
+ createEmptyTestFile();
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ // Add 26 mms whereas max size is 25.
+ OutgoingMms mms = OutgoingMms.newBuilder()
+ .setRoaming(ServiceState.ROAMING_TYPE_DOMESTIC)
+ .setSimSlotIndex(0)
+ .setIsMultiSim(false)
+ .setIsEsim(false)
+ .setCarrierId(CARRIER1_ID)
+ .setMmsCount(1)
+ .setAvgIntervalMillis(500L)
+ .setIsFromDefaultApp(true)
+ .setHandledByCarrierApp(false)
+ .setRetryId(0)
+ .build();
+ for (int ratType = 0; ratType < 5; ratType++) {
+ for (int resultType = 0; resultType < 5; resultType++) {
+ mms = mms.toBuilder().setRat(ratType).setResult(resultType).build();
+ mTestablePersistMmsAtomsStorage.addOutgoingMms(mms);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+ }
+ }
+
+ // Add 26th mms 5 times
+ OutgoingMms lastMms = copyOf(mms);
+ lastMms = lastMms.toBuilder().setRat(6).setResult(6).build();
+ for (int i = 0; i < 5; i++) {
+ mTestablePersistMmsAtomsStorage.addOutgoingMms(lastMms);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+ }
+
+ // Last mms should be present in storage.
+ assertHasMmsAndCountAvg(mTestablePersistMmsAtomsStorage.getOutgoingMms(0L),
+ lastMms, 5L, lastMms.getAvgIntervalMillis());
+ }
+
+ @Test
+ public void getOutgoingMms_tooFrequent() throws Exception {
+ createTestFile(START_TIME_MILLIS);
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ // Pull interval less than minimum.
+ mTestablePersistMmsAtomsStorage.incTimeMillis(50L);
+
+ List<OutgoingMms> outgoingMmsList = mTestablePersistMmsAtomsStorage
+ .getOutgoingMms(100L);
+ // Should be denied.
+ assertNull(outgoingMmsList);
+ }
+
+ @Test
+ public void getOutgoingMms_withSavedAtoms() throws Exception {
+ createTestFile(START_TIME_MILLIS);
+
+ mTestablePersistMmsAtomsStorage = new TestablePersistMmsAtomsStorage(mContext);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+ List<OutgoingMms> outgoingMmsList1 = mTestablePersistMmsAtomsStorage
+ .getOutgoingMms(50L);
+ mTestablePersistMmsAtomsStorage.incTimeMillis(100L);
+ List<OutgoingMms> outgoingMmsList2 = mTestablePersistMmsAtomsStorage
+ .getOutgoingMms(50L);
+
+ // First set of results should be equal to file contents.
+ List<OutgoingMms> expectedOutgoingMmsList = Arrays.asList(mOutgoingMms1Proto,
+ mOutgoingMms2Proto);
+ assertProtoListEqualsIgnoringOrder(expectedOutgoingMmsList, outgoingMmsList1);
+ // Second set of results should be empty.
+ expectedOutgoingMmsList = new ArrayList<>();
+ assertProtoListEqualsIgnoringOrder(expectedOutgoingMmsList, outgoingMmsList2);
+ // Corresponding pull timestamp should be updated and saved.
+ assertEquals(START_TIME_MILLIS + 200L, mTestablePersistMmsAtomsStorage
+ .getAtomsProto().getOutgoingMmsPullTimestampMillis());
+ InOrder inOrder = inOrder(mTestFileOutputStream);
+ assertEquals(START_TIME_MILLIS + 100L,
+ getAtomsWritten(inOrder).getOutgoingMmsPullTimestampMillis());
+ assertEquals(START_TIME_MILLIS + 200L,
+ getAtomsWritten(inOrder).getOutgoingMmsPullTimestampMillis());
+ inOrder.verifyNoMoreInteractions();
+ }
+
+ /** Utilities */
+
+ private void assertAllPullTimestampEquals(long timestamp) {
+ assertEquals(timestamp, mTestablePersistMmsAtomsStorage.getAtomsProto()
+ .getIncomingMmsPullTimestampMillis());
+ assertEquals(timestamp, mTestablePersistMmsAtomsStorage.getAtomsProto()
+ .getOutgoingMmsPullTimestampMillis());
+ }
+
+ private void assertStorageIsEmptyForAllAtoms() {
+ assertProtoListIsEmpty(mTestablePersistMmsAtomsStorage.getIncomingMms(0L));
+ assertProtoListIsEmpty(mTestablePersistMmsAtomsStorage.getOutgoingMms(0L));
+ }
+
+ private static <T> void assertProtoListIsEmpty(@Nullable List<T> list) {
+ assertNotNull(list);
+ assertEquals(0, list.size());
+ }
+
+ private static <T> void assertProtoListEquals(@Nullable List<T> expected,
+ @Nullable List<T> actual) {
+ assertNotNull(expected);
+ assertNotNull(actual);
+ String message =
+ "Expected:\n" + expected.stream().map(Object::toString).collect(
+ Collectors.joining(", "))
+ + "\nGot:\n" + actual.stream().map(Object::toString).collect(
+ Collectors.joining(", "));
+ assertEquals(message, expected.size(), actual.size());
+ for (int i = 0; i < expected.size(); i++) {
+ assertTrue(message, expected.get(i).equals(actual.get(i)));
+ }
+ }
+
+ private static <T> void assertProtoListEqualsIgnoringOrder(@Nullable List<T> expected,
+ @Nullable List<T> actual) {
+ assertNotNull(expected);
+ assertNotNull(actual);
+ expected = new ArrayList<>(expected);
+ actual = new ArrayList<>(actual);
+ Collections.sort(expected, sProtoComparator);
+ Collections.sort(actual, sProtoComparator);
+ assertProtoListEquals(expected, actual);
+ }
+
+ private static void assertHasMmsAndCountAvg(@Nullable List<IncomingMms> incomingMmsList,
+ @Nullable IncomingMms expectedMms, long expectedCount, long expectedAvg) {
+ assertNotNull(incomingMmsList);
+ assertNotNull(expectedMms);
+ long actualCount = -1;
+ long actualAvg = -1;
+ for (IncomingMms mms : incomingMmsList) {
+ if (mms.getRat() == expectedMms.getRat()
+ && mms.getResult() == expectedMms.getResult()
+ && mms.getRoaming() == expectedMms.getRoaming()
+ && mms.getSimSlotIndex() == expectedMms.getSimSlotIndex()
+ && mms.getIsMultiSim() == expectedMms.getIsMultiSim()
+ && mms.getIsEsim() == expectedMms.getIsEsim()
+ && mms.getCarrierId() == expectedMms.getCarrierId()
+ && mms.getRetryId() == expectedMms.getRetryId()
+ && mms.getHandledByCarrierApp() == expectedMms.getHandledByCarrierApp()) {
+ actualCount = mms.getMmsCount();
+ actualAvg = mms.getAvgIntervalMillis();
+ }
+ }
+
+ assertEquals(expectedCount, actualCount);
+ assertEquals(expectedAvg, actualAvg);
+ }
+
+ private static void assertHasMmsAndCountAvg(@Nullable List<OutgoingMms> outgoingMmsList,
+ @Nullable OutgoingMms expectedMms, long expectedCount, long expectedAvg) {
+ assertNotNull(outgoingMmsList);
+ assertNotNull(expectedMms);
+ long actualCount = -1;
+ long actualAvg = -1;
+ for (OutgoingMms mms : outgoingMmsList) {
+ if (mms.getRat() == expectedMms.getRat()
+ && mms.getResult() == expectedMms.getResult()
+ && mms.getRoaming() == expectedMms.getRoaming()
+ && mms.getSimSlotIndex() == expectedMms.getSimSlotIndex()
+ && mms.getIsMultiSim() == expectedMms.getIsMultiSim()
+ && mms.getIsEsim() == expectedMms.getIsEsim()
+ && mms.getCarrierId() == expectedMms.getCarrierId()
+ && mms.getIsFromDefaultApp() == expectedMms.getIsFromDefaultApp()
+ && mms.getRetryId() == expectedMms.getRetryId()
+ && mms.getHandledByCarrierApp() == expectedMms.getHandledByCarrierApp()) {
+ actualCount = mms.getMmsCount();
+ actualAvg = mms.getAvgIntervalMillis();
+ }
+ }
+
+ assertEquals(expectedCount, actualCount);
+ assertEquals(expectedAvg, actualAvg);
+ }
+
+ private void verifyCurrentStateSavedToFileOnce() throws Exception {
+ InOrder inOrder = inOrder(mTestFileOutputStream);
+ inOrder.verify(mTestFileOutputStream, times(1))
+ .write(eq(mTestablePersistMmsAtomsStorage.getAtomsProto().toByteArray()));
+ inOrder.verify(mTestFileOutputStream, times(1)).close();
+ inOrder.verifyNoMoreInteractions();
+ }
+
+ private PersistMmsAtoms getAtomsWritten(@Nullable InOrder inOrder) throws Exception {
+ if (inOrder == null) {
+ inOrder = inOrder(mTestFileOutputStream);
+ }
+ ArgumentCaptor bytesCaptor = ArgumentCaptor.forClass(Object.class);
+ inOrder.verify(mTestFileOutputStream, times(1))
+ .write((byte[]) bytesCaptor.capture());
+ PersistMmsAtoms savedAtoms = PersistMmsAtoms.parseFrom((byte[]) bytesCaptor.getValue());
+ inOrder.verify(mTestFileOutputStream, times(1)).close();
+ return savedAtoms;
+ }
+
+ private static IncomingMms copyOf(IncomingMms source) {
+ return source.toBuilder().build();
+ }
+
+ private static OutgoingMms copyOf(OutgoingMms source) {
+ return source.toBuilder().build();
+ }
+
+ private void makeTestData() {
+ mIncomingMms1Proto = IncomingMms.newBuilder()
+ .setRat(TelephonyManager.NETWORK_TYPE_LTE)
+ .setResult(1)
+ .setRoaming(ServiceState.ROAMING_TYPE_NOT_ROAMING)
+ .setSimSlotIndex(0)
+ .setIsMultiSim(true)
+ .setIsEsim(false)
+ .setCarrierId(CARRIER1_ID)
+ .setAvgIntervalMillis(500L)
+ .setMmsCount(1)
+ .setRetryId(0)
+ .setHandledByCarrierApp(false)
+ .build();
+
+ mIncomingMms2Proto = IncomingMms.newBuilder()
+ .setRat(TelephonyManager.NETWORK_TYPE_LTE)
+ .setResult(1)
+ .setRoaming(ServiceState.ROAMING_TYPE_NOT_ROAMING)
+ .setSimSlotIndex(1)
+ .setIsMultiSim(false)
+ .setIsEsim(false)
+ .setCarrierId(CARRIER2_ID)
+ .setAvgIntervalMillis(500L)
+ .setMmsCount(1)
+ .setRetryId(0)
+ .setHandledByCarrierApp(false)
+ .build();
+
+ mIncomingMmsList = new ArrayList<>();
+ mIncomingMmsList.add(mIncomingMms1Proto);
+ mIncomingMmsList.add(mIncomingMms2Proto);
+
+ mOutgoingMms1Proto = OutgoingMms.newBuilder()
+ .setRat(0)
+ .setResult(1)
+ .setRoaming(0)
+ .setSimSlotIndex(0)
+ .setIsMultiSim(true)
+ .setIsEsim(false)
+ .setCarrierId(CARRIER1_ID)
+ .setAvgIntervalMillis(500L)
+ .setMmsCount(1)
+ .setIsFromDefaultApp(true)
+ .setRetryId(0)
+ .setHandledByCarrierApp(false)
+ .build();
+
+ mOutgoingMms2Proto = OutgoingMms.newBuilder()
+ .setRat(0)
+ .setResult(1)
+ .setRoaming(0)
+ .setSimSlotIndex(0)
+ .setIsMultiSim(false)
+ .setIsEsim(false)
+ .setCarrierId(CARRIER2_ID)
+ .setAvgIntervalMillis(500L)
+ .setMmsCount(1)
+ .setIsFromDefaultApp(true)
+ .setRetryId(0)
+ .setHandledByCarrierApp(false)
+ .build();
+
+ mOutgoingMmsList = new ArrayList<>();
+ mOutgoingMmsList.add(mOutgoingMms1Proto);
+ mOutgoingMmsList.add(mOutgoingMms2Proto);
+ }
+
+ private void createEmptyTestFile() throws Exception {
+ PersistMmsAtoms atoms = PersistMmsAtoms.newBuilder().build();
+ FileOutputStream stream = new FileOutputStream(mTestFile);
+ stream.write(atoms.toByteArray());
+ stream.close();
+ }
+
+ private void createTestFile(long lastPullTimeMillis) throws Exception {
+ PersistMmsAtoms atoms = PersistMmsAtoms.newBuilder()
+ .setBuildFingerprint(Build.FINGERPRINT)
+ .setIncomingMmsPullTimestampMillis(lastPullTimeMillis)
+ .setOutgoingMmsPullTimestampMillis(lastPullTimeMillis)
+ .addAllIncomingMms(mIncomingMmsList)
+ .addAllOutgoingMms(mOutgoingMmsList)
+ .build();
+
+ FileOutputStream stream = new FileOutputStream(mTestFile);
+ stream.write(atoms.toByteArray());
+ stream.close();
+ }
+
+ private static class TestablePersistMmsAtomsStorage extends PersistMmsAtomsStorage {
+ private long mTimeMillis = START_TIME_MILLIS;
+
+ TestablePersistMmsAtomsStorage(Context context) {
+ super(context);
+ // Remove delay for saving to persistent storage during tests.
+ mSaveImmediately = true;
+ }
+
+ @Override
+ protected long getWallTimeMillis() {
+ // NOTE: super class constructor will be executed before private field is set, which
+ // gives the wrong start time (mTimeMillis will have its default value of 0L).
+ return mTimeMillis == 0L ? START_TIME_MILLIS : mTimeMillis;
+ }
+
+ private void incTimeMillis(long timeMillis) {
+ mTimeMillis += timeMillis;
+ }
+
+ private PersistMmsAtoms getAtomsProto() {
+ // NOTE: unlike other methods in PersistAtomsStorage, this is not synchronized, but
+ // should be fine since the test is single-threaded.
+ return mPersistMmsAtoms;
+ }
+ }
+}
\ No newline at end of file
