1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.phone; 18 19 import android.content.Context; 20 import android.provider.Settings; 21 import android.util.Log; 22 23 import com.android.internal.telephony.Phone; 24 25 /** 26 * TODO: This is intended as a temporary repository for behavior policy 27 * functions that depend upon the type of phone or the carrier. Ultimately 28 * these sorts of questions should be answered by the telephony layer. 29 */ 30 public class TelephonyCapabilities { 31 private static final String LOG_TAG = "TelephonyCapabilities"; 32 33 /** This class is never instantiated. */ 34 private TelephonyCapabilities() { 35 } 36 37 /** 38 * On GSM devices, we never use short tones. 39 * On CDMA devices, it depends upon the settings. 40 * TODO: I don't think this has anything to do with GSM versus CDMA, 41 * should we be looking only at the setting? 42 */ 43 /* package */ static boolean useShortDtmfTones(Phone phone, Context context) { 44 int phoneType = phone.getPhoneType(); 45 if (phoneType == Phone.PHONE_TYPE_GSM) { 46 return false; 47 } else if (phoneType == Phone.PHONE_TYPE_CDMA) { 48 int toneType = android.provider.Settings.System.getInt( 49 context.getContentResolver(), 50 Settings.System.DTMF_TONE_TYPE_WHEN_DIALING, 51 CallFeaturesSetting.DTMF_TONE_TYPE_NORMAL); 52 if (toneType == CallFeaturesSetting.DTMF_TONE_TYPE_NORMAL) { 53 return true; 54 } else { 55 return false; 56 } 57 } else if (phoneType == Phone.PHONE_TYPE_SIP) { 58 // TODO: confirm SipPhone supports this 59 return true; 60 } else { 61 throw new IllegalStateException("Unexpected phone type: " + phoneType); 62 } 63 } 64 65 /** 66 * Return true if the current phone supports ECM ("Emergency Callback 67 * Mode"), which is a feature where the device goes into a special 68 * state for a short period of time after making an outgoing emergency 69 * call. 70 * 71 * (On current devices, that state lasts 5 minutes. It prevents data 72 * usage by other apps, to avoid conflicts with any possible incoming 73 * calls. It also puts up a notification in the status bar, showing a 74 * countdown while ECM is active, and allowing the user to exit ECM.) 75 * 76 * Currently this is assumed to be true for CDMA phones, and false 77 * otherwise. 78 * 79 * TODO: This capability should really be exposed by the telephony 80 * layer, since it depends on the underlying telephony technology. 81 * (Or, is this actually carrier-specific? Is it VZW-only?) 82 */ 83 /* package */ static boolean supportsEcm(Phone phone) { 84 return (phone.getPhoneType() == Phone.PHONE_TYPE_CDMA); 85 } 86 87 /** 88 * Return true if the current phone supports Over The Air Service 89 * Provisioning (OTASP) 90 * 91 * Currently this is assumed to be true for CDMA phones, and false 92 * otherwise. 93 * 94 * TODO: This capability should really be exposed by the telephony 95 * layer, since it depends on the underlying telephony technology. 96 * 97 * TODO: Watch out: this is also highly carrier-specific, since the 98 * OTA procedure is different from one carrier to the next, *and* the 99 * different carriers may want very different onscreen UI as well. 100 * The procedure may even be different for different devices with the 101 * same carrier. 102 * 103 * So we eventually will need a much more flexible, pluggable design. 104 * This method here is just a placeholder to reduce hardcoded 105 * "if (CDMA)" checks sprinkled throughout the rest of the phone app. 106 * 107 * TODO: consider using the term "OTASP" rather "OTA" everywhere in the 108 * phone app, since OTA can also mean over-the-air software updates. 109 */ 110 /* package */ static boolean supportsOtasp(Phone phone) { 111 return (phone.getPhoneType() == Phone.PHONE_TYPE_CDMA); 112 } 113 114 /** 115 * Return true if the current phone can retrieve the voice message count. 116 * 117 * Currently this is assumed to be true on CDMA phones and false otherwise. 118 * 119 * TODO: This capability should really be exposed by the telephony 120 * layer, since it depends on the underlying telephony technology. 121 */ 122 /* package */ static boolean supportsVoiceMessageCount(Phone phone) { 123 return (phone.getPhoneType() == Phone.PHONE_TYPE_CDMA); 124 } 125 126 /** 127 * Return true if this phone allows the user to select which 128 * network to use. 129 * 130 * Currently this is assumed to be true only on GSM phones. 131 * 132 * TODO: Should CDMA phones allow this as well? 133 */ 134 /* package */ static boolean supportsNetworkSelection(Phone phone) { 135 return (phone.getPhoneType() == Phone.PHONE_TYPE_GSM); 136 } 137 138 /** 139 * Returns a resource ID for a label to use when displaying the 140 * "device id" of the current device. (This is currently used as the 141 * title of the "device id" dialog.) 142 * 143 * This is specific to the device's telephony technology: the device 144 * id is called "IMEI" on GSM phones and "MEID" on CDMA phones. 145 * TODO: ultimately this name should come directly from the 146 * telephony layer. 147 */ 148 /* package */ static int getDeviceIdLabel(Phone phone) { 149 if (phone.getPhoneType() == Phone.PHONE_TYPE_GSM) { 150 return R.string.imei; 151 } else if (phone.getPhoneType() == Phone.PHONE_TYPE_CDMA) { 152 return R.string.meid; 153 } else { 154 Log.w(LOG_TAG, "getDeviceIdLabel: no known label for phone " 155 + phone.getPhoneName()); 156 return 0; 157 } 158 } 159 160 /** 161 * Return true if the current phone supports the ability to explicitly 162 * manage the state of a conference call (i.e. view the participants, 163 * and hangup or separate individual callers.) 164 * 165 * The in-call screen's "Manage conference" UI is available only on 166 * devices that support this feature. 167 * 168 * Currently this is assumed to be true on GSM phones and false otherwise. 169 * TODO: This capability should really be exposed by the telephony 170 * layer, since it depends on the underlying telephony technology. 171 */ 172 /* package */ static boolean supportsConferenceCallManagement(Phone phone) { 173 return ((phone.getPhoneType() == Phone.PHONE_TYPE_GSM) 174 || (phone.getPhoneType() == Phone.PHONE_TYPE_SIP)); 175 } 176 177 /** 178 * Return true if the current phone supports explicit "Hold" and 179 * "Unhold" actions for an active call. (If so, the in-call UI will 180 * provide onscreen "Hold" / "Unhold" buttons.) 181 * 182 * Currently this is assumed to be true on GSM phones and false 183 * otherwise. (In particular, CDMA has no concept of "putting a call 184 * on hold.") 185 * TODO: This capability should really be exposed by the telephony 186 * layer, since it depends on the underlying telephony technology. 187 */ 188 /* package */ static boolean supportsHoldAndUnhold(Phone phone) { 189 return ((phone.getPhoneType() == Phone.PHONE_TYPE_GSM) 190 || (phone.getPhoneType() == Phone.PHONE_TYPE_SIP)); 191 } 192 193 /** 194 * Return true if the current phone supports distinct "Answer & Hold" 195 * and "Answer & End" behaviors in the call-waiting scenario. If so, 196 * the in-call UI may provide separate buttons or menu items for these 197 * two actions. 198 * 199 * Currently this is assumed to be true on GSM phones and false 200 * otherwise. (In particular, CDMA has no concept of explicitly 201 * managing the background call, or "putting a call on hold.") 202 * 203 * TODO: This capability should really be exposed by the telephony 204 * layer, since it depends on the underlying telephony technology. 205 * 206 * TODO: It might be better to expose this capability in a more 207 * generic form, like maybe "supportsExplicitMultipleLineManagement()" 208 * rather than focusing specifically on call-waiting behavior. 209 */ 210 /* package */ static boolean supportsAnswerAndHold(Phone phone) { 211 return ((phone.getPhoneType() == Phone.PHONE_TYPE_GSM) 212 || (phone.getPhoneType() == Phone.PHONE_TYPE_SIP)); 213 } 214 } 215
