| /* |
| * Copyright (C) 2014 Google Inc. |
| * |
| * 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.googlecode.android_scripting.facade.tele; |
| |
| import android.app.Service; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.database.Cursor; |
| import android.net.Uri; |
| import android.os.RemoteException; |
| import android.provider.ContactsContract; |
| import android.telephony.CellLocation; |
| import android.telephony.NeighboringCellInfo; |
| import android.telephony.PhoneStateListener; |
| import android.telephony.TelephonyManager; |
| import android.provider.Telephony; |
| |
| import com.android.internal.telephony.ITelephony; |
| import com.android.internal.telephony.RILConstants; |
| import com.android.internal.telephony.TelephonyProperties; |
| |
| import android.content.ContentValues; |
| import android.os.SystemProperties; |
| |
| import com.googlecode.android_scripting.facade.AndroidFacade; |
| import com.googlecode.android_scripting.facade.EventFacade; |
| import com.googlecode.android_scripting.facade.FacadeManager; |
| import com.googlecode.android_scripting.facade.tele.TelephonyStateListeners |
| .CallStateChangeListener; |
| import com.googlecode.android_scripting.facade.tele.TelephonyStateListeners |
| .DataConnectionChangeListener; |
| import com.googlecode.android_scripting.facade.tele.TelephonyStateListeners |
| .DataConnectionStateChangeListener; |
| import com.googlecode.android_scripting.facade.tele.TelephonyStateListeners |
| .ServiceStateChangeListener; |
| import com.googlecode.android_scripting.jsonrpc.RpcReceiver; |
| import com.googlecode.android_scripting.rpc.Rpc; |
| import com.googlecode.android_scripting.rpc.RpcDefault; |
| import com.googlecode.android_scripting.rpc.RpcParameter; |
| import com.googlecode.android_scripting.Log; |
| import com.googlecode.android_scripting.MainThread; |
| import com.googlecode.android_scripting.rpc.RpcOptional; |
| |
| import java.io.UnsupportedEncodingException; |
| import java.lang.reflect.Field; |
| import java.net.URLEncoder; |
| import java.util.List; |
| import java.util.concurrent.Callable; |
| |
| /** |
| * Exposes TelephonyManager functionality. |
| * |
| * @author Damon Kohler (damonkohler@gmail.com) |
| * @author Felix Arends (felix.arends@gmail.com) |
| */ |
| public class PhoneFacade extends RpcReceiver { |
| |
| private final Service mService; |
| private final AndroidFacade mAndroidFacade; |
| private final EventFacade mEventFacade; |
| private final TelephonyManager mTelephonyManager; |
| |
| private CallStateChangeListener mCallStateChangeListener; |
| private DataConnectionChangeListener mDataConnectionChangeListener; |
| private DataConnectionStateChangeListener mDataConnectionStateChangeListener; |
| private ServiceStateChangeListener mServiceStateChangeListener; |
| |
| private ITelephony mITelephony; |
| private PhoneStateListener mPhoneStateListener; |
| |
| private static final String[] sProjection = new String[] { |
| Telephony.Carriers._ID, // 0 |
| Telephony.Carriers.NAME, // 1 |
| Telephony.Carriers.APN, // 2 |
| Telephony.Carriers.PROXY, // 3 |
| Telephony.Carriers.PORT, // 4 |
| Telephony.Carriers.USER, // 5 |
| Telephony.Carriers.SERVER, // 6 |
| Telephony.Carriers.PASSWORD, // 7 |
| Telephony.Carriers.MMSC, // 8 |
| Telephony.Carriers.MCC, // 9 |
| Telephony.Carriers.MNC, // 10 |
| Telephony.Carriers.NUMERIC, // 11 |
| Telephony.Carriers.MMSPROXY,// 12 |
| Telephony.Carriers.MMSPORT, // 13 |
| Telephony.Carriers.AUTH_TYPE, // 14 |
| Telephony.Carriers.TYPE, // 15 |
| Telephony.Carriers.PROTOCOL, // 16 |
| Telephony.Carriers.CARRIER_ENABLED, // 17 |
| Telephony.Carriers.BEARER, // 18 |
| Telephony.Carriers.ROAMING_PROTOCOL, // 19 |
| Telephony.Carriers.MVNO_TYPE, // 20 |
| Telephony.Carriers.MVNO_MATCH_DATA // 21 |
| }; |
| |
| public PhoneFacade(FacadeManager manager) { |
| super(manager); |
| mService = manager.getService(); |
| mTelephonyManager = |
| (TelephonyManager) mService.getSystemService(Context.TELEPHONY_SERVICE); |
| mAndroidFacade = manager.getReceiver(AndroidFacade.class); |
| mEventFacade = manager.getReceiver(EventFacade.class); |
| MainThread.run(manager.getService(), new Callable<Object>() { |
| @Override |
| public Object call() throws Exception { |
| mCallStateChangeListener = new CallStateChangeListener(mEventFacade); |
| mDataConnectionChangeListener = new DataConnectionChangeListener(mEventFacade); |
| mDataConnectionStateChangeListener = new DataConnectionStateChangeListener(mEventFacade, mTelephonyManager); |
| mServiceStateChangeListener = new ServiceStateChangeListener(mEventFacade); |
| return null; |
| } |
| }); |
| } |
| |
| @Rpc(description = "Set preferred network setting.") |
| public boolean phoneSetPreferredNetworkType(String mode){ |
| int networkType; |
| int phoneType = mTelephonyManager.getPhoneType(); |
| if (phoneType == TelephonyManager.PHONE_TYPE_GSM) { |
| if (mode.equalsIgnoreCase("LTE")) { |
| networkType = RILConstants.NETWORK_MODE_LTE_GSM_WCDMA; |
| } else if (mode.equalsIgnoreCase("Global")) { |
| networkType = RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA; |
| } else if (mode.equalsIgnoreCase("3G")) { |
| networkType = RILConstants.NETWORK_MODE_WCDMA_PREF; |
| } else if (mode.equalsIgnoreCase("2G")) { |
| networkType = RILConstants.NETWORK_MODE_GSM_ONLY; |
| } else { |
| return false; |
| } |
| } else if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) { |
| if (mode.equalsIgnoreCase("LTE")) { |
| networkType = RILConstants.NETWORK_MODE_LTE_CDMA_EVDO; |
| } else if (mode.equalsIgnoreCase("Global")) { |
| networkType = RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA; |
| } else if (mode.equalsIgnoreCase("3G")) { |
| networkType = RILConstants.NETWORK_MODE_CDMA; |
| } else if (mode.equalsIgnoreCase("1X")) { |
| networkType = RILConstants.NETWORK_MODE_CDMA_NO_EVDO; |
| } else { |
| return false; |
| } |
| } else{ |
| return false; |
| } |
| Log.v("SL4A: Setting the preferred network setting to:" + networkType); |
| mTelephonyManager.setPreferredNetworkType(networkType); |
| return true; |
| } |
| |
| @Rpc(description = "Get preferred network setting. Return value is integer.") |
| public int phoneGetPreferredNetworkTypeInteger(){ |
| return mTelephonyManager.getPreferredNetworkType(); |
| } |
| |
| @Rpc(description = "Get preferred network setting. Return value is String.") |
| public String phoneGetPreferredNetworkTypeString(){ |
| int mode = mTelephonyManager.getPreferredNetworkType(); |
| int phoneType = mTelephonyManager.getPhoneType(); |
| if (phoneType == TelephonyManager.PHONE_TYPE_GSM) { |
| if (mode == RILConstants.NETWORK_MODE_LTE_GSM_WCDMA){ |
| return "LTE"; |
| } else if (mode == RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA){ |
| return "Global"; |
| } else if (mode == RILConstants.NETWORK_MODE_WCDMA_PREF) { |
| return "3G"; |
| } else if (mode == RILConstants.NETWORK_MODE_GSM_ONLY) { |
| return "2G"; |
| } else { |
| Log.d("Unknown mode in phone type GSM: " + mode); |
| } |
| } else if (phoneType == TelephonyManager.PHONE_TYPE_CDMA){ |
| if (mode == RILConstants.NETWORK_MODE_LTE_CDMA_EVDO){ |
| return "LTE"; |
| } else if (mode == RILConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA){ |
| return "Global"; |
| } else if (mode == RILConstants.NETWORK_MODE_CDMA) { |
| return "3G"; |
| } else if (mode == RILConstants.NETWORK_MODE_CDMA_NO_EVDO) { |
| return "1X"; |
| } else { |
| Log.d("Unknown mode in phone type CDMA: " + mode); |
| } |
| } else { |
| Log.d("Unknown phone type: " + phoneType); |
| } |
| return null; |
| } |
| |
| @Rpc(description = "Starts tracking call state change.") |
| public void phoneStartTrackingCallState() { |
| mTelephonyManager.listen(mCallStateChangeListener, |
| CallStateChangeListener.sListeningStates); |
| } |
| |
| @Rpc(description = "Turn on/off precise listening on fore/background or ringing calls.") |
| public void phoneAdjustPreciseCallStateListenLevel(String type, Boolean listen) { |
| if (type.equals("Foreground")) { |
| mCallStateChangeListener.listenForeground = listen; |
| } else if (type.equals("Ringing")) { |
| mCallStateChangeListener.listenRinging = listen; |
| } else if (type.equals("Background")) { |
| mCallStateChangeListener.listenBackground = listen; |
| } |
| } |
| |
| @Rpc(description = "Stops tracking call state change.") |
| public void phoneStopTrackingCallStateChange() { |
| mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE); |
| } |
| |
| @Rpc(description = "Starts tracking power level change.") |
| public void phoneStartTrackingPowerLevelChange() { |
| mTelephonyManager.listen(mDataConnectionChangeListener, |
| DataConnectionChangeListener.sListeningStates); |
| } |
| |
| @Rpc(description = "Stops tracking power level change.") |
| public void phoneStopTrackingPowerLevelChange() { |
| mTelephonyManager.listen(mDataConnectionChangeListener, PhoneStateListener.LISTEN_NONE); |
| } |
| |
| @Rpc(description = "Starts tracking data connection state change.") |
| public void phoneStartTrackingDataConnectionStateChange() { |
| mTelephonyManager.listen(mDataConnectionStateChangeListener, |
| DataConnectionStateChangeListener.sListeningStates); |
| } |
| |
| @Rpc(description = "Stops tracking data connection state change.") |
| public void phoneStopTrackingDataConnectionStateChange() { |
| mTelephonyManager.listen(mDataConnectionStateChangeListener, PhoneStateListener.LISTEN_NONE); |
| } |
| |
| @Rpc(description = "Starts tracking service state change.") |
| public void phoneStartTrackingServiceStateChange() { |
| mTelephonyManager.listen(mServiceStateChangeListener, |
| ServiceStateChangeListener.sListeningStates); |
| } |
| |
| @Rpc(description = "Stops tracking service state change.") |
| public void phoneStopTrackingServiceStateChange() { |
| mTelephonyManager.listen(mServiceStateChangeListener, PhoneStateListener.LISTEN_NONE); |
| } |
| |
| @Rpc(description = "Calls a contact/phone number by URI.") |
| public void phoneCall(@RpcParameter(name = "uri") |
| final String uriString) |
| throws Exception { |
| Uri uri = Uri.parse(uriString); |
| if (uri.getScheme().equals("content")) { |
| String phoneNumberColumn = ContactsContract.PhoneLookup.NUMBER; |
| String selectWhere = null; |
| if ((FacadeManager.class.cast(mManager)).getSdkLevel() >= 5) { |
| Class<?> contactsContract_Data_class = |
| Class.forName("android.provider.ContactsContract$Data"); |
| Field RAW_CONTACT_ID_field = |
| contactsContract_Data_class.getField("RAW_CONTACT_ID"); |
| selectWhere = RAW_CONTACT_ID_field.get(null).toString() + "=" |
| + uri.getLastPathSegment(); |
| Field CONTENT_URI_field = |
| contactsContract_Data_class.getField("CONTENT_URI"); |
| uri = Uri.parse(CONTENT_URI_field.get(null).toString()); |
| Class<?> ContactsContract_CommonDataKinds_Phone_class = |
| Class.forName("android.provider.ContactsContract$CommonDataKinds$Phone"); |
| Field NUMBER_field = |
| ContactsContract_CommonDataKinds_Phone_class.getField("NUMBER"); |
| phoneNumberColumn = NUMBER_field.get(null).toString(); |
| } |
| ContentResolver resolver = mService.getContentResolver(); |
| Cursor c = resolver.query(uri, new String[] { |
| phoneNumberColumn |
| }, |
| selectWhere, null, null); |
| String number = ""; |
| if (c.moveToFirst()) { |
| number = c.getString(c.getColumnIndexOrThrow(phoneNumberColumn)); |
| } |
| c.close(); |
| phoneCallNumber(number); |
| } else { |
| mAndroidFacade.startActivity(Intent.ACTION_CALL, uriString, null, |
| null, null, null, null); |
| } |
| } |
| |
| @Rpc(description = "Calls a phone number.") |
| public void phoneCallNumber( |
| @RpcParameter(name = "phone number") |
| final String number) |
| throws Exception { |
| phoneCall("tel:" + URLEncoder.encode(number, "ASCII")); |
| } |
| |
| @Rpc(description = "Calls an Emergency number.") |
| public void phoneCallEmergencyNumber( |
| @RpcParameter(name = "phone number") |
| final String number) |
| throws Exception { |
| String uriString = "tel:" + URLEncoder.encode(number, "ASCII"); |
| mAndroidFacade.startActivity(Intent.ACTION_CALL_PRIVILEGED, uriString, null, |
| null, null, null, null); |
| } |
| |
| @Rpc(description = "Dials a contact/phone number by URI.") |
| public void phoneDial(@RpcParameter(name = "uri") |
| final String uri) |
| throws Exception { |
| mAndroidFacade.startActivity(Intent.ACTION_DIAL, uri, null, null, null, |
| null, null); |
| } |
| |
| @Rpc(description = "Answers an incoming ringing call.") |
| public void phoneAnswerCall() throws RemoteException { |
| mITelephony.silenceRinger(); |
| mITelephony.answerRingingCall(); |
| } |
| |
| @Rpc(description = "Dials a phone number.") |
| public void phoneDialNumber(@RpcParameter(name = "phone number") |
| final String number) |
| throws Exception, UnsupportedEncodingException { |
| phoneDial("tel:" + URLEncoder.encode(number, "ASCII")); |
| } |
| |
| @Rpc(description = "Returns the current cell location.") |
| public CellLocation getCellLocation() { |
| return mTelephonyManager.getCellLocation(); |
| } |
| |
| @Rpc(description = "Returns the numeric name (MCC+MNC) of current registered operator.") |
| public String getNetworkOperator() { |
| return mTelephonyManager.getNetworkOperator(); |
| } |
| |
| @Rpc(description = "Returns the alphabetic name of current registered operator.") |
| public String getNetworkOperatorName() { |
| return mTelephonyManager.getNetworkOperatorName(); |
| } |
| |
| private String getNetworkTypeString(int networkType) { |
| |
| switch (networkType) { |
| case TelephonyManager.NETWORK_TYPE_EDGE: |
| return "edge"; |
| case TelephonyManager.NETWORK_TYPE_GPRS: |
| return "gprs"; |
| case TelephonyManager.NETWORK_TYPE_UMTS: |
| return "umts"; |
| case TelephonyManager.NETWORK_TYPE_HSDPA: |
| return "hsdpa"; |
| case TelephonyManager.NETWORK_TYPE_HSUPA: |
| return "hsupa"; |
| case TelephonyManager.NETWORK_TYPE_CDMA: |
| return "cdma"; |
| case TelephonyManager.NETWORK_TYPE_EVDO_0: |
| return "evdo_0"; |
| case TelephonyManager.NETWORK_TYPE_EVDO_A: |
| return "evdo_a"; |
| case TelephonyManager.NETWORK_TYPE_EVDO_B: |
| return "evdo_b"; |
| case TelephonyManager.NETWORK_TYPE_1xRTT: |
| return "1xrtt"; |
| case TelephonyManager.NETWORK_TYPE_IDEN: |
| return "iden"; |
| case TelephonyManager.NETWORK_TYPE_LTE: |
| return "lte"; |
| case TelephonyManager.NETWORK_TYPE_EHRPD: |
| return "ehrpd"; |
| case TelephonyManager.NETWORK_TYPE_HSPA: |
| return "hspa"; |
| case TelephonyManager.NETWORK_TYPE_HSPAP: |
| return "hspap"; |
| case TelephonyManager.NETWORK_TYPE_UNKNOWN: |
| return "unknown"; |
| default: |
| return null; |
| } |
| } |
| |
| @Rpc(description = "Returns the current RAT in use on the device.") |
| public String getNetworkType() { |
| |
| Log.d("sl4a:getNetworkType() is deprecated!" + |
| "Please use getVoiceNetworkType()" + |
| " or getDataNetworkTpe()"); |
| |
| return getNetworkTypeString(mTelephonyManager.getNetworkType()); |
| } |
| |
| @Rpc(description = "Returns the current RAT in use on the device" + |
| " for a given Subscription.") |
| public String getNetworkTypeForSubscriber( |
| @RpcParameter(name = "subId") Integer subId) { |
| |
| Log.d("sl4a:getNetworkTypeForSubscriber() is deprecated!" + |
| "Please use getVoiceNetworkType()" + |
| " or getDataNetworkTpe()"); |
| |
| return getNetworkTypeString(mTelephonyManager.getNetworkType(subId)); |
| } |
| |
| @Rpc(description = "Returns the current voice RAT for" + |
| " the default voice subscription.") |
| public String getVoiceNetworkType() { |
| return getNetworkTypeString(mTelephonyManager.getVoiceNetworkType()); |
| } |
| |
| @Rpc(description = "Returns the current voice RAT for" + |
| " the chosen voice subscription.") |
| public String getVoiceNetworkTypeForSubscriber( |
| @RpcParameter(name = "subId") Integer subId) { |
| return getNetworkTypeString(mTelephonyManager.getVoiceNetworkType(subId)); |
| } |
| |
| @Rpc(description = "Returns the current data RAT for" + |
| " the defaut data subscription") |
| public String getDataNetworkType() { |
| return getNetworkTypeString(mTelephonyManager.getDataNetworkType()); |
| } |
| |
| @Rpc(description = "Returns the current data RAT for" + |
| " the defaut data subscription") |
| public String getDataNetworkTypeForSubscriber( |
| @RpcParameter(name = "subId") Integer subId) { |
| return getNetworkTypeString(mTelephonyManager.getDataNetworkType(subId)); |
| } |
| |
| @Rpc(description = "Returns the device phone type.") |
| public String getPhoneType() { |
| switch (mTelephonyManager.getPhoneType()) { |
| case TelephonyManager.PHONE_TYPE_GSM: |
| return "gsm"; |
| case TelephonyManager.PHONE_TYPE_NONE: |
| return "none"; |
| case TelephonyManager.PHONE_TYPE_CDMA: |
| return "cdma"; |
| case TelephonyManager.PHONE_TYPE_SIP: |
| return "sip"; |
| default: |
| return null; |
| } |
| } |
| |
| @Rpc(description = "Returns the MCC") |
| public String getSimCountryIso() { |
| return mTelephonyManager.getSimCountryIso(); |
| } |
| |
| @Rpc(description = "Returns the MCC+MNC") |
| public String getSimOperator() { |
| return mTelephonyManager.getSimOperator(); |
| } |
| |
| @Rpc(description = "Returns the MCC+MNC by subId") |
| public String getSimOperatorBySubId( |
| @RpcParameter(name = "subId") |
| Integer subId) { |
| return mTelephonyManager.getSimOperator(subId); |
| } |
| |
| @Rpc(description = "Returns the Service Provider Name (SPN).") |
| public String getSimOperatorName() { |
| return mTelephonyManager.getSimOperatorName(); |
| } |
| |
| @Rpc(description = "Returns the serial number of the SIM, or Null if unavailable") |
| public String getSimSerialNumber() { |
| return mTelephonyManager.getSimSerialNumber(); |
| } |
| |
| @Rpc(description = "Returns the serial number of the SIM by SubId, or Null if unavailable") |
| public String getSimSerialNumberBySubId( |
| @RpcParameter(name = "subId") |
| Integer subId) { |
| return mTelephonyManager.getSimSerialNumber(subId); |
| } |
| |
| @Rpc(description = "Returns the state of the device SIM card.") |
| public String getSimState() { |
| switch (mTelephonyManager.getSimState()) { |
| case TelephonyManager.SIM_STATE_UNKNOWN: |
| return "uknown"; |
| case TelephonyManager.SIM_STATE_ABSENT: |
| return "absent"; |
| case TelephonyManager.SIM_STATE_PIN_REQUIRED: |
| return "pin_required"; |
| case TelephonyManager.SIM_STATE_PUK_REQUIRED: |
| return "puk_required"; |
| case TelephonyManager.SIM_STATE_NETWORK_LOCKED: |
| return "network_locked"; |
| case TelephonyManager.SIM_STATE_READY: |
| return "ready"; |
| default: |
| return null; |
| } |
| } |
| |
| @Rpc(description = "Returns the unique subscriber ID (such as IMSI), or null if unavailable") |
| public String getSubscriberId() { |
| return mTelephonyManager.getSubscriberId(); |
| } |
| |
| @Rpc(description = "Retrieves the alphabetic id associated with the voice mail number.") |
| public String getVoiceMailAlphaTag() { |
| return mTelephonyManager.getVoiceMailAlphaTag(); |
| } |
| |
| @Rpc(description = "Returns the voice mail number; null if unavailable.") |
| public String getVoiceMailNumber() { |
| return mTelephonyManager.getVoiceMailNumber(); |
| } |
| |
| @Rpc(description = "Returns true if the device is in a roaming state") |
| public Boolean checkNetworkRoaming() { |
| return mTelephonyManager.isNetworkRoaming(); |
| } |
| |
| @Rpc(description = "Returns true if the device is in a roaming state") |
| public Boolean checkNetworkRoamingBySubId( |
| @RpcParameter(name = "subId") |
| Integer subId){ |
| return mTelephonyManager.isNetworkRoaming(subId); |
| } |
| |
| @Rpc(description = "Returns the unique device ID such as MEID or IMEI, null if unavailable") |
| public String getDeviceId() { |
| return mTelephonyManager.getDeviceId(); |
| } |
| |
| @Rpc(description = "Returns the unique device ID such as MEID or IMEI by slotId, null if unavailable") |
| public String getDeviceIdBySlotId( |
| @RpcParameter(name = "slotId") |
| Integer slotId){ |
| return mTelephonyManager.getDeviceId(slotId); |
| } |
| |
| @Rpc(description = "Returns the modem sw version, such as IMEI-SV; null if unavailable") |
| public String getDeviceSoftwareVersion() { |
| return mTelephonyManager.getDeviceSoftwareVersion(); |
| } |
| |
| @Rpc(description = "Returns phone # string \"line 1\", such as MSISDN; null if unavailable") |
| public String getLine1Number() { |
| return mTelephonyManager.getLine1Number(); |
| } |
| |
| @Rpc(description = "Returns the neighboring cell information of the device.") |
| public List<NeighboringCellInfo> getNeighboringCellInfo() { |
| return mTelephonyManager.getNeighboringCellInfo(); |
| } |
| |
| @Rpc(description = "Returns True if data connection is enabled.") |
| public Boolean checkDataConnection() { |
| return mTelephonyManager.getDataEnabled(); |
| } |
| |
| @Rpc(description = "Toggles data connection on or off.") |
| public void toggleDataConnection( |
| @RpcParameter(name = "enabled") |
| @RpcOptional |
| Boolean enabled) { |
| if (enabled == null) { |
| enabled = !checkDataConnection(); |
| } |
| mTelephonyManager.setDataEnabled(enabled); |
| } |
| |
| @Rpc(description = "Sets an APN and make that as preferred APN.") |
| public void setAPN(@RpcParameter(name = "name") final String name, |
| @RpcParameter(name = "apn") final String apn, |
| @RpcParameter(name = "type") @RpcOptional @RpcDefault("") |
| final String type) { |
| Uri uri; |
| Cursor cursor; |
| |
| String mcc = ""; |
| String mnc = ""; |
| |
| String numeric = SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC); |
| // MCC is first 3 chars and then in 2 - 3 chars of MNC |
| if (numeric != null && numeric.length() > 4) { |
| // Country code |
| mcc = numeric.substring(0, 3); |
| // Network code |
| mnc = numeric.substring(3); |
| } |
| |
| uri = mService.getContentResolver().insert( |
| Telephony.Carriers.CONTENT_URI, new ContentValues()); |
| if (uri == null) { |
| Log.w("Failed to insert new provider into " + Telephony.Carriers.CONTENT_URI); |
| return; |
| } |
| |
| cursor = mService.getContentResolver().query(uri, sProjection, null, null, null); |
| cursor.moveToFirst(); |
| |
| ContentValues values = new ContentValues(); |
| |
| values.put(Telephony.Carriers.NAME, name); |
| values.put(Telephony.Carriers.APN, apn); |
| values.put(Telephony.Carriers.PROXY, ""); |
| values.put(Telephony.Carriers.PORT, ""); |
| values.put(Telephony.Carriers.MMSPROXY, ""); |
| values.put(Telephony.Carriers.MMSPORT, ""); |
| values.put(Telephony.Carriers.USER, ""); |
| values.put(Telephony.Carriers.SERVER, ""); |
| values.put(Telephony.Carriers.PASSWORD, ""); |
| values.put(Telephony.Carriers.MMSC, ""); |
| values.put(Telephony.Carriers.TYPE, type); |
| values.put(Telephony.Carriers.MCC, mcc); |
| values.put(Telephony.Carriers.MNC, mnc); |
| values.put(Telephony.Carriers.NUMERIC, mcc + mnc); |
| |
| int ret = mService.getContentResolver().update(uri, values, null, null); |
| Log.d("after update " + ret); |
| cursor.close(); |
| |
| // Make this APN as the preferred |
| String where = "name=\"" + name + "\""; |
| |
| Cursor c = mService.getContentResolver().query( |
| Telephony.Carriers.CONTENT_URI, |
| new String[] { |
| "_id", "name", "apn", "type" |
| }, where, null, |
| Telephony.Carriers.DEFAULT_SORT_ORDER); |
| if (c != null) { |
| c.moveToFirst(); |
| String key = c.getString(0); |
| final String PREFERRED_APN_URI = "content://telephony/carriers/preferapn"; |
| ContentResolver resolver = mService.getContentResolver(); |
| ContentValues prefAPN = new ContentValues(); |
| prefAPN.put("apn_id", key); |
| resolver.update(Uri.parse(PREFERRED_APN_URI), prefAPN, null, null); |
| } |
| c.close(); |
| } |
| |
| @Rpc(description = "Returns the number of APNs defined") |
| public int getNumberOfAPNs() { |
| int result = 0; |
| String where = "numeric=\"" + android.os.SystemProperties.get( |
| TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC, "") + "\""; |
| |
| Cursor cursor = mService.getContentResolver().query( |
| Telephony.Carriers.CONTENT_URI, |
| new String[] {"_id", "name", "apn", "type"}, where, null, |
| Telephony.Carriers.DEFAULT_SORT_ORDER); |
| |
| if (cursor != null) { |
| result = cursor.getCount(); |
| } |
| cursor.close(); |
| return result; |
| } |
| |
| @Rpc(description = "Returns the currently selected APN name") |
| public String getSelectedAPN() { |
| String key = null; |
| int ID_INDEX = 0; |
| final String PREFERRED_APN_URI = "content://telephony/carriers/preferapn"; |
| |
| Cursor cursor = mService.getContentResolver().query(Uri.parse(PREFERRED_APN_URI), |
| new String[] {"name"}, null, null, Telephony.Carriers.DEFAULT_SORT_ORDER); |
| |
| if (cursor.getCount() > 0) { |
| cursor.moveToFirst(); |
| key = cursor.getString(ID_INDEX); |
| } |
| cursor.close(); |
| return key; |
| } |
| |
| @Rpc(description = "Sets the preferred Network type") |
| public void setPreferredNetwork(Integer networktype) { |
| android.provider.Settings.Global.putInt(mService.getContentResolver(), |
| android.provider.Settings.Global.PREFERRED_NETWORK_MODE, |
| networktype ); |
| mTelephonyManager.setPreferredNetworkType(networktype); |
| } |
| |
| @Rpc(description = "Returns the current data connection state") |
| public String getDataConnectionState() { |
| int state = mTelephonyManager.getDataState(); |
| |
| switch(state) { |
| case TelephonyManager.DATA_DISCONNECTED: |
| return "DATA_DISCONNECTED"; |
| case TelephonyManager.DATA_CONNECTING: |
| return "DATA_CONNECTING"; |
| case TelephonyManager.DATA_CONNECTED: |
| return "DATA_CONNECTED"; |
| case TelephonyManager.DATA_SUSPENDED: |
| return "DATA_SUSPENDED"; |
| default: |
| return "DATA_UNKNOWN"; |
| } |
| } |
| |
| @Override |
| public void shutdown() { |
| phoneStopTrackingCallStateChange(); |
| phoneStopTrackingPowerLevelChange(); |
| phoneStopTrackingServiceStateChange(); |
| phoneStopTrackingDataConnectionStateChange(); |
| } |
| } |
