From 8887011b87f29ac33de4af781ce4d8f4f03fcd16 Mon Sep 17 00:00:00 2001 From: Yaqing Lu Date: Tue, 28 Feb 2023 15:49:33 +0800 Subject: [PATCH] Fix network can't handle simultaneously SS request for both subs When disabling Smart forwarding, the SS requests for both subs will be sent simultaneously, but sometimes network can't handle both SS requests from both subs causing call forwarding settings to not be changed without any notification to user. Send the next SS request after completing the previous request same as enabling Smart forwarding. Test: manual Bug: 289326844 Change-Id: I4869fa200d3fbb70ba1b6b46cc491ea45299f412 --- .../DisableSmartForwardingTask.java | 135 ++++++++++++++++-- .../SmartForwardingActivity.java | 23 ++- 2 files changed, 139 insertions(+), 19 deletions(-) diff --git a/src/com/android/settings/sim/smartForwarding/DisableSmartForwardingTask.java b/src/com/android/settings/sim/smartForwarding/DisableSmartForwardingTask.java index a1035dc8477..8448319f32c 100644 --- a/src/com/android/settings/sim/smartForwarding/DisableSmartForwardingTask.java +++ b/src/com/android/settings/sim/smartForwarding/DisableSmartForwardingTask.java @@ -23,6 +23,14 @@ import android.telephony.SubscriptionManager; import android.telephony.TelephonyManager; import android.util.Log; +import com.android.settings.sim.smartForwarding.EnableSmartForwardingTask.UpdateCommand; + +import com.google.common.util.concurrent.SettableFuture; + +import java.util.ArrayList; +import java.util.concurrent.Executor; +import java.util.concurrent.Executors; + public class DisableSmartForwardingTask implements Runnable { private final TelephonyManager tm; private final boolean[] callWaitingStatus; @@ -37,22 +45,123 @@ public class DisableSmartForwardingTask implements Runnable { @Override public void run() { - for (int i = 0; i < tm.getActiveModemCount(); i++) { - int subId = getSubId(i); - if (callWaitingStatus != null - && subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) { - Log.d(TAG, "Restore call waiting to " + callWaitingStatus[i]); - tm.createForSubscriptionId(subId) - .setCallWaitingEnabled(callWaitingStatus[i], null, null); + FlowController controller = new FlowController(); + if (controller.init()) { + controller.startProcess(); + } + } + + class FlowController { + private final ArrayList mSteps = new ArrayList<>(); + + /* package */ boolean init() { + if (tm == null) { + Log.e(TAG, "TelephonyManager is null"); + return false; } - if (callForwardingInfo != null - && callForwardingInfo[i] != null - && subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) { - Log.d(TAG, "Restore call forwarding to " + callForwardingInfo[i]); - tm.createForSubscriptionId(subId) - .setCallForwarding(callForwardingInfo[i], null, null); + if (callWaitingStatus == null || callForwardingInfo == null) { + Log.e(TAG, "CallWaitingStatus or CallForwardingInfo array is null"); + return false; } + + int slotCount = tm.getActiveModemCount(); + if (callWaitingStatus.length != slotCount || callForwardingInfo.length != slotCount) { + Log.e(TAG, "The length of CallWaitingStatus and CallForwardingInfo array" + + " should be the same as phone count."); + return false; + } + + Executor executor = Executors.newSingleThreadExecutor(); + + for (int i = 0; i < slotCount; i++) { + int subId = getSubId(i); + if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { + continue; + } + + mSteps.add(new RestoreCallWaitingCommand( + tm, executor, callWaitingStatus[i], subId)); + + if (callForwardingInfo[i] != null) { + mSteps.add(new RestoreCallForwardingCommand( + tm, executor, callForwardingInfo[i], subId)); + } + } + + return true; + } + + /* package */ void startProcess() { + int index = 0; + + while (index < mSteps.size()) { + UpdateCommand currentStep = mSteps.get(index); + Log.d(TAG, "processing : " + currentStep); + + try { + currentStep.process(); + index++; + } catch (Exception e) { + Log.e(TAG, "Failed on : " + currentStep, e); + } + } + } + } + + class RestoreCallForwardingCommand extends UpdateCommand { + private SettableFuture mResultFuture = SettableFuture.create(); + private CallForwardingInfo mCallForwardingInfo; + + /* package */ RestoreCallForwardingCommand(TelephonyManager tm, Executor executor, + CallForwardingInfo mCallForwardingInfo, int subId) { + super(tm, executor, subId); + this.mCallForwardingInfo = mCallForwardingInfo; + } + + @Override + public boolean process() throws Exception { + Log.d(TAG, "Restore call forwarding to " + mCallForwardingInfo); + tm.createForSubscriptionId(subId).setCallForwarding(mCallForwardingInfo, executor, + this::updateStatusCallBack); + return mResultFuture.get(); + } + + @Override + void onRestore() { + } + + private void updateStatusCallBack(int result) { + Log.d(TAG, "updateStatusCallBack for CallForwarding: " + result); + mResultFuture.set(true); + } + } + + class RestoreCallWaitingCommand extends UpdateCommand { + private SettableFuture mResultFuture = SettableFuture.create(); + private boolean mCallWaitingStatus; + + /* package */ RestoreCallWaitingCommand(TelephonyManager tm, Executor executor, + boolean mCallWaitingStatus, int subId) { + super(tm, executor, subId); + this.mCallWaitingStatus = mCallWaitingStatus; + } + + @Override + public boolean process() throws Exception { + Log.d(TAG, "Restore call waiting to " + mCallWaitingStatus); + tm.createForSubscriptionId(subId).setCallWaitingEnabled(mCallWaitingStatus, executor, + this::updateStatusCallBack); + return mResultFuture.get(); + } + + @Override + void onRestore() { + } + + private void updateStatusCallBack(int result) { + Log.d(TAG, "updateStatusCallBack for CallWaiting: " + result); + mResultFuture.set(true); } } diff --git a/src/com/android/settings/sim/smartForwarding/SmartForwardingActivity.java b/src/com/android/settings/sim/smartForwarding/SmartForwardingActivity.java index 070e65a1d56..7e5d575ed9c 100644 --- a/src/com/android/settings/sim/smartForwarding/SmartForwardingActivity.java +++ b/src/com/android/settings/sim/smartForwarding/SmartForwardingActivity.java @@ -85,12 +85,7 @@ public class SmartForwardingActivity extends SettingsBaseActivity { public void enableSmartForwarding(String[] phoneNumber) { // Pop-up ongoing dialog - ProgressDialog dialog = new ProgressDialog(this); - dialog.setTitle(R.string.smart_forwarding_ongoing_title); - dialog.setIndeterminate(true); - dialog.setMessage(getText(R.string.smart_forwarding_ongoing_text)); - dialog.setCancelable(false); - dialog.show(); + ProgressDialog dialog = showOngoingDialog(); // Enable feature ListenableFuture enableTask = @@ -140,6 +135,9 @@ public class SmartForwardingActivity extends SettingsBaseActivity { boolean[] callWaitingStatus = getAllSlotCallWaitingStatus(this, sm, tm); CallForwardingInfo[] callForwardingInfo = getAllSlotCallForwardingStatus(this, sm, tm); + // Pop-up ongoing dialog + ProgressDialog dialog = showOngoingDialog(); + // Disable feature ListenableFuture disableTask = service.submit(new DisableSmartForwardingTask( tm, callWaitingStatus, callForwardingInfo)); @@ -147,11 +145,13 @@ public class SmartForwardingActivity extends SettingsBaseActivity { @Override public void onSuccess(Object result) { clearAllBackupData(SmartForwardingActivity.this, sm, tm); + dialog.dismiss(); } @Override public void onFailure(Throwable t) { Log.e(TAG, "Disable Feature exception" + t); + dialog.dismiss(); } }, ContextCompat.getMainExecutor(this)); } @@ -174,4 +174,15 @@ public class SmartForwardingActivity extends SettingsBaseActivity { .create(); mDialog.show(); } + + private ProgressDialog showOngoingDialog() { + ProgressDialog dialog = new ProgressDialog(this); + dialog.setTitle(R.string.smart_forwarding_ongoing_title); + dialog.setIndeterminate(true); + dialog.setMessage(getText(R.string.smart_forwarding_ongoing_text)); + dialog.setCancelable(false); + dialog.show(); + + return dialog; + } }