diff options
author | Joao Figueiredo <joaormf@gmail.com> | 2015-08-06 23:59:02 +0100 |
---|---|---|
committer | João Figueiredo <joaormf@gmail.com> | 2015-08-06 18:56:12 -0700 |
commit | 7f50335f2b23abc759613a3dd10c19e5e6b77cf2 (patch) | |
tree | c2ff39b48a4e2279f58b86fc95945bbe067c302d /cm/lib/main | |
parent | 7820e6d56604a196cb629c20d76ff08c12a1d3e6 (diff) | |
download | vendor_cmsdk-7f50335f2b23abc759613a3dd10c19e5e6b77cf2.zip vendor_cmsdk-7f50335f2b23abc759613a3dd10c19e5e6b77cf2.tar.gz vendor_cmsdk-7f50335f2b23abc759613a3dd10c19e5e6b77cf2.tar.bz2 |
cmsdk: Dual SIM support on CM SDK
Signed-off-by: Adnan Begovic <adnan@cyngn.com>
Change-Id: I69b349853b0259582956744d9ddd99a187c10fff
Diffstat (limited to 'cm/lib/main')
-rw-r--r-- | cm/lib/main/java/org/cyanogenmod/platform/internal/CMTelephonyManagerService.java | 340 |
1 files changed, 340 insertions, 0 deletions
diff --git a/cm/lib/main/java/org/cyanogenmod/platform/internal/CMTelephonyManagerService.java b/cm/lib/main/java/org/cyanogenmod/platform/internal/CMTelephonyManagerService.java new file mode 100644 index 0000000..25ca556 --- /dev/null +++ b/cm/lib/main/java/org/cyanogenmod/platform/internal/CMTelephonyManagerService.java @@ -0,0 +1,340 @@ +/** + * Copyright (c) 2015, The CyanogenMod 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 org.cyanogenmod.platform.internal; + +import com.android.server.SystemService; + +import android.content.Context; +import android.os.IBinder; +import android.telephony.SubscriptionInfo; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import android.util.Log; + +import java.util.List; + +import cyanogenmod.app.CMContextConstants; +import cyanogenmod.app.CMTelephonyManager; +import cyanogenmod.app.ICMTelephonyManager; + +/** + * Internal service which manages interactions with the phone and data connection + * + * @hide + */ +public class CMTelephonyManagerService extends SystemService { + private static final String TAG = "CMTelephonyManagerSrv"; + private static boolean localLOGD = Log.isLoggable(TAG, Log.DEBUG); + + private TelephonyManager mTelephonyManager; + private final IBinder mService = new ICMTelephonyManager.Stub() { + + /** + * Returns the available SIM subscription information. + * + * @return The list of SIM subscriptions. The returning list can be null or empty. + * @hide + */ + @Override + public List<SubscriptionInfo> getSubInformation() { + enforceTelephonyReadPermission(); + return getActiveSubscriptionInfoList(); + } + + /** + * Returns the state of the SIM by subscription ID. + * + * If the subscription ID is not valid the method will return {@code false}. + * + * @param subId The subscription ID to query. + * @return {@code true} if the SIM is activated (even without signal or requesting the + * PIN/PUK), {@code false} otherwise. + * @hide + */ + @Override + public boolean isSubActive(int subId) { + enforceTelephonyReadPermission(); + return CMTelephonyManagerService.this.isSubActive(subId); + } + + /** + * Sets the state of one of the SIMs by subscription ID. + * + * If the subscription ID is not valid or the SIM already + * is in the desired state the method will do nothing. + * + * @param subId The subscription ID to set. + * @param state {@code true} to activate the SIM, {@code false} to disable. + * @hide + */ + @Override + public void setSubState(int subId, boolean state) { + enforceTelephonyModifyPermission(); + CMTelephonyManagerService.this.setSubState(subId, state); + } + + /** + * Checks if the received subscription received has the data + * connection enabled. + * + * This method will return {@code true} (or {@code false} if inactive on the SIM) + * even when an internet connection is active through Wifi/BT. + * + * If the subscription ID is not valid the method will return {@code false}. + * + * @param subId The subscription ID to query. + * @return {@code true} if the data connection is enabled on the SIM, {@code false} otherwise. + * @hide + */ + public boolean isDataConnectionSelectedOnSub(int subId) { + enforceTelephonyReadPermission(); + return CMTelephonyManagerService.this.isDataConnectionSelectedOnSub(subId); + } + + /** + * Checks if the network data connection is enabled. + * + * This method will return {@code true} (or {@code false} if inactive) + * even when an internet connection is active through Wifi/BT. + * + * @return {@code true} if the network data connection is enabled, {@code false} otherwise. + * @hide + */ + public boolean isDataConnectionEnabled() { + enforceTelephonyReadPermission(); + return CMTelephonyManagerService.this.isDataConnectionEnabled(); + } + + /** + * Sets the network data conection active or inactive. + * + * @param state If {@code true} enables the network data connection, if {@code false} disables it. + * @hide + */ + public void setDataConnectionState(boolean state) { + enforceTelephonyModifyPermission(); + CMTelephonyManagerService.this.setDataConnectionState(state); + } + + /** + * Sets the data connection state on one of the SIMs by subscription ID. + * + * If the subscription ID is not valid or the data connection is already + * enabled on the SIM the method will do nothing. + * + * @param subId The subscription ID to set the network data connection. + * @hide + */ + public void setDataConnectionSelectedOnSub(int subId) { + enforceTelephonyModifyPermission(); + CMTelephonyManagerService.this.setDataConnectionSelectedOnSub(subId); + } + + /** + * Sets the default phone used to make phone calls as the one received on subId. + * + * If 0 is used as a parameter, then the option to choose what SIM to use is + * selected. + * + * @param subId The subscription to set as default for phone calls. + * To select SIM when calling use 0. + * @hide + */ + public void setDefaultPhoneSub(int subId) { + enforceTelephonyModifyPermission(); + CMTelephonyManagerService.this.setDefaultPhoneSub(subId); + } + + /** + * Sets the default phone used to send SMS as the one received on subId. + * + * If 0 is used as a parameter, then the option to choose what SIM to use is + * selected. + * + * @param subId The subscription to set as default for sending SMS. + * To select SIM when sending SMS use 0. + * @hide + */ + public void setDefaultSmsSub(int subId) { + enforceTelephonyModifyPermission(); + CMTelephonyManagerService.this.setDefaultSmsSub(subId); + } + }; + + public CMTelephonyManagerService(Context context) { + super(context); + } + + @Override + public void onStart() { + if (localLOGD) { + Log.d(TAG, "CM telephony manager service start: " + this); + } + publishBinderService(CMContextConstants.CM_TELEPHONY_MANAGER_SERVICE, mService); + + mTelephonyManager = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); + } + + private List<SubscriptionInfo> getActiveSubscriptionInfoList() { + SubscriptionManager subscriptionManager = SubscriptionManager.from(mContext); + List<SubscriptionInfo> subInfoList = subscriptionManager.getActiveSubscriptionInfoList(); + if (localLOGD) { + Log.d(TAG, "The active subscriptions where obtained from the subscription manager."); + } + return subInfoList; + } + + private boolean isSubActive(int subId) { + boolean validSubscriptionId = SubscriptionManager.isValidSubscriptionId(subId); + + if (validSubscriptionId) { + int simState = SubscriptionManager.getSimStateForSubscriber(subId); + switch (simState) { + case TelephonyManager.SIM_STATE_ABSENT: + case TelephonyManager.SIM_STATE_CARD_IO_ERROR: + case TelephonyManager.SIM_STATE_PERM_DISABLED: + case TelephonyManager.SIM_STATE_NOT_READY: + if (localLOGD) { + Log.d(TAG, "The subscription " + subId + " is NOT active: " + simState); + } + return false; + default: + if (localLOGD) { + Log.d(TAG, "The subscription " + subId + " is active: " + simState); + } + return true; + } + } else { + Log.w(TAG, "Invalid subscription identifier: " + subId); + return false; + } + } + + private void setSubState(int subId, boolean state) { + if (localLOGD) { + Log.d(TAG, "Setting the subscription " + subId + " to inactive (false) or active (true): " + state); + } + + if (state) { + SubscriptionManager.activateSubId(subId); + } else { + SubscriptionManager.deactivateSubId(subId); + } + } + + private boolean isDataConnectionSelectedOnSub(int subId) { + boolean validSubscriptionId = SubscriptionManager.isValidSubscriptionId(subId); + + if (validSubscriptionId) { + if (subId == SubscriptionManager.getDefaultDataSubId()) { + if (localLOGD) { + Log.d(TAG, "Data connection selected for subscription " + subId); + } + return true; + } else { + if (localLOGD) { + Log.d(TAG, "Data connection not selected for subscription " + subId); + } + return false; + } + } else { + Log.w(TAG, "Invalid subscription identifier: " + subId); + return false; + } + } + + private boolean isDataConnectionEnabled() { + if (localLOGD) { + Log.d(TAG, "Checking if the network data connection is active"); + } + + boolean dataEnabled = mTelephonyManager.getDataEnabled(); + + if (localLOGD) { + Log.d(TAG, "Data network connection is inactive (false) or active (true): " + dataEnabled); + } + + return dataEnabled; + } + + private void setDataConnectionState(boolean state) { + if (localLOGD) { + Log.d(TAG, "Setting the network data connection inactive (false) or active (true): " + state); + } + + if (state) { + mTelephonyManager.enableDataConnectivity(); + } else { + mTelephonyManager.disableDataConnectivity(); + } + } + + private void setDataConnectionSelectedOnSub(int subId) { + if (localLOGD) { + Log.d(TAG, "Setting the network data connection for subscription " + subId); + } + + SubscriptionManager subscriptionManager = SubscriptionManager.from(mContext); + subscriptionManager.setDefaultDataSubId(subId); + } + + private void setDefaultPhoneSub(int subId) { + if (localLOGD) { + Log.d(TAG, "Setting the SIM for phone calls on subscription " + subId); + } + + SubscriptionManager subscriptionManager = SubscriptionManager.from(mContext); + if (subId == CMTelephonyManager.ASK_FOR_SUBSCRIPTION_ID) { + if (localLOGD) { + Log.d(TAG, "Activates the prompt for phone calls"); + } + SubscriptionManager.setVoicePromptEnabled(true); + } else { + SubscriptionManager.setVoicePromptEnabled(false); + subscriptionManager.setDefaultVoiceSubId(subId); + } + } + + private void setDefaultSmsSub(int subId) { + if (localLOGD) { + Log.d(TAG, "Setting the SIM for phone calls on subscription " + subId); + } + + SubscriptionManager subscriptionManager = SubscriptionManager.from(mContext); + if (subId == CMTelephonyManager.ASK_FOR_SUBSCRIPTION_ID) { + if (localLOGD) { + Log.d(TAG, "Activates the prompt for SMS"); + } + SubscriptionManager.setSMSPromptEnabled(true); + } else { + SubscriptionManager.setSMSPromptEnabled(false); + subscriptionManager.setDefaultSmsSubId(subId); + } + } + + private void enforceTelephonyReadPermission() { + mContext.enforceCallingOrSelfPermission( + cyanogenmod.platform.Manifest.permission.READ_MSIM_PHONE_STATE, + "CMTelephonyManagerService"); + } + + private void enforceTelephonyModifyPermission() { + mContext.enforceCallingOrSelfPermission( + cyanogenmod.platform.Manifest.permission.MODIFY_MSIM_PHONE_STATE, + "CMTelephonyManagerService"); + } +} |