| /* |
| * Copyright 2020 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.phone; |
| |
| import static com.android.internal.telephony.TelephonyStatsLog.RCS_ACS_PROVISIONING_STATS__RESPONSE_TYPE__PROVISIONING_XML; |
| import static com.android.internal.telephony.TelephonyStatsLog.RCS_CLIENT_PROVISIONING_STATS__EVENT__DMA_CHANGED; |
| import static com.android.internal.telephony.TelephonyStatsLog.RCS_CLIENT_PROVISIONING_STATS__EVENT__TRIGGER_RCS_RECONFIGURATION; |
| |
| import android.Manifest; |
| import android.app.role.OnRoleHoldersChangedListener; |
| import android.app.role.RoleManager; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.PackageManager; |
| import android.os.Build; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.PersistableBundle; |
| import android.os.RemoteException; |
| import android.os.UserHandle; |
| import android.telephony.CarrierConfigManager; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyRegistryManager; |
| import android.telephony.ims.ProvisioningManager; |
| import android.telephony.ims.RcsConfig; |
| import android.telephony.ims.aidl.IImsConfig; |
| import android.telephony.ims.aidl.IRcsConfigCallback; |
| import android.text.TextUtils; |
| import android.util.ArraySet; |
| import android.util.SparseArray; |
| |
| import com.android.ims.FeatureConnector; |
| import com.android.ims.FeatureUpdates; |
| import com.android.ims.RcsFeatureManager; |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.telephony.metrics.RcsStats; |
| import com.android.internal.telephony.metrics.RcsStats.RcsProvisioningCallback; |
| import com.android.internal.telephony.util.HandlerExecutor; |
| import com.android.internal.util.CollectionUtils; |
| import com.android.telephony.Rlog; |
| |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.Executor; |
| |
| /** |
| * Class to monitor RCS Provisioning Status |
| */ |
| public class RcsProvisioningMonitor { |
| private static final String TAG = "RcsProvisioningMonitor"; |
| private static final boolean DBG = Build.IS_ENG; |
| |
| private static final int EVENT_SUB_CHANGED = 1; |
| private static final int EVENT_DMA_CHANGED = 2; |
| private static final int EVENT_CC_CHANGED = 3; |
| private static final int EVENT_CONFIG_RECEIVED = 4; |
| private static final int EVENT_RECONFIG_REQUEST = 5; |
| private static final int EVENT_DEVICE_CONFIG_OVERRIDE = 6; |
| private static final int EVENT_CARRIER_CONFIG_OVERRIDE = 7; |
| private static final int EVENT_RESET = 8; |
| private static final int EVENT_FEATURE_ENABLED_OVERRIDE = 9; |
| |
| // indicate that the carrier single registration capable is initial value as |
| // carrier config is not ready yet. |
| private static final int MASK_CAP_CARRIER_INIT = 0xF000; |
| |
| private final PhoneGlobals mPhone; |
| private final Handler mHandler; |
| // Cache the RCS provsioning info and related sub id |
| private final ConcurrentHashMap<Integer, RcsProvisioningInfo> mRcsProvisioningInfos = |
| new ConcurrentHashMap<>(); |
| private Boolean mDeviceSingleRegistrationEnabledOverride; |
| private final HashMap<Integer, Boolean> mCarrierSingleRegistrationEnabledOverride = |
| new HashMap<>(); |
| private final ConcurrentHashMap<Integer, Boolean> mImsFeatureValidationOverride = |
| new ConcurrentHashMap<>(); |
| private String mDmaPackageName; |
| private final SparseArray<RcsFeatureListener> mRcsFeatureListeners = new SparseArray<>(); |
| private volatile boolean mTestModeEnabled; |
| |
| private final CarrierConfigManager mCarrierConfigManager; |
| private final DmaChangedListener mDmaChangedListener; |
| private final SubscriptionManager mSubscriptionManager; |
| private final TelephonyRegistryManager mTelephonyRegistryManager; |
| private final RoleManagerAdapter mRoleManager; |
| private FeatureConnectorFactory<RcsFeatureManager> mFeatureFactory; |
| |
| private RcsStats mRcsStats; |
| |
| private static RcsProvisioningMonitor sInstance; |
| |
| private final SubscriptionManager.OnSubscriptionsChangedListener mSubChangedListener = |
| new SubscriptionManager.OnSubscriptionsChangedListener() { |
| @Override |
| public void onSubscriptionsChanged() { |
| if (!mHandler.hasMessages(EVENT_SUB_CHANGED)) { |
| mHandler.sendEmptyMessage(EVENT_SUB_CHANGED); |
| } |
| } |
| }; |
| |
| private final BroadcastReceiver mReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| if (CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED.equals( |
| intent.getAction())) { |
| int subId = intent.getIntExtra(SubscriptionManager.EXTRA_SUBSCRIPTION_INDEX, |
| SubscriptionManager.INVALID_SUBSCRIPTION_ID); |
| logv("Carrier-config changed for sub : " + subId); |
| if (SubscriptionManager.isValidSubscriptionId(subId) |
| && !mHandler.hasMessages(EVENT_CC_CHANGED)) { |
| mHandler.sendEmptyMessage(EVENT_CC_CHANGED); |
| } |
| } |
| } |
| }; |
| |
| private final class DmaChangedListener implements OnRoleHoldersChangedListener { |
| @Override |
| public void onRoleHoldersChanged(String role, UserHandle user) { |
| if (RoleManager.ROLE_SMS.equals(role)) { |
| logv("default messaging application changed."); |
| mHandler.sendEmptyMessage(EVENT_DMA_CHANGED); |
| } |
| } |
| |
| public void register() { |
| try { |
| mRoleManager.addOnRoleHoldersChangedListenerAsUser( |
| mPhone.getMainExecutor(), this, UserHandle.SYSTEM); |
| } catch (RuntimeException e) { |
| loge("Could not register dma change listener due to " + e); |
| } |
| } |
| |
| public void unregister() { |
| try { |
| mRoleManager.removeOnRoleHoldersChangedListenerAsUser(this, UserHandle.SYSTEM); |
| } catch (RuntimeException e) { |
| loge("Could not unregister dma change listener due to " + e); |
| } |
| } |
| } |
| |
| private final class MyHandler extends Handler { |
| MyHandler(Looper looper) { |
| super(looper); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| logv("handleMessage: " + msg); |
| switch (msg.what) { |
| case EVENT_SUB_CHANGED: |
| onSubChanged(); |
| break; |
| case EVENT_DMA_CHANGED: |
| onDefaultMessagingApplicationChanged(); |
| break; |
| case EVENT_CC_CHANGED: |
| onCarrierConfigChange(); |
| break; |
| case EVENT_CONFIG_RECEIVED: |
| onConfigReceived(msg.arg1, (byte[]) msg.obj, msg.arg2 == 1); |
| break; |
| case EVENT_RECONFIG_REQUEST: |
| onReconfigRequest(msg.arg1); |
| break; |
| case EVENT_DEVICE_CONFIG_OVERRIDE: |
| Boolean deviceEnabled = (Boolean) msg.obj; |
| if (!booleanEquals(deviceEnabled, mDeviceSingleRegistrationEnabledOverride)) { |
| mDeviceSingleRegistrationEnabledOverride = deviceEnabled; |
| onCarrierConfigChange(); |
| } |
| break; |
| case EVENT_CARRIER_CONFIG_OVERRIDE: |
| Boolean carrierEnabledOverride = (Boolean) msg.obj; |
| Boolean carrierEnabled = mCarrierSingleRegistrationEnabledOverride.put( |
| msg.arg1, carrierEnabledOverride); |
| if (!booleanEquals(carrierEnabledOverride, carrierEnabled)) { |
| onCarrierConfigChange(); |
| } |
| break; |
| case EVENT_RESET: |
| reset(); |
| break; |
| default: |
| loge("Unhandled event " + msg.what); |
| } |
| } |
| } |
| |
| private final class RcsProvisioningInfo { |
| private int mSubId; |
| private volatile int mSingleRegistrationCapability; |
| private volatile byte[] mConfig; |
| private ArraySet<IRcsConfigCallback> mRcsConfigCallbacks; |
| private IImsConfig mIImsConfig; |
| private boolean mHasReconfigRequest; |
| |
| RcsProvisioningInfo(int subId, int singleRegistrationCapability, byte[] config) { |
| mSubId = subId; |
| mSingleRegistrationCapability = singleRegistrationCapability; |
| mConfig = config; |
| mRcsConfigCallbacks = new ArraySet<>(); |
| registerRcsFeatureListener(this); |
| } |
| |
| int getSubId() { |
| return mSubId; |
| } |
| |
| void setSingleRegistrationCapability(int singleRegistrationCapability) { |
| if (mSingleRegistrationCapability != singleRegistrationCapability) { |
| mSingleRegistrationCapability = singleRegistrationCapability; |
| notifyDma(); |
| |
| // update whether single registration supported. |
| mRcsStats.setEnableSingleRegistration(mSubId, |
| mSingleRegistrationCapability == ProvisioningManager.STATUS_CAPABLE); |
| } |
| } |
| |
| void notifyDma() { |
| // notify only if capable value has been updated when carrier config ready. |
| if ((mSingleRegistrationCapability & MASK_CAP_CARRIER_INIT) != MASK_CAP_CARRIER_INIT) { |
| logi("notify default messaging app for sub:" + mSubId + " with capability:" |
| + mSingleRegistrationCapability); |
| notifyDmaForSub(mSubId, mSingleRegistrationCapability); |
| } |
| } |
| |
| int getSingleRegistrationCapability() { |
| return mSingleRegistrationCapability; |
| } |
| |
| void setConfig(byte[] config) { |
| if (!Arrays.equals(mConfig, config)) { |
| mConfig = config; |
| if (mConfig != null) { |
| notifyRcsAutoConfigurationReceived(); |
| } else { |
| notifyRcsAutoConfigurationRemoved(); |
| } |
| } |
| } |
| |
| byte[] getConfig() { |
| return mConfig; |
| } |
| |
| boolean addRcsConfigCallback(IRcsConfigCallback cb) { |
| if (mIImsConfig == null) { |
| logd("fail to addRcsConfigCallback as imsConfig is null"); |
| return false; |
| } |
| |
| synchronized (mRcsConfigCallbacks) { |
| try { |
| mIImsConfig.addRcsConfigCallback(cb); |
| } catch (RemoteException e) { |
| loge("fail to addRcsConfigCallback due to " + e); |
| return false; |
| } |
| mRcsConfigCallbacks.add(cb); |
| } |
| return true; |
| } |
| |
| boolean removeRcsConfigCallback(IRcsConfigCallback cb) { |
| boolean result = true; |
| |
| synchronized (mRcsConfigCallbacks) { |
| if (mIImsConfig != null) { |
| try { |
| mIImsConfig.removeRcsConfigCallback(cb); |
| } catch (RemoteException e) { |
| loge("fail to removeRcsConfigCallback due to " + e); |
| } |
| } else { |
| // Return false but continue to remove the callback |
| result = false; |
| } |
| |
| try { |
| cb.onRemoved(); |
| } catch (RemoteException e) { |
| logd("Failed to notify onRemoved due to dead binder of " + cb); |
| } |
| mRcsConfigCallbacks.remove(cb); |
| } |
| return result; |
| } |
| |
| void triggerRcsReconfiguration() { |
| if (mIImsConfig != null) { |
| try { |
| logv("triggerRcsReconfiguration for sub:" + mSubId); |
| mIImsConfig.triggerRcsReconfiguration(); |
| mHasReconfigRequest = false; |
| } catch (RemoteException e) { |
| loge("triggerRcsReconfiguration failed due to " + e); |
| } |
| } else { |
| logd("triggerRcsReconfiguration failed due to IImsConfig null."); |
| mHasReconfigRequest = true; |
| } |
| } |
| |
| void destroy() { |
| unregisterRcsFeatureListener(this); |
| clear(); |
| mIImsConfig = null; |
| mRcsConfigCallbacks = null; |
| } |
| |
| void clear() { |
| setConfig(null); |
| clearCallbacks(); |
| } |
| |
| void onRcsStatusChanged(IImsConfig binder) { |
| logv("onRcsStatusChanged for sub:" + mSubId + ", IImsConfig?" + binder); |
| if (mIImsConfig != binder) { |
| mIImsConfig = binder; |
| if (mIImsConfig != null) { |
| if (mHasReconfigRequest) { |
| triggerRcsReconfiguration(); |
| } else { |
| notifyRcsAutoConfigurationReceived(); |
| } |
| |
| // check callback for metrics if not registered, register callback |
| registerMetricsCallback(); |
| } else { |
| // clear callbacks if rcs disconnected |
| clearCallbacks(); |
| } |
| } |
| } |
| |
| private void notifyRcsAutoConfigurationReceived() { |
| if (mConfig == null) { |
| logd("Rcs config is null for sub : " + mSubId); |
| return; |
| } |
| |
| if (mIImsConfig != null) { |
| try { |
| logv("notifyRcsAutoConfigurationReceived for sub:" + mSubId); |
| mIImsConfig.notifyRcsAutoConfigurationReceived(mConfig, false); |
| } catch (RemoteException e) { |
| loge("notifyRcsAutoConfigurationReceived failed due to " + e); |
| } |
| } else { |
| logd("notifyRcsAutoConfigurationReceived failed due to IImsConfig null."); |
| } |
| } |
| |
| private void notifyRcsAutoConfigurationRemoved() { |
| if (mIImsConfig != null) { |
| try { |
| logv("notifyRcsAutoConfigurationRemoved for sub:" + mSubId); |
| mIImsConfig.notifyRcsAutoConfigurationRemoved(); |
| } catch (RemoteException e) { |
| loge("notifyRcsAutoConfigurationRemoved failed due to " + e); |
| } |
| } else { |
| logd("notifyRcsAutoConfigurationRemoved failed due to IImsConfig null."); |
| } |
| } |
| |
| private void clearCallbacks() { |
| synchronized (mRcsConfigCallbacks) { |
| Iterator<IRcsConfigCallback> it = mRcsConfigCallbacks.iterator(); |
| while (it.hasNext()) { |
| IRcsConfigCallback cb = it.next(); |
| if (mIImsConfig != null) { |
| try { |
| mIImsConfig.removeRcsConfigCallback(cb); |
| } catch (RemoteException e) { |
| loge("fail to removeRcsConfigCallback due to " + e); |
| } |
| } |
| try { |
| cb.onRemoved(); |
| } catch (RemoteException e) { |
| logd("Failed to notify onRemoved due to dead binder of " + cb); |
| } |
| it.remove(); |
| } |
| } |
| } |
| |
| private void registerMetricsCallback() { |
| RcsProvisioningCallback rcsProvisioningCallback = mRcsStats.getRcsProvisioningCallback( |
| mSubId, mSingleRegistrationCapability == ProvisioningManager.STATUS_CAPABLE); |
| |
| // if not yet registered, register callback and set registered value |
| if (rcsProvisioningCallback != null && !rcsProvisioningCallback.getRegistered()) { |
| if (addRcsConfigCallback(rcsProvisioningCallback)) { |
| rcsProvisioningCallback.setRegistered(true); |
| } |
| } |
| } |
| } |
| |
| @VisibleForTesting |
| public interface FeatureConnectorFactory<U extends FeatureUpdates> { |
| /** |
| * @return a {@link FeatureConnector} associated for the given {@link FeatureUpdates} |
| * and slot index. |
| */ |
| FeatureConnector<U> create(Context context, int slotIndex, |
| FeatureConnector.Listener<U> listener, Executor executor, String logPrefix); |
| } |
| |
| private final class RcsFeatureListener implements FeatureConnector.Listener<RcsFeatureManager> { |
| private final ArraySet<RcsProvisioningInfo> mRcsProvisioningInfos = new ArraySet<>(); |
| private RcsFeatureManager mRcsFeatureManager; |
| private FeatureConnector<RcsFeatureManager> mConnector; |
| |
| RcsFeatureListener(int slotId) { |
| mConnector = mFeatureFactory.create( |
| mPhone, slotId, this, new HandlerExecutor(mHandler), TAG); |
| mConnector.connect(); |
| } |
| |
| void destroy() { |
| mConnector.disconnect(); |
| mConnector = null; |
| mRcsFeatureManager = null; |
| mRcsProvisioningInfos.clear(); |
| } |
| |
| void addRcsProvisioningInfo(RcsProvisioningInfo info) { |
| if (!mRcsProvisioningInfos.contains(info)) { |
| mRcsProvisioningInfos.add(info); |
| info.onRcsStatusChanged(mRcsFeatureManager == null ? null |
| : mRcsFeatureManager.getConfig()); |
| } |
| } |
| |
| void removeRcsProvisioningInfo(RcsProvisioningInfo info) { |
| mRcsProvisioningInfos.remove(info); |
| } |
| |
| @Override |
| public void connectionReady(RcsFeatureManager manager, int subId) { |
| mRcsFeatureManager = manager; |
| mRcsProvisioningInfos.forEach(v -> v.onRcsStatusChanged(manager.getConfig())); |
| } |
| |
| @Override |
| public void connectionUnavailable(int reason) { |
| mRcsFeatureManager = null; |
| mRcsProvisioningInfos.forEach(v -> v.onRcsStatusChanged(null)); |
| } |
| } |
| |
| @VisibleForTesting |
| public RcsProvisioningMonitor(PhoneGlobals app, Looper looper, RoleManagerAdapter roleManager, |
| FeatureConnectorFactory<RcsFeatureManager> factory, RcsStats rcsStats) { |
| mPhone = app; |
| mHandler = new MyHandler(looper); |
| mCarrierConfigManager = mPhone.getSystemService(CarrierConfigManager.class); |
| mSubscriptionManager = mPhone.getSystemService(SubscriptionManager.class); |
| mTelephonyRegistryManager = mPhone.getSystemService(TelephonyRegistryManager.class); |
| mRoleManager = roleManager; |
| mDmaPackageName = getDmaPackageName(); |
| logv("DMA is " + mDmaPackageName); |
| mDmaChangedListener = new DmaChangedListener(); |
| mFeatureFactory = factory; |
| mRcsStats = rcsStats; |
| init(); |
| } |
| |
| /** |
| * create an instance |
| */ |
| public static RcsProvisioningMonitor make(PhoneGlobals app) { |
| if (sInstance == null) { |
| logd("RcsProvisioningMonitor created."); |
| HandlerThread handlerThread = new HandlerThread(TAG); |
| handlerThread.start(); |
| sInstance = new RcsProvisioningMonitor(app, handlerThread.getLooper(), |
| new RoleManagerAdapterImpl(app), RcsFeatureManager::getConnector, |
| RcsStats.getInstance()); |
| } |
| return sInstance; |
| } |
| |
| /** |
| * get the instance |
| */ |
| public static RcsProvisioningMonitor getInstance() { |
| return sInstance; |
| } |
| |
| private void init() { |
| logd("init."); |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED); |
| mPhone.registerReceiver(mReceiver, filter); |
| mTelephonyRegistryManager.addOnSubscriptionsChangedListener( |
| mSubChangedListener, mSubChangedListener.getHandlerExecutor()); |
| mDmaChangedListener.register(); |
| //initialize configs for all active sub |
| onSubChanged(); |
| } |
| |
| private void release() { |
| logd("release."); |
| mDmaChangedListener.unregister(); |
| mTelephonyRegistryManager.removeOnSubscriptionsChangedListener(mSubChangedListener); |
| mPhone.unregisterReceiver(mReceiver); |
| for (int i = 0; i < mRcsFeatureListeners.size(); i++) { |
| mRcsFeatureListeners.valueAt(i).destroy(); |
| } |
| mRcsFeatureListeners.clear(); |
| mRcsProvisioningInfos.forEach((k, v)->v.destroy()); |
| mRcsProvisioningInfos.clear(); |
| mCarrierSingleRegistrationEnabledOverride.clear(); |
| } |
| |
| private void reset() { |
| release(); |
| init(); |
| } |
| |
| /** |
| * destroy the instance |
| */ |
| @VisibleForTesting |
| public void destroy() { |
| logd("destroy it."); |
| release(); |
| mHandler.getLooper().quit(); |
| } |
| |
| /** |
| * get the handler |
| */ |
| @VisibleForTesting |
| public Handler getHandler() { |
| return mHandler; |
| } |
| |
| /** |
| * Gets the config for a subscription |
| */ |
| @VisibleForTesting |
| public byte[] getConfig(int subId) { |
| if (mRcsProvisioningInfos.containsKey(subId)) { |
| return mRcsProvisioningInfos.get(subId).getConfig(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns whether Rcs Volte single registration is enabled for the sub. |
| */ |
| public Boolean isRcsVolteSingleRegistrationEnabled(int subId) { |
| if (mRcsProvisioningInfos.containsKey(subId)) { |
| return mRcsProvisioningInfos.get(subId).getSingleRegistrationCapability() |
| == ProvisioningManager.STATUS_CAPABLE; |
| } |
| return null; |
| } |
| |
| /** |
| * Called when the new rcs config is received |
| */ |
| public void updateConfig(int subId, byte[] config, boolean isCompressed) { |
| mHandler.sendMessage(mHandler.obtainMessage( |
| EVENT_CONFIG_RECEIVED, subId, isCompressed ? 1 : 0, config)); |
| } |
| |
| /** |
| * Called when the application needs rcs re-config |
| */ |
| public void requestReconfig(int subId) { |
| mHandler.sendMessage(mHandler.obtainMessage(EVENT_RECONFIG_REQUEST, subId, 0)); |
| } |
| |
| /** |
| * Called when the application registers rcs provisioning callback |
| */ |
| public boolean registerRcsProvisioningCallback(int subId, IRcsConfigCallback cb) { |
| RcsProvisioningInfo info = mRcsProvisioningInfos.get(subId); |
| // should not happen in normal case |
| if (info == null) { |
| logd("fail to register rcs provisioning callback due to subscription unavailable"); |
| return false; |
| } |
| |
| return info.addRcsConfigCallback(cb); |
| } |
| |
| /** |
| * Called when the application unregisters rcs provisioning callback |
| */ |
| public boolean unregisterRcsProvisioningCallback(int subId, IRcsConfigCallback cb) { |
| RcsProvisioningInfo info = mRcsProvisioningInfos.get(subId); |
| // should not happen in normal case |
| if (info == null) { |
| logd("fail to unregister rcs provisioning changed due to subscription unavailable"); |
| return false; |
| } |
| |
| return info.removeRcsConfigCallback(cb); |
| } |
| |
| /** |
| * Enables or disables test mode. |
| * |
| * <p> If test mode is enabled, any rcs config change will not update the database. |
| */ |
| public void setTestModeEnabled(boolean enabled) { |
| logv("setTestModeEnabled as " + enabled); |
| if (mTestModeEnabled != enabled) { |
| mTestModeEnabled = enabled; |
| mHandler.sendMessage(mHandler.obtainMessage(EVENT_RESET)); |
| } |
| } |
| |
| |
| /** |
| * Returns whether the test mode is enabled. |
| */ |
| public boolean getTestModeEnabled() { |
| return mTestModeEnabled; |
| } |
| |
| /** |
| * override the device config whether single registration is enabled |
| */ |
| public void overrideDeviceSingleRegistrationEnabled(Boolean enabled) { |
| mHandler.sendMessage(mHandler.obtainMessage(EVENT_DEVICE_CONFIG_OVERRIDE, enabled)); |
| } |
| |
| /** |
| * Overrides the carrier config whether single registration is enabled |
| */ |
| public boolean overrideCarrierSingleRegistrationEnabled(int subId, Boolean enabled) { |
| if (!mRcsProvisioningInfos.containsKey(subId)) { |
| return false; |
| } |
| mHandler.sendMessage(mHandler.obtainMessage( |
| EVENT_CARRIER_CONFIG_OVERRIDE, subId, 0, enabled)); |
| return true; |
| } |
| |
| /** |
| * override the rcs feature validation result for a subscription |
| */ |
| public boolean overrideImsFeatureValidation(int subId, Boolean enabled) { |
| if (enabled == null) { |
| mImsFeatureValidationOverride.remove(subId); |
| } else { |
| mImsFeatureValidationOverride.put(subId, enabled); |
| } |
| return true; |
| } |
| |
| /** |
| * Returns the device config whether single registration is enabled |
| */ |
| public boolean getDeviceSingleRegistrationEnabled() { |
| for (RcsProvisioningInfo info : mRcsProvisioningInfos.values()) { |
| return (info.getSingleRegistrationCapability() |
| & ProvisioningManager.STATUS_DEVICE_NOT_CAPABLE) == 0; |
| } |
| return false; |
| } |
| |
| /** |
| * Returns the carrier config whether single registration is enabled |
| */ |
| public boolean getCarrierSingleRegistrationEnabled(int subId) { |
| if (mRcsProvisioningInfos.containsKey(subId)) { |
| return (mRcsProvisioningInfos.get(subId).getSingleRegistrationCapability() |
| & ProvisioningManager.STATUS_CARRIER_NOT_CAPABLE) == 0; |
| } |
| return false; |
| } |
| |
| /** |
| * Returns the rcs feature validation override value, null if it is not set. |
| */ |
| public Boolean getImsFeatureValidationOverride(int subId) { |
| return mImsFeatureValidationOverride.get(subId); |
| } |
| |
| private void onDefaultMessagingApplicationChanged() { |
| final String packageName = getDmaPackageName(); |
| if (!TextUtils.equals(mDmaPackageName, packageName)) { |
| mDmaPackageName = packageName; |
| logv("new default messaging application " + mDmaPackageName); |
| |
| mRcsProvisioningInfos.forEach((k, v) -> { |
| v.notifyDma(); |
| |
| byte[] cachedConfig = v.getConfig(); |
| //clear old callbacks |
| v.clear(); |
| if (isAcsUsed(k)) { |
| logv("acs used, trigger to re-configure."); |
| updateConfigForSub(k, null, true); |
| v.triggerRcsReconfiguration(); |
| } else { |
| logv("acs not used, set cached config and notify."); |
| v.setConfig(cachedConfig); |
| } |
| |
| // store RCS metrics - DMA changed event |
| mRcsStats.onRcsClientProvisioningStats(k, |
| RCS_CLIENT_PROVISIONING_STATS__EVENT__DMA_CHANGED); |
| }); |
| } |
| } |
| |
| private void updateConfigForSub(int subId, byte[] config, boolean isCompressed) { |
| logv("updateConfigForSub, subId:" + subId + ", mTestModeEnabled:" + mTestModeEnabled); |
| if (!mTestModeEnabled) { |
| RcsConfig.updateConfigForSub(mPhone, subId, config, isCompressed); |
| } |
| } |
| |
| private byte[] loadConfigForSub(int subId) { |
| logv("loadConfigForSub, subId:" + subId + ", mTestModeEnabled:" + mTestModeEnabled); |
| if (!mTestModeEnabled) { |
| return RcsConfig.loadRcsConfigForSub(mPhone, subId, false); |
| } |
| return null; |
| } |
| |
| private boolean isAcsUsed(int subId) { |
| PersistableBundle b = mCarrierConfigManager.getConfigForSubId(subId); |
| if (b == null) { |
| return false; |
| } |
| return b.getBoolean(CarrierConfigManager.KEY_USE_ACS_FOR_RCS_BOOL); |
| } |
| |
| private int getSingleRegistrationRequiredByCarrier(int subId) { |
| Boolean enabledByOverride = mCarrierSingleRegistrationEnabledOverride.get(subId); |
| if (enabledByOverride != null) { |
| return enabledByOverride ? ProvisioningManager.STATUS_CAPABLE |
| : ProvisioningManager.STATUS_CARRIER_NOT_CAPABLE; |
| } |
| |
| PersistableBundle b = mCarrierConfigManager.getConfigForSubId(subId); |
| if (!CarrierConfigManager.isConfigForIdentifiedCarrier(b)) { |
| return MASK_CAP_CARRIER_INIT; |
| } |
| return b.getBoolean(CarrierConfigManager.Ims.KEY_IMS_SINGLE_REGISTRATION_REQUIRED_BOOL) |
| ? ProvisioningManager.STATUS_CAPABLE |
| : ProvisioningManager.STATUS_CARRIER_NOT_CAPABLE; |
| } |
| |
| private int getSingleRegistrationCapableValue(int subId) { |
| boolean isSingleRegistrationEnabledOnDevice = |
| mDeviceSingleRegistrationEnabledOverride != null |
| ? mDeviceSingleRegistrationEnabledOverride |
| : mPhone.getPackageManager().hasSystemFeature( |
| PackageManager.FEATURE_TELEPHONY_IMS_SINGLE_REGISTRATION); |
| |
| int value = (isSingleRegistrationEnabledOnDevice ? ProvisioningManager.STATUS_CAPABLE |
| : ProvisioningManager.STATUS_DEVICE_NOT_CAPABLE) |
| | getSingleRegistrationRequiredByCarrier(subId); |
| logv("SingleRegistrationCapableValue : " + value); |
| return value; |
| } |
| |
| private void onCarrierConfigChange() { |
| logv("onCarrierConfigChange"); |
| mRcsProvisioningInfos.forEach((subId, info) -> { |
| info.setSingleRegistrationCapability( |
| getSingleRegistrationCapableValue(subId)); |
| }); |
| } |
| |
| private void onSubChanged() { |
| final int[] activeSubs = mSubscriptionManager.getActiveSubscriptionIdList(); |
| final ArraySet<Integer> subsToBeDeactivated = |
| new ArraySet<>(mRcsProvisioningInfos.keySet()); |
| |
| for (int i : activeSubs) { |
| subsToBeDeactivated.remove(i); |
| if (!mRcsProvisioningInfos.containsKey(i)) { |
| byte[] data = loadConfigForSub(i); |
| int capability = getSingleRegistrationCapableValue(i); |
| logv("new info is created for sub : " + i + ", single registration capability :" |
| + capability + ", rcs config : " + Arrays.toString(data)); |
| mRcsProvisioningInfos.put(i, new RcsProvisioningInfo(i, capability, data)); |
| } |
| } |
| |
| subsToBeDeactivated.forEach(i -> { |
| RcsProvisioningInfo info = mRcsProvisioningInfos.remove(i); |
| if (info != null) { |
| info.destroy(); |
| } |
| }); |
| } |
| |
| private void onConfigReceived(int subId, byte[] config, boolean isCompressed) { |
| logv("onConfigReceived, subId:" + subId + ", config:" |
| + Arrays.toString(config) + ", isCompressed:" + isCompressed); |
| RcsProvisioningInfo info = mRcsProvisioningInfos.get(subId); |
| if (info == null) { |
| logd("sub[" + subId + "] has been removed"); |
| return; |
| } |
| info.setConfig(isCompressed ? RcsConfig.decompressGzip(config) : config); |
| updateConfigForSub(subId, config, isCompressed); |
| |
| // Supporting ACS means config data comes from ACS |
| // store RCS metrics - received provisioning event |
| if (isAcsUsed(subId)) { |
| mRcsStats.onRcsAcsProvisioningStats(subId, 200, |
| RCS_ACS_PROVISIONING_STATS__RESPONSE_TYPE__PROVISIONING_XML, |
| isRcsVolteSingleRegistrationEnabled(subId)); |
| } |
| } |
| |
| private void onReconfigRequest(int subId) { |
| logv("onReconfigRequest, subId:" + subId); |
| RcsProvisioningInfo info = mRcsProvisioningInfos.get(subId); |
| if (info != null) { |
| info.setConfig(null); |
| // clear rcs config stored in db |
| updateConfigForSub(subId, null, true); |
| info.triggerRcsReconfiguration(); |
| } |
| |
| // store RCS metrics - reconfig event |
| mRcsStats.onRcsClientProvisioningStats(subId, |
| RCS_CLIENT_PROVISIONING_STATS__EVENT__TRIGGER_RCS_RECONFIGURATION); |
| } |
| |
| private void notifyDmaForSub(int subId, int capability) { |
| final Intent intent = new Intent( |
| ProvisioningManager.ACTION_RCS_SINGLE_REGISTRATION_CAPABILITY_UPDATE); |
| intent.setPackage(mDmaPackageName); |
| intent.putExtra(ProvisioningManager.EXTRA_SUBSCRIPTION_ID, subId); |
| intent.putExtra(ProvisioningManager.EXTRA_STATUS, capability); |
| logv("notify " + intent + ", sub:" + subId + ", capability:" + capability); |
| // Only send permission to the default sms app if it has the correct permissions |
| // except test mode enabled |
| if (!mTestModeEnabled) { |
| mPhone.sendBroadcast(intent, Manifest.permission.PERFORM_IMS_SINGLE_REGISTRATION); |
| } else { |
| mPhone.sendBroadcast(intent); |
| } |
| } |
| |
| private String getDmaPackageName() { |
| try { |
| return CollectionUtils.firstOrNull(mRoleManager.getRoleHolders(RoleManager.ROLE_SMS)); |
| } catch (RuntimeException e) { |
| loge("Could not get dma name due to " + e); |
| return null; |
| } |
| } |
| |
| void registerRcsFeatureListener(RcsProvisioningInfo info) { |
| int slotId = SubscriptionManager.getSlotIndex(info.getSubId()); |
| RcsFeatureListener cb = mRcsFeatureListeners.get(slotId); |
| if (cb == null) { |
| cb = new RcsFeatureListener(slotId); |
| mRcsFeatureListeners.put(slotId, cb); |
| } |
| cb.addRcsProvisioningInfo(info); |
| } |
| |
| void unregisterRcsFeatureListener(RcsProvisioningInfo info) { |
| // make sure the info to be removed in any case, even the slotId changed or invalid. |
| for (int i = 0; i < mRcsFeatureListeners.size(); i++) { |
| mRcsFeatureListeners.valueAt(i).removeRcsProvisioningInfo(info); |
| } |
| } |
| |
| private static boolean booleanEquals(Boolean val1, Boolean val2) { |
| return (val1 == null && val2 == null) |
| || (Boolean.TRUE.equals(val1) && Boolean.TRUE.equals(val2)) |
| || (Boolean.FALSE.equals(val1) && Boolean.FALSE.equals(val2)); |
| } |
| |
| private static void logv(String msg) { |
| if (DBG) { |
| Rlog.d(TAG, msg); |
| } |
| } |
| |
| private static void logi(String msg) { |
| Rlog.i(TAG, msg); |
| } |
| |
| private static void logd(String msg) { |
| Rlog.d(TAG, msg); |
| } |
| |
| private static void loge(String msg) { |
| Rlog.e(TAG, msg); |
| } |
| |
| /** |
| * {@link RoleManager} is final so we have to wrap the implementation for testing. |
| */ |
| @VisibleForTesting |
| public interface RoleManagerAdapter { |
| /** See {@link RoleManager#getRoleHolders(String)} */ |
| List<String> getRoleHolders(String roleName); |
| /** See {@link RoleManager#addOnRoleHoldersChangedListenerAsUser} */ |
| void addOnRoleHoldersChangedListenerAsUser(Executor executor, |
| OnRoleHoldersChangedListener listener, UserHandle user); |
| /** See {@link RoleManager#removeOnRoleHoldersChangedListenerAsUser} */ |
| void removeOnRoleHoldersChangedListenerAsUser(OnRoleHoldersChangedListener listener, |
| UserHandle user); |
| } |
| |
| private static class RoleManagerAdapterImpl implements RoleManagerAdapter { |
| private final RoleManager mRoleManager; |
| |
| private RoleManagerAdapterImpl(Context context) { |
| mRoleManager = context.getSystemService(RoleManager.class); |
| } |
| |
| @Override |
| public List<String> getRoleHolders(String roleName) { |
| return mRoleManager.getRoleHolders(roleName); |
| } |
| |
| @Override |
| public void addOnRoleHoldersChangedListenerAsUser(Executor executor, |
| OnRoleHoldersChangedListener listener, UserHandle user) { |
| mRoleManager.addOnRoleHoldersChangedListenerAsUser(executor, listener, user); |
| } |
| |
| @Override |
| public void removeOnRoleHoldersChangedListenerAsUser(OnRoleHoldersChangedListener listener, |
| UserHandle user) { |
| mRoleManager.removeOnRoleHoldersChangedListenerAsUser(listener, user); |
| } |
| } |
| } |
