MmsNetworkManager uses network release timeout from carrier config am: b4c34c3c85 am: 827b4ed0af

Original change: https://android-review.googlesource.com/c/platform/packages/services/Mms/+/2334430

Change-Id: I2903c95a78a43ae332c518c43ee277eead3e8068
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

2 files changed, 117 insertions, 17 deletions

diff --git a/src/com/android/mms/service/MmsNetworkManager.java b/src/com/android/mms/service/MmsNetworkManager.java
index 6799d29..52feb77 100644
--- a/src/com/android/mms/service/MmsNetworkManager.java
+++ b/src/com/android/mms/service/MmsNetworkManager.java
@@ -26,11 +26,16 @@ import android.net.NetworkCapabilities;
 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 @@ public class MmsNetworkManager {
     // 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 @@ public class MmsNetworkManager {
     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 = (5 * 1000);
+    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,39 @@ public class MmsNetworkManager {
     }
 
     /**
+     * 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);
+        if (config == null) {
+                LogUtil.e("MmsNetworkManager: handleCarrierConfigChanged() config is null");
+                return;
+        }
+        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 +308,13 @@ public class MmsNetworkManager {
                 }
             }
         };
+
+        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 +340,7 @@ public class MmsNetworkManager {
                 return;
             }
 
-            if (!mReceiverRegistered) {
+            if (!mSimCardStateChangedReceiverRegistered) {
                 mPhoneId = mDeps.getPhoneId(mSubId);
                 if (mPhoneId == SubscriptionManager.INVALID_PHONE_INDEX
                         || mPhoneId == SubscriptionManager.DEFAULT_PHONE_INDEX) {
@@ -279,9 +349,9 @@ public class MmsNetworkManager {
 
                 // 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 +367,10 @@ public class MmsNetworkManager {
                 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 +398,11 @@ public class MmsNetworkManager {
     /**
      * 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 +415,7 @@ public class MmsNetworkManager {
                         // handler to release the network
                         mReleaseHandler.removeCallbacks(mNetworkReleaseTask);
                         mReleaseHandler.postDelayed(mNetworkReleaseTask,
-                                NETWORK_RELEASE_TIMEOUT_MILLIS);
+                                mNetworkReleaseTimeoutMillis);
                     } else {
                         releaseRequestLocked(mNetworkCallback);
                     }
@@ -443,4 +514,9 @@ public class MmsNetworkManager {
         }
         return apnName;
     }
+
+    @VisibleForTesting
+    protected int getNetworkReleaseTimeoutMillis() {
+        return mNetworkReleaseTimeoutMillis;
+    }
 }
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.ConnectivityManager.NetworkCallback;
 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 @@ public final class MmsNetworkManagerTest {
     @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 @@ public final class MmsNetworkManagerTest {
         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 @@ public final class MmsNetworkManagerTest {
         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 =