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.internal.telephony;
18 
19 import android.compat.annotation.UnsupportedAppUsage;
20 
21 import com.android.telephony.Rlog;
22 
23 /**
24  * Utilities that check if the phone supports specified capabilities.
25  */
26 public class TelephonyCapabilities {
27     private static final String LOG_TAG = "TelephonyCapabilities";
28 
29     /** This class is never instantiated. */
TelephonyCapabilities()30     private TelephonyCapabilities() {
31     }
32 
33     /**
34      * Return true if the current phone supports ECM ("Emergency Callback
35      * Mode"), which is a feature where the device goes into a special
36      * state for a short period of time after making an outgoing emergency
37      * call.
38      *
39      * (On current devices, that state lasts 5 minutes.  It prevents data
40      * usage by other apps, to avoid conflicts with any possible incoming
41      * calls.  It also puts up a notification in the status bar, showing a
42      * countdown while ECM is active, and allowing the user to exit ECM.)
43      *
44      * Currently this is assumed to be true for CDMA phones, and false
45      * otherwise.
46      */
supportsEcm(Phone phone)47     public static boolean supportsEcm(Phone phone) {
48         Rlog.d(LOG_TAG, "supportsEcm: Phone type = " + phone.getPhoneType() +
49                   " Ims Phone = " + phone.getImsPhone());
50         return (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA ||
51                 phone.getImsPhone() != null);
52     }
53 
54     /**
55      * Return true if the current phone supports Over The Air Service
56      * Provisioning (OTASP)
57      *
58      * Currently this is assumed to be true for CDMA phones, and false
59      * otherwise.
60      *
61      * TODO: Watch out: this is also highly carrier-specific, since the
62      * OTASP procedure is different from one carrier to the next, *and* the
63      * different carriers may want very different onscreen UI as well.
64      * The procedure may even be different for different devices with the
65      * same carrier.
66      *
67      * So we eventually will need a much more flexible, pluggable design.
68      * This method here is just a placeholder to reduce hardcoded
69      * "if (CDMA)" checks sprinkled throughout the phone app.
70      */
supportsOtasp(Phone phone)71     public static boolean supportsOtasp(Phone phone) {
72         return (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA);
73     }
74 
75     /**
76      * Return true if the current phone supports voice message count.
77      * and the count is available
78      * Both CDMA and GSM phones support voice message count
79      */
supportsVoiceMessageCount(Phone phone)80     public static boolean supportsVoiceMessageCount(Phone phone) {
81         return (phone.getVoiceMessageCount() != -1);
82     }
83 
84     /**
85      * Return true if this phone allows the user to select which
86      * network to use.
87      *
88      * Currently this is assumed to be true only on GSM phones.
89      *
90      * TODO: Should CDMA phones allow this as well?
91      */
supportsNetworkSelection(Phone phone)92     public static boolean supportsNetworkSelection(Phone phone) {
93         return (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_GSM);
94     }
95 
96     /**
97      * Returns a resource ID for a label to use when displaying the
98      * "device id" of the current device.  (This is currently used as the
99      * title of the "device id" dialog.)
100      *
101      * This is specific to the device's telephony technology: the device
102      * id is called "IMEI" on GSM phones and "MEID" on CDMA phones.
103      */
getDeviceIdLabel(Phone phone)104     public static int getDeviceIdLabel(Phone phone) {
105         if (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_GSM) {
106             return com.android.internal.R.string.imei;
107         } else if (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) {
108             return com.android.internal.R.string.meid;
109         } else {
110             Rlog.w(LOG_TAG, "getDeviceIdLabel: no known label for phone "
111                   + phone.getPhoneName());
112             return 0;
113         }
114     }
115 
116     /**
117      * Return true if the current phone supports the ability to explicitly
118      * manage the state of a conference call (i.e. view the participants,
119      * and hangup or separate individual callers.)
120      *
121      * The in-call screen's "Manage conference" UI is available only on
122      * devices that support this feature.
123      *
124      * Currently this is assumed to be true on GSM phones and false otherwise.
125      */
supportsConferenceCallManagement(Phone phone)126     public static boolean supportsConferenceCallManagement(Phone phone) {
127         return ((phone.getPhoneType() == PhoneConstants.PHONE_TYPE_GSM)
128                 || (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_SIP));
129     }
130 
131     /**
132      * Return true if the current phone supports explicit "Hold" and
133      * "Unhold" actions for an active call.  (If so, the in-call UI will
134      * provide onscreen "Hold" / "Unhold" buttons.)
135      *
136      * Currently this is assumed to be true on GSM phones and false
137      * otherwise.  (In particular, CDMA has no concept of "putting a call
138      * on hold.")
139      */
supportsHoldAndUnhold(Phone phone)140     public static boolean supportsHoldAndUnhold(Phone phone) {
141         return ((phone.getPhoneType() == PhoneConstants.PHONE_TYPE_GSM)
142                 || (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_SIP)
143                 || (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_IMS));
144     }
145 
146     /**
147      * Return true if the current phone supports distinct "Answer & Hold"
148      * and "Answer & End" behaviors in the call-waiting scenario.  If so,
149      * the in-call UI may provide separate buttons or menu items for these
150      * two actions.
151      *
152      * Currently this is assumed to be true on GSM phones and false
153      * otherwise.  (In particular, CDMA has no concept of explicitly
154      * managing the background call, or "putting a call on hold.")
155      *
156      * TODO: It might be better to expose this capability in a more
157      * generic form, like maybe "supportsExplicitMultipleLineManagement()"
158      * rather than focusing specifically on call-waiting behavior.
159      */
supportsAnswerAndHold(Phone phone)160     public static boolean supportsAnswerAndHold(Phone phone) {
161         return ((phone.getPhoneType() == PhoneConstants.PHONE_TYPE_GSM)
162                 || (phone.getPhoneType() == PhoneConstants.PHONE_TYPE_SIP));
163     }
164 
165     /**
166      * Return true if phones with the given phone type support ADN
167      * (Abbreviated Dialing Numbers).
168      *
169      * Currently this returns true when the phone type is GSM
170      * ({@link PhoneConstants#PHONE_TYPE_GSM}).
171      *
172      * This is using int for an argument for letting apps outside
173      * Phone process access to it, while other methods in this class is
174      * using Phone object.
175      *
176      * TODO: Theoretically phones other than GSM may have the ADN capability.
177      * Consider having better check here, or have better capability as part
178      * of public API, with which the argument should be replaced with
179      * something more appropriate.
180      */
181     @UnsupportedAppUsage
supportsAdn(int phoneType)182     public static boolean supportsAdn(int phoneType) {
183         return phoneType == PhoneConstants.PHONE_TYPE_GSM;
184     }
185 
186     /**
187      * Returns true if the device can distinguish the phone's dialing state
188      * (Call.State.DIALING/ALERTING) and connected state (Call.State.ACTIVE).
189      *
190      * Currently this returns true for GSM phones as we cannot know when a CDMA
191      * phone has transitioned from dialing/active to connected.
192      */
canDistinguishDialingAndConnected(int phoneType)193     public static boolean canDistinguishDialingAndConnected(int phoneType) {
194         return phoneType == PhoneConstants.PHONE_TYPE_GSM;
195     }
196 }
197