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.telephony.Rlog;
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        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     */
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     */
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     */
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     */
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     */
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     */
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     */
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    public static boolean supportsAdn(int phoneType) {
182        return phoneType == PhoneConstants.PHONE_TYPE_GSM;
183    }
184
185    /**
186     * Returns true if the device can distinguish the phone's dialing state
187     * (Call.State.DIALING/ALERTING) and connected state (Call.State.ACTIVE).
188     *
189     * Currently this returns true for GSM phones as we cannot know when a CDMA
190     * phone has transitioned from dialing/active to connected.
191     */
192    public static boolean canDistinguishDialingAndConnected(int phoneType) {
193        return phoneType == PhoneConstants.PHONE_TYPE_GSM;
194    }
195}
196