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