Merge "Remove volte_feature_disabled as carrier config handled it." into mnc-dev
[android/platform/frameworks/opt/net/ims.git] / src / java / com / android / ims / ImsManager.java
1 /*
2  * Copyright (c) 2013 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.ims;
18
19 import android.app.PendingIntent;
20 import android.app.QueuedWork;
21 import android.content.Context;
22 import android.content.Intent;
23 import android.os.IBinder;
24 import android.os.Message;
25 import android.os.PersistableBundle;
26 import android.os.RemoteException;
27 import android.os.ServiceManager;
28 import android.os.SystemProperties;
29 import android.provider.Settings;
30 import android.telecom.TelecomManager;
31 import android.telephony.CarrierConfigManager;
32 import android.telephony.Rlog;
33 import android.telephony.SubscriptionManager;
34 import android.telephony.TelephonyManager;
35
36 import com.android.ims.internal.IImsCallSession;
37 import com.android.ims.internal.IImsEcbm;
38 import com.android.ims.internal.IImsEcbmListener;
39 import com.android.ims.internal.IImsRegistrationListener;
40 import com.android.ims.internal.IImsService;
41 import com.android.ims.internal.IImsUt;
42 import com.android.ims.internal.ImsCallSession;
43 import com.android.ims.internal.IImsConfig;
44
45 import java.util.HashMap;
46
47 /**
48  * Provides APIs for IMS services, such as initiating IMS calls, and provides access to
49  * the operator's IMS network. This class is the starting point for any IMS actions.
50  * You can acquire an instance of it with {@link #getInstance getInstance()}.</p>
51  * <p>The APIs in this class allows you to:</p>
52  *
53  * @hide
54  */
55 public class ImsManager {
56
57     /*
58      * Debug flag to override configuration flag
59      */
60     public static final String PROPERTY_DBG_VOLTE_AVAIL_OVERRIDE = "persist.dbg.volte_avail_ovr";
61     public static final int PROPERTY_DBG_VOLTE_AVAIL_OVERRIDE_DEFAULT = 0;
62     public static final String PROPERTY_DBG_VT_AVAIL_OVERRIDE = "persist.dbg.vt_avail_ovr";
63     public static final int PROPERTY_DBG_VT_AVAIL_OVERRIDE_DEFAULT = 0;
64     public static final String PROPERTY_DBG_WFC_AVAIL_OVERRIDE = "persist.dbg.wfc_avail_ovr";
65     public static final int PROPERTY_DBG_WFC_AVAIL_OVERRIDE_DEFAULT = 0;
66
67     /**
68      * For accessing the IMS related service.
69      * Internal use only.
70      * @hide
71      */
72     private static final String IMS_SERVICE = "ims";
73
74     /**
75      * The result code to be sent back with the incoming call {@link PendingIntent}.
76      * @see #open(PendingIntent, ImsConnectionStateListener)
77      */
78     public static final int INCOMING_CALL_RESULT_CODE = 101;
79
80     /**
81      * Key to retrieve the call ID from an incoming call intent.
82      * @see #open(PendingIntent, ImsConnectionStateListener)
83      */
84     public static final String EXTRA_CALL_ID = "android:imsCallID";
85
86     /**
87      * Action to broadcast when ImsService is up.
88      * Internal use only.
89      * @hide
90      */
91     public static final String ACTION_IMS_SERVICE_UP =
92             "com.android.ims.IMS_SERVICE_UP";
93
94     /**
95      * Action to broadcast when ImsService is down.
96      * Internal use only.
97      * @hide
98      */
99     public static final String ACTION_IMS_SERVICE_DOWN =
100             "com.android.ims.IMS_SERVICE_DOWN";
101
102     /**
103      * Action to broadcast when ImsService registration fails.
104      * Internal use only.
105      * @hide
106      */
107     public static final String ACTION_IMS_REGISTRATION_ERROR =
108             "com.android.ims.REGISTRATION_ERROR";
109
110     /**
111      * Part of the ACTION_IMS_SERVICE_UP or _DOWN intents.
112      * A long value; the phone ID corresponding to the IMS service coming up or down.
113      * Internal use only.
114      * @hide
115      */
116     public static final String EXTRA_PHONE_ID = "android:phone_id";
117
118     /**
119      * Action for the incoming call intent for the Phone app.
120      * Internal use only.
121      * @hide
122      */
123     public static final String ACTION_IMS_INCOMING_CALL =
124             "com.android.ims.IMS_INCOMING_CALL";
125
126     /**
127      * Part of the ACTION_IMS_INCOMING_CALL intents.
128      * An integer value; service identifier obtained from {@link ImsManager#open}.
129      * Internal use only.
130      * @hide
131      */
132     public static final String EXTRA_SERVICE_ID = "android:imsServiceId";
133
134     /**
135      * Part of the ACTION_IMS_INCOMING_CALL intents.
136      * An boolean value; Flag to indicate that the incoming call is a normal call or call for USSD.
137      * The value "true" indicates that the incoming call is for USSD.
138      * Internal use only.
139      * @hide
140      */
141     public static final String EXTRA_USSD = "android:ussd";
142
143     private static final String TAG = "ImsManager";
144     private static final boolean DBG = true;
145
146     private static HashMap<Integer, ImsManager> sImsManagerInstances =
147             new HashMap<Integer, ImsManager>();
148
149     private Context mContext;
150     private int mPhoneId;
151     private IImsService mImsService = null;
152     private ImsServiceDeathRecipient mDeathRecipient = new ImsServiceDeathRecipient();
153     // Ut interface for the supplementary service configuration
154     private ImsUt mUt = null;
155     // Interface to get/set ims config items
156     private ImsConfig mConfig = null;
157
158     // ECBM interface
159     private ImsEcbm mEcbm = null;
160
161     /**
162      * Gets a manager instance.
163      *
164      * @param context application context for creating the manager object
165      * @param phoneId the phone ID for the IMS Service
166      * @return the manager instance corresponding to the phoneId
167      */
168     public static ImsManager getInstance(Context context, int phoneId) {
169         synchronized (sImsManagerInstances) {
170             if (sImsManagerInstances.containsKey(phoneId))
171                 return sImsManagerInstances.get(phoneId);
172
173             ImsManager mgr = new ImsManager(context, phoneId);
174             sImsManagerInstances.put(phoneId, mgr);
175
176             return mgr;
177         }
178     }
179
180     /**
181      * Returns the user configuration of Enhanced 4G LTE Mode setting
182      */
183     public static boolean isEnhanced4gLteModeSettingEnabledByUser(Context context) {
184         int enabled = android.provider.Settings.Global.getInt(
185                     context.getContentResolver(),
186                     android.provider.Settings.Global.ENHANCED_4G_MODE_ENABLED, ImsConfig.FeatureValueConstants.ON);
187         return (enabled == 1) ? true : false;
188     }
189
190     /**
191      * Change persistent Enhanced 4G LTE Mode setting
192      */
193     public static void setEnhanced4gLteModeSetting(Context context, boolean enabled) {
194         int value = enabled ? 1 : 0;
195         android.provider.Settings.Global.putInt(
196                 context.getContentResolver(),
197                 android.provider.Settings.Global.ENHANCED_4G_MODE_ENABLED, value);
198
199         if (isNonTtyOrTtyOnVolteEnabled(context)) {
200             ImsManager imsManager = ImsManager.getInstance(context,
201                     SubscriptionManager.getDefaultVoicePhoneId());
202             if (imsManager != null) {
203                 try {
204                     imsManager.setAdvanced4GMode(enabled);
205                 } catch (ImsException ie) {
206                     // do nothing
207                 }
208             }
209         }
210     }
211
212     /**
213      * Indicates whether the call is non-TTY or if TTY - whether TTY on VoLTE is
214      * supported.
215      */
216     public static boolean isNonTtyOrTtyOnVolteEnabled(Context context) {
217         if (getBooleanCarrierConfig(context,
218                     CarrierConfigManager.KEY_CARRIER_VOLTE_TTY_SUPPORTED_BOOL)) {
219             return true;
220         }
221
222         return Settings.Secure.getInt(context.getContentResolver(),
223                 Settings.Secure.PREFERRED_TTY_MODE, TelecomManager.TTY_MODE_OFF)
224                 == TelecomManager.TTY_MODE_OFF;
225     }
226
227     /**
228      * Returns a platform configuration for VoLTE which may override the user setting.
229      */
230     public static boolean isVolteEnabledByPlatform(Context context) {
231         if (SystemProperties.getInt(PROPERTY_DBG_VOLTE_AVAIL_OVERRIDE,
232                 PROPERTY_DBG_VOLTE_AVAIL_OVERRIDE_DEFAULT) == 1) {
233             return true;
234         }
235
236         return context.getResources().getBoolean(
237                 com.android.internal.R.bool.config_device_volte_available)
238                 && getBooleanCarrierConfig(context,
239                         CarrierConfigManager.KEY_CARRIER_VOLTE_AVAILABLE_BOOL);
240     }
241
242     /*
243      * Indicates whether VoLTE is provisioned on device
244      */
245     public static boolean isVolteProvisionedOnDevice(Context context) {
246         boolean isProvisioned = true;
247         if (getBooleanCarrierConfig(context,
248                     CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL)) {
249             isProvisioned = false; // disable on any error
250             ImsManager mgr = ImsManager.getInstance(context,
251                     SubscriptionManager.getDefaultVoicePhoneId());
252             if (mgr != null) {
253                 try {
254                     ImsConfig config = mgr.getConfigInterface();
255                     if (config != null) {
256                         isProvisioned = config.getVolteProvisioned();
257                     }
258                 } catch (ImsException ie) {
259                     // do nothing
260                 }
261             }
262         }
263
264         return isProvisioned;
265     }
266
267     /**
268      * Returns a platform configuration for VT which may override the user setting.
269      *
270      * Note: VT presumes that VoLTE is enabled (these are configuration settings
271      * which must be done correctly).
272      */
273     public static boolean isVtEnabledByPlatform(Context context) {
274         if (SystemProperties.getInt(PROPERTY_DBG_VT_AVAIL_OVERRIDE,
275                 PROPERTY_DBG_VT_AVAIL_OVERRIDE_DEFAULT) == 1) {
276             return true;
277         }
278
279         return
280                 context.getResources().getBoolean(
281                         com.android.internal.R.bool.config_device_vt_available) &&
282                 getBooleanCarrierConfig(context,
283                         CarrierConfigManager.KEY_CARRIER_VT_AVAILABLE_BOOL);
284     }
285
286     /**
287      * Returns the user configuration of WFC setting
288      */
289     public static boolean isWfcEnabledByUser(Context context) {
290         int enabled = android.provider.Settings.Global.getInt(context.getContentResolver(),
291                 android.provider.Settings.Global.WFC_IMS_ENABLED,
292                 ImsConfig.FeatureValueConstants.OFF);
293         return (enabled == 1) ? true : false;
294     }
295
296     /**
297      * Change persistent WFC enabled setting
298      */
299     public static void setWfcSetting(Context context, boolean enabled) {
300         int value = enabled ? 1 : 0;
301         android.provider.Settings.Global.putInt(context.getContentResolver(),
302                 android.provider.Settings.Global.WFC_IMS_ENABLED, value);
303
304         ImsManager imsManager = ImsManager.getInstance(context,
305                 SubscriptionManager.getDefaultVoicePhoneId());
306         if (imsManager != null) {
307             try {
308                 ImsConfig config = imsManager.getConfigInterface();
309                 // FIXME: replace NETWORK_TYPE_LTE with NETWORK_TYPE_IWLAN
310                 // when available
311                 config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_WIFI,
312                         TelephonyManager.NETWORK_TYPE_LTE,
313                         enabled ? ImsConfig.FeatureValueConstants.ON
314                                 : ImsConfig.FeatureValueConstants.OFF, null);
315
316                 if (enabled) {
317                     imsManager.turnOnIms();
318                 } else if (getBooleanCarrierConfig(context,
319                         CarrierConfigManager.KEY_CARRIER_ALLOW_TURNOFF_IMS_BOOL)
320                         && (!isVolteEnabledByPlatform(context)
321                         || !isEnhanced4gLteModeSettingEnabledByUser(context))) {
322                     log("setWfcSetting() : imsServiceAllowTurnOff -> turnOffIms");
323                     imsManager.turnOffIms();
324                 }
325
326                 // Force IMS to register over LTE when turning off WFC
327                 setWfcModeInternal(context, enabled
328                         ? getWfcMode(context)
329                         : ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED);
330             } catch (ImsException e) {
331                 loge("setWfcSetting(): " + e);
332             }
333         }
334     }
335
336     /**
337      * Returns the user configuration of WFC modem setting
338      */
339     public static int getWfcMode(Context context) {
340         int setting = android.provider.Settings.Global.getInt(context.getContentResolver(),
341                 android.provider.Settings.Global.WFC_IMS_MODE,
342                 ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED);
343         if (DBG) log("getWfcMode - setting=" + setting);
344         return setting;
345     }
346
347     /**
348      * Returns the user configuration of WFC modem setting
349      */
350     public static void setWfcMode(Context context, int wfcMode) {
351         if (DBG) log("setWfcMode - setting=" + wfcMode);
352         android.provider.Settings.Global.putInt(context.getContentResolver(),
353                 android.provider.Settings.Global.WFC_IMS_MODE, wfcMode);
354
355         setWfcModeInternal(context, wfcMode);
356     }
357
358     private static void setWfcModeInternal(Context context, int wfcMode) {
359         final ImsManager imsManager = ImsManager.getInstance(context,
360                 SubscriptionManager.getDefaultVoicePhoneId());
361         if (imsManager != null) {
362             final int value = wfcMode;
363             QueuedWork.singleThreadExecutor().submit(new Runnable() {
364                 public void run() {
365                     try {
366                         imsManager.getConfigInterface().setProvisionedValue(
367                                 ImsConfig.ConfigConstants.VOICE_OVER_WIFI_MODE,
368                                 value);
369                     } catch (ImsException e) {
370                         // do nothing
371                     }
372                 }
373             });
374         }
375     }
376
377     /**
378      * Returns the user configuration of WFC roaming setting
379      */
380     public static boolean isWfcRoamingEnabledByUser(Context context) {
381         int enabled = android.provider.Settings.Global.getInt(context.getContentResolver(),
382                 android.provider.Settings.Global.WFC_IMS_ROAMING_ENABLED,
383                 ImsConfig.FeatureValueConstants.OFF);
384         return (enabled == 1) ? true : false;
385     }
386
387     /**
388      * Change persistent WFC roaming enabled setting
389      */
390     public static void setWfcRoamingSetting(Context context, boolean enabled) {
391         final int value = enabled
392                 ? ImsConfig.FeatureValueConstants.ON
393                 : ImsConfig.FeatureValueConstants.OFF;
394         android.provider.Settings.Global.putInt(context.getContentResolver(),
395                 android.provider.Settings.Global.WFC_IMS_ROAMING_ENABLED, value);
396
397         final ImsManager imsManager = ImsManager.getInstance(context,
398                 SubscriptionManager.getDefaultVoicePhoneId());
399         if (imsManager != null) {
400             QueuedWork.singleThreadExecutor().submit(new Runnable() {
401                 public void run() {
402                     try {
403                         imsManager.getConfigInterface().setProvisionedValue(
404                                 ImsConfig.ConfigConstants.VOICE_OVER_WIFI_ROAMING,
405                                 value);
406                     } catch (ImsException e) {
407                         // do nothing
408                     }
409                 }
410             });
411         }
412     }
413
414     /**
415      * Returns a platform configuration for WFC which may override the user
416      * setting. Note: WFC presumes that VoLTE is enabled (these are
417      * configuration settings which must be done correctly).
418      */
419     public static boolean isWfcEnabledByPlatform(Context context) {
420         if (SystemProperties.getInt(PROPERTY_DBG_WFC_AVAIL_OVERRIDE,
421                 PROPERTY_DBG_WFC_AVAIL_OVERRIDE_DEFAULT) == 1) {
422             return true;
423         }
424
425         return
426                context.getResources().getBoolean(
427                        com.android.internal.R.bool.config_device_wfc_ims_available) &&
428                getBooleanCarrierConfig(context,
429                        CarrierConfigManager.KEY_CARRIER_WFC_IMS_AVAILABLE_BOOL);
430     }
431
432     private ImsManager(Context context, int phoneId) {
433         mContext = context;
434         mPhoneId = phoneId;
435         createImsService(true);
436     }
437
438     /*
439      * Returns a flag indicating whether the IMS service is available.
440      */
441     public boolean isServiceAvailable() {
442         if (mImsService != null) {
443             return true;
444         }
445
446         IBinder binder = ServiceManager.checkService(getImsServiceName(mPhoneId));
447         if (binder != null) {
448             return true;
449         }
450
451         return false;
452     }
453
454     /**
455      * Opens the IMS service for making calls and/or receiving generic IMS calls.
456      * The caller may make subsquent calls through {@link #makeCall}.
457      * The IMS service will register the device to the operator's network with the credentials
458      * (from ISIM) periodically in order to receive calls from the operator's network.
459      * When the IMS service receives a new call, it will send out an intent with
460      * the provided action string.
461      * The intent contains a call ID extra {@link getCallId} and it can be used to take a call.
462      *
463      * @param serviceClass a service class specified in {@link ImsServiceClass}
464      *      For VoLTE service, it MUST be a {@link ImsServiceClass#MMTEL}.
465      * @param incomingCallPendingIntent When an incoming call is received,
466      *        the IMS service will call {@link PendingIntent#send(Context, int, Intent)} to
467      *        send back the intent to the caller with {@link #INCOMING_CALL_RESULT_CODE}
468      *        as the result code and the intent to fill in the call ID; It cannot be null
469      * @param listener To listen to IMS registration events; It cannot be null
470      * @return identifier (greater than 0) for the specified service
471      * @throws NullPointerException if {@code incomingCallPendingIntent}
472      *      or {@code listener} is null
473      * @throws ImsException if calling the IMS service results in an error
474      * @see #getCallId
475      * @see #getServiceId
476      */
477     public int open(int serviceClass, PendingIntent incomingCallPendingIntent,
478             ImsConnectionStateListener listener) throws ImsException {
479         checkAndThrowExceptionIfServiceUnavailable();
480
481         if (incomingCallPendingIntent == null) {
482             throw new NullPointerException("incomingCallPendingIntent can't be null");
483         }
484
485         if (listener == null) {
486             throw new NullPointerException("listener can't be null");
487         }
488
489         int result = 0;
490
491         try {
492             result = mImsService.open(mPhoneId, serviceClass, incomingCallPendingIntent,
493                     createRegistrationListenerProxy(serviceClass, listener));
494         } catch (RemoteException e) {
495             throw new ImsException("open()", e,
496                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
497         }
498
499         if (result <= 0) {
500             // If the return value is a minus value,
501             // it means that an error occurred in the service.
502             // So, it needs to convert to the reason code specified in ImsReasonInfo.
503             throw new ImsException("open()", (result * (-1)));
504         }
505
506         return result;
507     }
508
509     /**
510      * Closes the specified service ({@link ImsServiceClass}) not to make/receive calls.
511      * All the resources that were allocated to the service are also released.
512      *
513      * @param serviceId a service id to be closed which is obtained from {@link ImsManager#open}
514      * @throws ImsException if calling the IMS service results in an error
515      */
516     public void close(int serviceId) throws ImsException {
517         checkAndThrowExceptionIfServiceUnavailable();
518
519         try {
520             mImsService.close(serviceId);
521         } catch (RemoteException e) {
522             throw new ImsException("close()", e,
523                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
524         } finally {
525             mUt = null;
526             mConfig = null;
527             mEcbm = null;
528         }
529     }
530
531     /**
532      * Gets the configuration interface to provision / withdraw the supplementary service settings.
533      *
534      * @param serviceId a service id which is obtained from {@link ImsManager#open}
535      * @return the Ut interface instance
536      * @throws ImsException if getting the Ut interface results in an error
537      */
538     public ImsUtInterface getSupplementaryServiceConfiguration(int serviceId)
539             throws ImsException {
540         // FIXME: manage the multiple Ut interfaces based on the service id
541         if (mUt == null) {
542             checkAndThrowExceptionIfServiceUnavailable();
543
544             try {
545                 IImsUt iUt = mImsService.getUtInterface(serviceId);
546
547                 if (iUt == null) {
548                     throw new ImsException("getSupplementaryServiceConfiguration()",
549                             ImsReasonInfo.CODE_UT_NOT_SUPPORTED);
550                 }
551
552                 mUt = new ImsUt(iUt);
553             } catch (RemoteException e) {
554                 throw new ImsException("getSupplementaryServiceConfiguration()", e,
555                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
556             }
557         }
558
559         return mUt;
560     }
561
562     /**
563      * Checks if the IMS service has successfully registered to the IMS network
564      * with the specified service & call type.
565      *
566      * @param serviceId a service id which is obtained from {@link ImsManager#open}
567      * @param serviceType a service type that is specified in {@link ImsCallProfile}
568      *        {@link ImsCallProfile#SERVICE_TYPE_NORMAL}
569      *        {@link ImsCallProfile#SERVICE_TYPE_EMERGENCY}
570      * @param callType a call type that is specified in {@link ImsCallProfile}
571      *        {@link ImsCallProfile#CALL_TYPE_VOICE_N_VIDEO}
572      *        {@link ImsCallProfile#CALL_TYPE_VOICE}
573      *        {@link ImsCallProfile#CALL_TYPE_VT}
574      *        {@link ImsCallProfile#CALL_TYPE_VS}
575      * @return true if the specified service id is connected to the IMS network;
576      *        false otherwise
577      * @throws ImsException if calling the IMS service results in an error
578      */
579     public boolean isConnected(int serviceId, int serviceType, int callType)
580             throws ImsException {
581         checkAndThrowExceptionIfServiceUnavailable();
582
583         try {
584             return mImsService.isConnected(serviceId, serviceType, callType);
585         } catch (RemoteException e) {
586             throw new ImsException("isServiceConnected()", e,
587                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
588         }
589     }
590
591     /**
592      * Checks if the specified IMS service is opend.
593      *
594      * @param serviceId a service id which is obtained from {@link ImsManager#open}
595      * @return true if the specified service id is opened; false otherwise
596      * @throws ImsException if calling the IMS service results in an error
597      */
598     public boolean isOpened(int serviceId) throws ImsException {
599         checkAndThrowExceptionIfServiceUnavailable();
600
601         try {
602             return mImsService.isOpened(serviceId);
603         } catch (RemoteException e) {
604             throw new ImsException("isOpened()", e,
605                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
606         }
607     }
608
609     /**
610      * Creates a {@link ImsCallProfile} from the service capabilities & IMS registration state.
611      *
612      * @param serviceId a service id which is obtained from {@link ImsManager#open}
613      * @param serviceType a service type that is specified in {@link ImsCallProfile}
614      *        {@link ImsCallProfile#SERVICE_TYPE_NONE}
615      *        {@link ImsCallProfile#SERVICE_TYPE_NORMAL}
616      *        {@link ImsCallProfile#SERVICE_TYPE_EMERGENCY}
617      * @param callType a call type that is specified in {@link ImsCallProfile}
618      *        {@link ImsCallProfile#CALL_TYPE_VOICE}
619      *        {@link ImsCallProfile#CALL_TYPE_VT}
620      *        {@link ImsCallProfile#CALL_TYPE_VT_TX}
621      *        {@link ImsCallProfile#CALL_TYPE_VT_RX}
622      *        {@link ImsCallProfile#CALL_TYPE_VT_NODIR}
623      *        {@link ImsCallProfile#CALL_TYPE_VS}
624      *        {@link ImsCallProfile#CALL_TYPE_VS_TX}
625      *        {@link ImsCallProfile#CALL_TYPE_VS_RX}
626      * @return a {@link ImsCallProfile} object
627      * @throws ImsException if calling the IMS service results in an error
628      */
629     public ImsCallProfile createCallProfile(int serviceId,
630             int serviceType, int callType) throws ImsException {
631         checkAndThrowExceptionIfServiceUnavailable();
632
633         try {
634             return mImsService.createCallProfile(serviceId, serviceType, callType);
635         } catch (RemoteException e) {
636             throw new ImsException("createCallProfile()", e,
637                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
638         }
639     }
640
641     /**
642      * Creates a {@link ImsCall} to make a call.
643      *
644      * @param serviceId a service id which is obtained from {@link ImsManager#open}
645      * @param profile a call profile to make the call
646      *      (it contains service type, call type, media information, etc.)
647      * @param participants participants to invite the conference call
648      * @param listener listen to the call events from {@link ImsCall}
649      * @return a {@link ImsCall} object
650      * @throws ImsException if calling the IMS service results in an error
651      */
652     public ImsCall makeCall(int serviceId, ImsCallProfile profile, String[] callees,
653             ImsCall.Listener listener) throws ImsException {
654         if (DBG) {
655             log("makeCall :: serviceId=" + serviceId
656                     + ", profile=" + profile + ", callees=" + callees);
657         }
658
659         checkAndThrowExceptionIfServiceUnavailable();
660
661         ImsCall call = new ImsCall(mContext, profile);
662
663         call.setListener(listener);
664         ImsCallSession session = createCallSession(serviceId, profile);
665
666         if ((callees != null) && (callees.length == 1)) {
667             call.start(session, callees[0]);
668         } else {
669             call.start(session, callees);
670         }
671
672         return call;
673     }
674
675     /**
676      * Creates a {@link ImsCall} to take an incoming call.
677      *
678      * @param serviceId a service id which is obtained from {@link ImsManager#open}
679      * @param incomingCallIntent the incoming call broadcast intent
680      * @param listener to listen to the call events from {@link ImsCall}
681      * @return a {@link ImsCall} object
682      * @throws ImsException if calling the IMS service results in an error
683      */
684     public ImsCall takeCall(int serviceId, Intent incomingCallIntent,
685             ImsCall.Listener listener) throws ImsException {
686         if (DBG) {
687             log("takeCall :: serviceId=" + serviceId
688                     + ", incomingCall=" + incomingCallIntent);
689         }
690
691         checkAndThrowExceptionIfServiceUnavailable();
692
693         if (incomingCallIntent == null) {
694             throw new ImsException("Can't retrieve session with null intent",
695                     ImsReasonInfo.CODE_LOCAL_ILLEGAL_ARGUMENT);
696         }
697
698         int incomingServiceId = getServiceId(incomingCallIntent);
699
700         if (serviceId != incomingServiceId) {
701             throw new ImsException("Service id is mismatched in the incoming call intent",
702                     ImsReasonInfo.CODE_LOCAL_ILLEGAL_ARGUMENT);
703         }
704
705         String callId = getCallId(incomingCallIntent);
706
707         if (callId == null) {
708             throw new ImsException("Call ID missing in the incoming call intent",
709                     ImsReasonInfo.CODE_LOCAL_ILLEGAL_ARGUMENT);
710         }
711
712         try {
713             IImsCallSession session = mImsService.getPendingCallSession(serviceId, callId);
714
715             if (session == null) {
716                 throw new ImsException("No pending session for the call",
717                         ImsReasonInfo.CODE_LOCAL_NO_PENDING_CALL);
718             }
719
720             ImsCall call = new ImsCall(mContext, session.getCallProfile());
721
722             call.attachSession(new ImsCallSession(session));
723             call.setListener(listener);
724
725             return call;
726         } catch (Throwable t) {
727             throw new ImsException("takeCall()", t, ImsReasonInfo.CODE_UNSPECIFIED);
728         }
729     }
730
731     /**
732      * Gets the config interface to get/set service/capability parameters.
733      *
734      * @return the ImsConfig instance.
735      * @throws ImsException if getting the setting interface results in an error.
736      */
737     public ImsConfig getConfigInterface() throws ImsException {
738
739         if (mConfig == null) {
740             checkAndThrowExceptionIfServiceUnavailable();
741
742             try {
743                 IImsConfig config = mImsService.getConfigInterface(mPhoneId);
744                 if (config == null) {
745                     throw new ImsException("getConfigInterface()",
746                             ImsReasonInfo.CODE_LOCAL_SERVICE_UNAVAILABLE);
747                 }
748                 mConfig = new ImsConfig(config, mContext);
749             } catch (RemoteException e) {
750                 throw new ImsException("getConfigInterface()", e,
751                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
752             }
753         }
754         if (DBG) log("getConfigInterface(), mConfig= " + mConfig);
755         return mConfig;
756     }
757
758     public void setUiTTYMode(Context context, int serviceId, int uiTtyMode, Message onComplete)
759             throws ImsException {
760
761         checkAndThrowExceptionIfServiceUnavailable();
762
763         try {
764             mImsService.setUiTTYMode(serviceId, uiTtyMode, onComplete);
765         } catch (RemoteException e) {
766             throw new ImsException("setTTYMode()", e,
767                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
768         }
769
770         if (!getBooleanCarrierConfig(context,
771                 CarrierConfigManager.KEY_CARRIER_VOLTE_TTY_SUPPORTED_BOOL)) {
772             setAdvanced4GMode((uiTtyMode == TelecomManager.TTY_MODE_OFF) &&
773                     isEnhanced4gLteModeSettingEnabledByUser(context));
774         }
775     }
776
777     /**
778      * Get the boolean config from carrier config manager.
779      *
780      * @param context the context to get carrier service
781      * @param key config key defined in CarrierConfigManager
782      * @return boolean value of corresponding key.
783      */
784     private static boolean getBooleanCarrierConfig(Context context, String key) {
785         CarrierConfigManager configManager = (CarrierConfigManager) context.getSystemService(
786                 Context.CARRIER_CONFIG_SERVICE);
787         PersistableBundle b = null;
788         if (configManager != null) {
789             b = configManager.getConfig();
790         }
791         if (b != null) {
792             return b.getBoolean(key);
793         } else {
794             // Return static default defined in CarrierConfigManager.
795             return CarrierConfigManager.getDefaultConfig().getBoolean(key);
796         }
797     }
798
799     /**
800      * Gets the call ID from the specified incoming call broadcast intent.
801      *
802      * @param incomingCallIntent the incoming call broadcast intent
803      * @return the call ID or null if the intent does not contain it
804      */
805     private static String getCallId(Intent incomingCallIntent) {
806         if (incomingCallIntent == null) {
807             return null;
808         }
809
810         return incomingCallIntent.getStringExtra(EXTRA_CALL_ID);
811     }
812
813     /**
814      * Gets the service type from the specified incoming call broadcast intent.
815      *
816      * @param incomingCallIntent the incoming call broadcast intent
817      * @return the service identifier or -1 if the intent does not contain it
818      */
819     private static int getServiceId(Intent incomingCallIntent) {
820         if (incomingCallIntent == null) {
821             return (-1);
822         }
823
824         return incomingCallIntent.getIntExtra(EXTRA_SERVICE_ID, -1);
825     }
826
827     /**
828      * Binds the IMS service only if the service is not created.
829      */
830     private void checkAndThrowExceptionIfServiceUnavailable()
831             throws ImsException {
832         if (mImsService == null) {
833             createImsService(true);
834
835             if (mImsService == null) {
836                 throw new ImsException("Service is unavailable",
837                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
838             }
839         }
840     }
841
842     private static String getImsServiceName(int phoneId) {
843         // TODO: MSIM implementation needs to decide on service name as a function of phoneId
844         return IMS_SERVICE;
845     }
846
847     /**
848      * Binds the IMS service to make/receive the call.
849      */
850     private void createImsService(boolean checkService) {
851         if (checkService) {
852             IBinder binder = ServiceManager.checkService(getImsServiceName(mPhoneId));
853
854             if (binder == null) {
855                 return;
856             }
857         }
858
859         IBinder b = ServiceManager.getService(getImsServiceName(mPhoneId));
860
861         if (b != null) {
862             try {
863                 b.linkToDeath(mDeathRecipient, 0);
864             } catch (RemoteException e) {
865             }
866         }
867
868         mImsService = IImsService.Stub.asInterface(b);
869     }
870
871     /**
872      * Creates a {@link ImsCallSession} with the specified call profile.
873      * Use other methods, if applicable, instead of interacting with
874      * {@link ImsCallSession} directly.
875      *
876      * @param serviceId a service id which is obtained from {@link ImsManager#open}
877      * @param profile a call profile to make the call
878      */
879     private ImsCallSession createCallSession(int serviceId,
880             ImsCallProfile profile) throws ImsException {
881         try {
882             return new ImsCallSession(mImsService.createCallSession(serviceId, profile, null));
883         } catch (RemoteException e) {
884             return null;
885         }
886     }
887
888     private ImsRegistrationListenerProxy createRegistrationListenerProxy(int serviceClass,
889             ImsConnectionStateListener listener) {
890         ImsRegistrationListenerProxy proxy =
891                 new ImsRegistrationListenerProxy(serviceClass, listener);
892         return proxy;
893     }
894
895     private static void log(String s) {
896         Rlog.d(TAG, s);
897     }
898
899     private static void loge(String s) {
900         Rlog.e(TAG, s);
901     }
902
903     private static void loge(String s, Throwable t) {
904         Rlog.e(TAG, s, t);
905     }
906
907     /**
908      * Used for turning on IMS.if its off already
909      */
910     private void turnOnIms() throws ImsException {
911         checkAndThrowExceptionIfServiceUnavailable();
912
913         try {
914             mImsService.turnOnIms(mPhoneId);
915         } catch (RemoteException e) {
916             throw new ImsException("turnOnIms() ", e, ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
917         }
918     }
919
920     private void setAdvanced4GMode(boolean turnOn) throws ImsException {
921         checkAndThrowExceptionIfServiceUnavailable();
922
923         ImsConfig config = getConfigInterface();
924         if (config != null) {
925             config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_LTE,
926                     TelephonyManager.NETWORK_TYPE_LTE, turnOn ? 1 : 0, null);
927             if (isVtEnabledByPlatform(mContext)) {
928                 // TODO: once VT is available on platform replace the '1' with the current
929                 // user configuration of VT.
930                 config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VIDEO_OVER_LTE,
931                         TelephonyManager.NETWORK_TYPE_LTE, turnOn ? 1 : 0, null);
932             }
933         }
934
935         if (turnOn) {
936             turnOnIms();
937         } else if (getBooleanCarrierConfig(mContext,
938                 CarrierConfigManager.KEY_CARRIER_ALLOW_TURNOFF_IMS_BOOL)
939                 && (!isWfcEnabledByPlatform(mContext)
940                 || !isWfcEnabledByUser(mContext))) {
941             log("setAdvanced4GMode() : imsServiceAllowTurnOff -> turnOffIms");
942             turnOffIms();
943         }
944     }
945
946     /**
947      * Used for turning off IMS completely in order to make the device CSFB'ed.
948      * Once turned off, all calls will be over CS.
949      */
950     private void turnOffIms() throws ImsException {
951         checkAndThrowExceptionIfServiceUnavailable();
952
953         try {
954             mImsService.turnOffIms(mPhoneId);
955         } catch (RemoteException e) {
956             throw new ImsException("turnOffIms() ", e, ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
957         }
958     }
959
960     /**
961      * Death recipient class for monitoring IMS service.
962      */
963     private class ImsServiceDeathRecipient implements IBinder.DeathRecipient {
964         @Override
965         public void binderDied() {
966             mImsService = null;
967             mUt = null;
968             mConfig = null;
969             mEcbm = null;
970
971             if (mContext != null) {
972                 Intent intent = new Intent(ACTION_IMS_SERVICE_DOWN);
973                 intent.putExtra(EXTRA_PHONE_ID, mPhoneId);
974                 mContext.sendBroadcast(new Intent(intent));
975             }
976         }
977     }
978
979     /**
980      * Adapter class for {@link IImsRegistrationListener}.
981      */
982     private class ImsRegistrationListenerProxy extends IImsRegistrationListener.Stub {
983         private int mServiceClass;
984         private ImsConnectionStateListener mListener;
985
986         public ImsRegistrationListenerProxy(int serviceClass,
987                 ImsConnectionStateListener listener) {
988             mServiceClass = serviceClass;
989             mListener = listener;
990         }
991
992         public boolean isSameProxy(int serviceClass) {
993             return (mServiceClass == serviceClass);
994         }
995
996         @Override
997         public void registrationConnected() {
998             if (DBG) {
999                 log("registrationConnected ::");
1000             }
1001
1002             if (mListener != null) {
1003                 mListener.onImsConnected();
1004             }
1005         }
1006
1007         @Override
1008         public void registrationProgressing() {
1009             if (DBG) {
1010                 log("registrationProgressing ::");
1011             }
1012
1013             if (mListener != null) {
1014                 mListener.onImsProgressing();
1015             }
1016         }
1017
1018         @Override
1019         public void registrationDisconnected(ImsReasonInfo imsReasonInfo) {
1020             if (DBG) {
1021                 log("registrationDisconnected :: imsReasonInfo" + imsReasonInfo);
1022             }
1023
1024             if (mListener != null) {
1025                 mListener.onImsDisconnected(imsReasonInfo);
1026             }
1027         }
1028
1029         @Override
1030         public void registrationResumed() {
1031             if (DBG) {
1032                 log("registrationResumed ::");
1033             }
1034
1035             if (mListener != null) {
1036                 mListener.onImsResumed();
1037             }
1038         }
1039
1040         @Override
1041         public void registrationSuspended() {
1042             if (DBG) {
1043                 log("registrationSuspended ::");
1044             }
1045
1046             if (mListener != null) {
1047                 mListener.onImsSuspended();
1048             }
1049         }
1050
1051         @Override
1052         public void registrationServiceCapabilityChanged(int serviceClass, int event) {
1053             log("registrationServiceCapabilityChanged :: serviceClass=" +
1054                     serviceClass + ", event=" + event);
1055
1056             if (mListener != null) {
1057                 mListener.onImsConnected();
1058             }
1059         }
1060
1061         @Override
1062         public void registrationFeatureCapabilityChanged(int serviceClass,
1063                 int[] enabledFeatures, int[] disabledFeatures) {
1064             log("registrationFeatureCapabilityChanged :: serviceClass=" +
1065                     serviceClass);
1066             if (mListener != null) {
1067                 mListener.onFeatureCapabilityChanged(serviceClass,
1068                         enabledFeatures, disabledFeatures);
1069             }
1070         }
1071
1072     }
1073     /**
1074      * Gets the ECBM interface to request ECBM exit.
1075      *
1076      * @param serviceId a service id which is obtained from {@link ImsManager#open}
1077      * @return the ECBM interface instance
1078      * @throws ImsException if getting the ECBM interface results in an error
1079      */
1080     public ImsEcbm getEcbmInterface(int serviceId) throws ImsException {
1081         if (mEcbm == null) {
1082             checkAndThrowExceptionIfServiceUnavailable();
1083
1084             try {
1085                 IImsEcbm iEcbm = mImsService.getEcbmInterface(serviceId);
1086
1087                 if (iEcbm == null) {
1088                     throw new ImsException("getEcbmInterface()",
1089                             ImsReasonInfo.CODE_ECBM_NOT_SUPPORTED);
1090                 }
1091                 mEcbm = new ImsEcbm(iEcbm);
1092             } catch (RemoteException e) {
1093                 throw new ImsException("getEcbmInterface()", e,
1094                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1095             }
1096         }
1097         return mEcbm;
1098     }
1099 }