Fix unncessary IMS re-registration with network
[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                 config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_WIFI,
310                         TelephonyManager.NETWORK_TYPE_IWLAN,
311                         enabled ? ImsConfig.FeatureValueConstants.ON
312                                 : ImsConfig.FeatureValueConstants.OFF, null);
313
314                 if (enabled) {
315                     imsManager.turnOnIms();
316                 } else if (getBooleanCarrierConfig(context,
317                         CarrierConfigManager.KEY_CARRIER_ALLOW_TURNOFF_IMS_BOOL)
318                         && (!isVolteEnabledByPlatform(context)
319                         || !isEnhanced4gLteModeSettingEnabledByUser(context))) {
320                     log("setWfcSetting() : imsServiceAllowTurnOff -> turnOffIms");
321                     imsManager.turnOffIms();
322                 }
323
324                 // Force IMS to register over LTE when turning off WFC
325                 setWfcModeInternal(context, enabled
326                         ? getWfcMode(context)
327                         : ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED);
328             } catch (ImsException e) {
329                 loge("setWfcSetting(): " + e);
330             }
331         }
332     }
333
334     /**
335      * Returns the user configuration of WFC modem setting
336      */
337     public static int getWfcMode(Context context) {
338         int setting = android.provider.Settings.Global.getInt(context.getContentResolver(),
339                 android.provider.Settings.Global.WFC_IMS_MODE,
340                 ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED);
341         if (DBG) log("getWfcMode - setting=" + setting);
342         return setting;
343     }
344
345     /**
346      * Returns the user configuration of WFC modem setting
347      */
348     public static void setWfcMode(Context context, int wfcMode) {
349         if (DBG) log("setWfcMode - setting=" + wfcMode);
350         android.provider.Settings.Global.putInt(context.getContentResolver(),
351                 android.provider.Settings.Global.WFC_IMS_MODE, wfcMode);
352
353         setWfcModeInternal(context, wfcMode);
354     }
355
356     private static void setWfcModeInternal(Context context, int wfcMode) {
357         final ImsManager imsManager = ImsManager.getInstance(context,
358                 SubscriptionManager.getDefaultVoicePhoneId());
359         if (imsManager != null) {
360             final int value = wfcMode;
361             QueuedWork.singleThreadExecutor().submit(new Runnable() {
362                 public void run() {
363                     try {
364                         imsManager.getConfigInterface().setProvisionedValue(
365                                 ImsConfig.ConfigConstants.VOICE_OVER_WIFI_MODE,
366                                 value);
367                     } catch (ImsException e) {
368                         // do nothing
369                     }
370                 }
371             });
372         }
373     }
374
375     /**
376      * Returns the user configuration of WFC roaming setting
377      */
378     public static boolean isWfcRoamingEnabledByUser(Context context) {
379         int enabled = android.provider.Settings.Global.getInt(context.getContentResolver(),
380                 android.provider.Settings.Global.WFC_IMS_ROAMING_ENABLED,
381                 ImsConfig.FeatureValueConstants.OFF);
382         return (enabled == 1) ? true : false;
383     }
384
385     /**
386      * Change persistent WFC roaming enabled setting
387      */
388     public static void setWfcRoamingSetting(Context context, boolean enabled) {
389         final int value = enabled
390                 ? ImsConfig.FeatureValueConstants.ON
391                 : ImsConfig.FeatureValueConstants.OFF;
392         android.provider.Settings.Global.putInt(context.getContentResolver(),
393                 android.provider.Settings.Global.WFC_IMS_ROAMING_ENABLED, value);
394
395         final ImsManager imsManager = ImsManager.getInstance(context,
396                 SubscriptionManager.getDefaultVoicePhoneId());
397         if (imsManager != null) {
398             QueuedWork.singleThreadExecutor().submit(new Runnable() {
399                 public void run() {
400                     try {
401                         imsManager.getConfigInterface().setProvisionedValue(
402                                 ImsConfig.ConfigConstants.VOICE_OVER_WIFI_ROAMING,
403                                 value);
404                     } catch (ImsException e) {
405                         // do nothing
406                     }
407                 }
408             });
409         }
410     }
411
412     /**
413      * Returns a platform configuration for WFC which may override the user
414      * setting. Note: WFC presumes that VoLTE is enabled (these are
415      * configuration settings which must be done correctly).
416      */
417     public static boolean isWfcEnabledByPlatform(Context context) {
418         if (SystemProperties.getInt(PROPERTY_DBG_WFC_AVAIL_OVERRIDE,
419                 PROPERTY_DBG_WFC_AVAIL_OVERRIDE_DEFAULT) == 1) {
420             return true;
421         }
422
423         return
424                context.getResources().getBoolean(
425                        com.android.internal.R.bool.config_device_wfc_ims_available) &&
426                getBooleanCarrierConfig(context,
427                        CarrierConfigManager.KEY_CARRIER_WFC_IMS_AVAILABLE_BOOL);
428     }
429
430     private ImsManager(Context context, int phoneId) {
431         mContext = context;
432         mPhoneId = phoneId;
433         createImsService(true);
434     }
435
436     /*
437      * Returns a flag indicating whether the IMS service is available.
438      */
439     public boolean isServiceAvailable() {
440         if (mImsService != null) {
441             return true;
442         }
443
444         IBinder binder = ServiceManager.checkService(getImsServiceName(mPhoneId));
445         if (binder != null) {
446             return true;
447         }
448
449         return false;
450     }
451
452     /**
453      * Opens the IMS service for making calls and/or receiving generic IMS calls.
454      * The caller may make subsquent calls through {@link #makeCall}.
455      * The IMS service will register the device to the operator's network with the credentials
456      * (from ISIM) periodically in order to receive calls from the operator's network.
457      * When the IMS service receives a new call, it will send out an intent with
458      * the provided action string.
459      * The intent contains a call ID extra {@link getCallId} and it can be used to take a call.
460      *
461      * @param serviceClass a service class specified in {@link ImsServiceClass}
462      *      For VoLTE service, it MUST be a {@link ImsServiceClass#MMTEL}.
463      * @param incomingCallPendingIntent When an incoming call is received,
464      *        the IMS service will call {@link PendingIntent#send(Context, int, Intent)} to
465      *        send back the intent to the caller with {@link #INCOMING_CALL_RESULT_CODE}
466      *        as the result code and the intent to fill in the call ID; It cannot be null
467      * @param listener To listen to IMS registration events; It cannot be null
468      * @return identifier (greater than 0) for the specified service
469      * @throws NullPointerException if {@code incomingCallPendingIntent}
470      *      or {@code listener} is null
471      * @throws ImsException if calling the IMS service results in an error
472      * @see #getCallId
473      * @see #getServiceId
474      */
475     public int open(int serviceClass, PendingIntent incomingCallPendingIntent,
476             ImsConnectionStateListener listener) throws ImsException {
477         checkAndThrowExceptionIfServiceUnavailable();
478
479         if (incomingCallPendingIntent == null) {
480             throw new NullPointerException("incomingCallPendingIntent can't be null");
481         }
482
483         if (listener == null) {
484             throw new NullPointerException("listener can't be null");
485         }
486
487         int result = 0;
488
489         try {
490             result = mImsService.open(mPhoneId, serviceClass, incomingCallPendingIntent,
491                     createRegistrationListenerProxy(serviceClass, listener));
492         } catch (RemoteException e) {
493             throw new ImsException("open()", e,
494                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
495         }
496
497         if (result <= 0) {
498             // If the return value is a minus value,
499             // it means that an error occurred in the service.
500             // So, it needs to convert to the reason code specified in ImsReasonInfo.
501             throw new ImsException("open()", (result * (-1)));
502         }
503
504         return result;
505     }
506
507     /**
508      * Closes the specified service ({@link ImsServiceClass}) not to make/receive calls.
509      * All the resources that were allocated to the service are also released.
510      *
511      * @param serviceId a service id to be closed which is obtained from {@link ImsManager#open}
512      * @throws ImsException if calling the IMS service results in an error
513      */
514     public void close(int serviceId) throws ImsException {
515         checkAndThrowExceptionIfServiceUnavailable();
516
517         try {
518             mImsService.close(serviceId);
519         } catch (RemoteException e) {
520             throw new ImsException("close()", e,
521                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
522         } finally {
523             mUt = null;
524             mConfig = null;
525             mEcbm = null;
526         }
527     }
528
529     /**
530      * Gets the configuration interface to provision / withdraw the supplementary service settings.
531      *
532      * @param serviceId a service id which is obtained from {@link ImsManager#open}
533      * @return the Ut interface instance
534      * @throws ImsException if getting the Ut interface results in an error
535      */
536     public ImsUtInterface getSupplementaryServiceConfiguration(int serviceId)
537             throws ImsException {
538         // FIXME: manage the multiple Ut interfaces based on the service id
539         if (mUt == null) {
540             checkAndThrowExceptionIfServiceUnavailable();
541
542             try {
543                 IImsUt iUt = mImsService.getUtInterface(serviceId);
544
545                 if (iUt == null) {
546                     throw new ImsException("getSupplementaryServiceConfiguration()",
547                             ImsReasonInfo.CODE_UT_NOT_SUPPORTED);
548                 }
549
550                 mUt = new ImsUt(iUt);
551             } catch (RemoteException e) {
552                 throw new ImsException("getSupplementaryServiceConfiguration()", e,
553                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
554             }
555         }
556
557         return mUt;
558     }
559
560     /**
561      * Checks if the IMS service has successfully registered to the IMS network
562      * with the specified service & call type.
563      *
564      * @param serviceId a service id which is obtained from {@link ImsManager#open}
565      * @param serviceType a service type that is specified in {@link ImsCallProfile}
566      *        {@link ImsCallProfile#SERVICE_TYPE_NORMAL}
567      *        {@link ImsCallProfile#SERVICE_TYPE_EMERGENCY}
568      * @param callType a call type that is specified in {@link ImsCallProfile}
569      *        {@link ImsCallProfile#CALL_TYPE_VOICE_N_VIDEO}
570      *        {@link ImsCallProfile#CALL_TYPE_VOICE}
571      *        {@link ImsCallProfile#CALL_TYPE_VT}
572      *        {@link ImsCallProfile#CALL_TYPE_VS}
573      * @return true if the specified service id is connected to the IMS network;
574      *        false otherwise
575      * @throws ImsException if calling the IMS service results in an error
576      */
577     public boolean isConnected(int serviceId, int serviceType, int callType)
578             throws ImsException {
579         checkAndThrowExceptionIfServiceUnavailable();
580
581         try {
582             return mImsService.isConnected(serviceId, serviceType, callType);
583         } catch (RemoteException e) {
584             throw new ImsException("isServiceConnected()", e,
585                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
586         }
587     }
588
589     /**
590      * Checks if the specified IMS service is opend.
591      *
592      * @param serviceId a service id which is obtained from {@link ImsManager#open}
593      * @return true if the specified service id is opened; false otherwise
594      * @throws ImsException if calling the IMS service results in an error
595      */
596     public boolean isOpened(int serviceId) throws ImsException {
597         checkAndThrowExceptionIfServiceUnavailable();
598
599         try {
600             return mImsService.isOpened(serviceId);
601         } catch (RemoteException e) {
602             throw new ImsException("isOpened()", e,
603                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
604         }
605     }
606
607     /**
608      * Creates a {@link ImsCallProfile} from the service capabilities & IMS registration state.
609      *
610      * @param serviceId a service id which is obtained from {@link ImsManager#open}
611      * @param serviceType a service type that is specified in {@link ImsCallProfile}
612      *        {@link ImsCallProfile#SERVICE_TYPE_NONE}
613      *        {@link ImsCallProfile#SERVICE_TYPE_NORMAL}
614      *        {@link ImsCallProfile#SERVICE_TYPE_EMERGENCY}
615      * @param callType a call type that is specified in {@link ImsCallProfile}
616      *        {@link ImsCallProfile#CALL_TYPE_VOICE}
617      *        {@link ImsCallProfile#CALL_TYPE_VT}
618      *        {@link ImsCallProfile#CALL_TYPE_VT_TX}
619      *        {@link ImsCallProfile#CALL_TYPE_VT_RX}
620      *        {@link ImsCallProfile#CALL_TYPE_VT_NODIR}
621      *        {@link ImsCallProfile#CALL_TYPE_VS}
622      *        {@link ImsCallProfile#CALL_TYPE_VS_TX}
623      *        {@link ImsCallProfile#CALL_TYPE_VS_RX}
624      * @return a {@link ImsCallProfile} object
625      * @throws ImsException if calling the IMS service results in an error
626      */
627     public ImsCallProfile createCallProfile(int serviceId,
628             int serviceType, int callType) throws ImsException {
629         checkAndThrowExceptionIfServiceUnavailable();
630
631         try {
632             return mImsService.createCallProfile(serviceId, serviceType, callType);
633         } catch (RemoteException e) {
634             throw new ImsException("createCallProfile()", e,
635                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
636         }
637     }
638
639     /**
640      * Creates a {@link ImsCall} to make a call.
641      *
642      * @param serviceId a service id which is obtained from {@link ImsManager#open}
643      * @param profile a call profile to make the call
644      *      (it contains service type, call type, media information, etc.)
645      * @param participants participants to invite the conference call
646      * @param listener listen to the call events from {@link ImsCall}
647      * @return a {@link ImsCall} object
648      * @throws ImsException if calling the IMS service results in an error
649      */
650     public ImsCall makeCall(int serviceId, ImsCallProfile profile, String[] callees,
651             ImsCall.Listener listener) throws ImsException {
652         if (DBG) {
653             log("makeCall :: serviceId=" + serviceId
654                     + ", profile=" + profile + ", callees=" + callees);
655         }
656
657         checkAndThrowExceptionIfServiceUnavailable();
658
659         ImsCall call = new ImsCall(mContext, profile);
660
661         call.setListener(listener);
662         ImsCallSession session = createCallSession(serviceId, profile);
663
664         if ((callees != null) && (callees.length == 1)) {
665             call.start(session, callees[0]);
666         } else {
667             call.start(session, callees);
668         }
669
670         return call;
671     }
672
673     /**
674      * Creates a {@link ImsCall} to take an incoming call.
675      *
676      * @param serviceId a service id which is obtained from {@link ImsManager#open}
677      * @param incomingCallIntent the incoming call broadcast intent
678      * @param listener to listen to the call events from {@link ImsCall}
679      * @return a {@link ImsCall} object
680      * @throws ImsException if calling the IMS service results in an error
681      */
682     public ImsCall takeCall(int serviceId, Intent incomingCallIntent,
683             ImsCall.Listener listener) throws ImsException {
684         if (DBG) {
685             log("takeCall :: serviceId=" + serviceId
686                     + ", incomingCall=" + incomingCallIntent);
687         }
688
689         checkAndThrowExceptionIfServiceUnavailable();
690
691         if (incomingCallIntent == null) {
692             throw new ImsException("Can't retrieve session with null intent",
693                     ImsReasonInfo.CODE_LOCAL_ILLEGAL_ARGUMENT);
694         }
695
696         int incomingServiceId = getServiceId(incomingCallIntent);
697
698         if (serviceId != incomingServiceId) {
699             throw new ImsException("Service id is mismatched in the incoming call intent",
700                     ImsReasonInfo.CODE_LOCAL_ILLEGAL_ARGUMENT);
701         }
702
703         String callId = getCallId(incomingCallIntent);
704
705         if (callId == null) {
706             throw new ImsException("Call ID missing in the incoming call intent",
707                     ImsReasonInfo.CODE_LOCAL_ILLEGAL_ARGUMENT);
708         }
709
710         try {
711             IImsCallSession session = mImsService.getPendingCallSession(serviceId, callId);
712
713             if (session == null) {
714                 throw new ImsException("No pending session for the call",
715                         ImsReasonInfo.CODE_LOCAL_NO_PENDING_CALL);
716             }
717
718             ImsCall call = new ImsCall(mContext, session.getCallProfile());
719
720             call.attachSession(new ImsCallSession(session));
721             call.setListener(listener);
722
723             return call;
724         } catch (Throwable t) {
725             throw new ImsException("takeCall()", t, ImsReasonInfo.CODE_UNSPECIFIED);
726         }
727     }
728
729     /**
730      * Gets the config interface to get/set service/capability parameters.
731      *
732      * @return the ImsConfig instance.
733      * @throws ImsException if getting the setting interface results in an error.
734      */
735     public ImsConfig getConfigInterface() throws ImsException {
736
737         if (mConfig == null) {
738             checkAndThrowExceptionIfServiceUnavailable();
739
740             try {
741                 IImsConfig config = mImsService.getConfigInterface(mPhoneId);
742                 if (config == null) {
743                     throw new ImsException("getConfigInterface()",
744                             ImsReasonInfo.CODE_LOCAL_SERVICE_UNAVAILABLE);
745                 }
746                 mConfig = new ImsConfig(config, mContext);
747             } catch (RemoteException e) {
748                 throw new ImsException("getConfigInterface()", e,
749                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
750             }
751         }
752         if (DBG) log("getConfigInterface(), mConfig= " + mConfig);
753         return mConfig;
754     }
755
756     public void setUiTTYMode(Context context, int serviceId, int uiTtyMode, Message onComplete)
757             throws ImsException {
758
759         checkAndThrowExceptionIfServiceUnavailable();
760
761         try {
762             mImsService.setUiTTYMode(serviceId, uiTtyMode, onComplete);
763         } catch (RemoteException e) {
764             throw new ImsException("setTTYMode()", e,
765                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
766         }
767
768         if (!getBooleanCarrierConfig(context,
769                 CarrierConfigManager.KEY_CARRIER_VOLTE_TTY_SUPPORTED_BOOL)) {
770             setAdvanced4GMode((uiTtyMode == TelecomManager.TTY_MODE_OFF) &&
771                     isEnhanced4gLteModeSettingEnabledByUser(context));
772         }
773     }
774
775     /**
776      * Get the boolean config from carrier config manager.
777      *
778      * @param context the context to get carrier service
779      * @param key config key defined in CarrierConfigManager
780      * @return boolean value of corresponding key.
781      */
782     private static boolean getBooleanCarrierConfig(Context context, String key) {
783         CarrierConfigManager configManager = (CarrierConfigManager) context.getSystemService(
784                 Context.CARRIER_CONFIG_SERVICE);
785         PersistableBundle b = null;
786         if (configManager != null) {
787             b = configManager.getConfig();
788         }
789         if (b != null) {
790             return b.getBoolean(key);
791         } else {
792             // Return static default defined in CarrierConfigManager.
793             return CarrierConfigManager.getDefaultConfig().getBoolean(key);
794         }
795     }
796
797     /**
798      * Gets the call ID from the specified incoming call broadcast intent.
799      *
800      * @param incomingCallIntent the incoming call broadcast intent
801      * @return the call ID or null if the intent does not contain it
802      */
803     private static String getCallId(Intent incomingCallIntent) {
804         if (incomingCallIntent == null) {
805             return null;
806         }
807
808         return incomingCallIntent.getStringExtra(EXTRA_CALL_ID);
809     }
810
811     /**
812      * Gets the service type from the specified incoming call broadcast intent.
813      *
814      * @param incomingCallIntent the incoming call broadcast intent
815      * @return the service identifier or -1 if the intent does not contain it
816      */
817     private static int getServiceId(Intent incomingCallIntent) {
818         if (incomingCallIntent == null) {
819             return (-1);
820         }
821
822         return incomingCallIntent.getIntExtra(EXTRA_SERVICE_ID, -1);
823     }
824
825     /**
826      * Binds the IMS service only if the service is not created.
827      */
828     private void checkAndThrowExceptionIfServiceUnavailable()
829             throws ImsException {
830         if (mImsService == null) {
831             createImsService(true);
832
833             if (mImsService == null) {
834                 throw new ImsException("Service is unavailable",
835                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
836             }
837         }
838     }
839
840     private static String getImsServiceName(int phoneId) {
841         // TODO: MSIM implementation needs to decide on service name as a function of phoneId
842         return IMS_SERVICE;
843     }
844
845     /**
846      * Binds the IMS service to make/receive the call.
847      */
848     private void createImsService(boolean checkService) {
849         if (checkService) {
850             IBinder binder = ServiceManager.checkService(getImsServiceName(mPhoneId));
851
852             if (binder == null) {
853                 return;
854             }
855         }
856
857         IBinder b = ServiceManager.getService(getImsServiceName(mPhoneId));
858
859         if (b != null) {
860             try {
861                 b.linkToDeath(mDeathRecipient, 0);
862             } catch (RemoteException e) {
863             }
864         }
865
866         mImsService = IImsService.Stub.asInterface(b);
867     }
868
869     /**
870      * Creates a {@link ImsCallSession} with the specified call profile.
871      * Use other methods, if applicable, instead of interacting with
872      * {@link ImsCallSession} directly.
873      *
874      * @param serviceId a service id which is obtained from {@link ImsManager#open}
875      * @param profile a call profile to make the call
876      */
877     private ImsCallSession createCallSession(int serviceId,
878             ImsCallProfile profile) throws ImsException {
879         try {
880             return new ImsCallSession(mImsService.createCallSession(serviceId, profile, null));
881         } catch (RemoteException e) {
882             return null;
883         }
884     }
885
886     private ImsRegistrationListenerProxy createRegistrationListenerProxy(int serviceClass,
887             ImsConnectionStateListener listener) {
888         ImsRegistrationListenerProxy proxy =
889                 new ImsRegistrationListenerProxy(serviceClass, listener);
890         return proxy;
891     }
892
893     private static void log(String s) {
894         Rlog.d(TAG, s);
895     }
896
897     private static void loge(String s) {
898         Rlog.e(TAG, s);
899     }
900
901     private static void loge(String s, Throwable t) {
902         Rlog.e(TAG, s, t);
903     }
904
905     /**
906      * Used for turning on IMS.if its off already
907      */
908     private void turnOnIms() throws ImsException {
909         checkAndThrowExceptionIfServiceUnavailable();
910
911         try {
912             mImsService.turnOnIms(mPhoneId);
913         } catch (RemoteException e) {
914             throw new ImsException("turnOnIms() ", e, ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
915         }
916     }
917
918     private boolean isImsTurnOffAllowed() {
919         return getBooleanCarrierConfig(mContext,
920                 CarrierConfigManager.KEY_CARRIER_ALLOW_TURNOFF_IMS_BOOL)
921                 && (!isWfcEnabledByPlatform(mContext)
922                 || !isWfcEnabledByUser(mContext));
923     }
924
925     private void setAdvanced4GMode(boolean turnOn) throws ImsException {
926         checkAndThrowExceptionIfServiceUnavailable();
927
928         try {
929             ImsConfig config = getConfigInterface();
930             if (config != null && (turnOn || !isImsTurnOffAllowed())) {
931                 config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_LTE,
932                         TelephonyManager.NETWORK_TYPE_LTE, turnOn ? 1 : 0, null);
933                 if (isVtEnabledByPlatform(mContext)) {
934                     // TODO: once VT is available on platform:
935                     // - replace the '1' with the current user configuration of VT.
936                     // - separate exception checks for setFeatureValue() failures for VoLTE and VT.
937                     //   I.e. if VoLTE fails still try to configure VT.
938                     config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VIDEO_OVER_LTE,
939                             TelephonyManager.NETWORK_TYPE_LTE, turnOn ? 1 : 0, null);
940                 }
941             }
942         } catch (ImsException e) {
943             log("setAdvanced4GMode() : " + e);
944         }
945         if (turnOn) {
946             turnOnIms();
947         } else if (isImsTurnOffAllowed()) {
948             log("setAdvanced4GMode() : imsServiceAllowTurnOff -> turnOffIms");
949             turnOffIms();
950         }
951     }
952
953     /**
954      * Used for turning off IMS completely in order to make the device CSFB'ed.
955      * Once turned off, all calls will be over CS.
956      */
957     private void turnOffIms() throws ImsException {
958         checkAndThrowExceptionIfServiceUnavailable();
959
960         try {
961             mImsService.turnOffIms(mPhoneId);
962         } catch (RemoteException e) {
963             throw new ImsException("turnOffIms() ", e, ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
964         }
965     }
966
967     /**
968      * Death recipient class for monitoring IMS service.
969      */
970     private class ImsServiceDeathRecipient implements IBinder.DeathRecipient {
971         @Override
972         public void binderDied() {
973             mImsService = null;
974             mUt = null;
975             mConfig = null;
976             mEcbm = null;
977
978             if (mContext != null) {
979                 Intent intent = new Intent(ACTION_IMS_SERVICE_DOWN);
980                 intent.putExtra(EXTRA_PHONE_ID, mPhoneId);
981                 mContext.sendBroadcast(new Intent(intent));
982             }
983         }
984     }
985
986     /**
987      * Adapter class for {@link IImsRegistrationListener}.
988      */
989     private class ImsRegistrationListenerProxy extends IImsRegistrationListener.Stub {
990         private int mServiceClass;
991         private ImsConnectionStateListener mListener;
992
993         public ImsRegistrationListenerProxy(int serviceClass,
994                 ImsConnectionStateListener listener) {
995             mServiceClass = serviceClass;
996             mListener = listener;
997         }
998
999         public boolean isSameProxy(int serviceClass) {
1000             return (mServiceClass == serviceClass);
1001         }
1002
1003         @Override
1004         public void registrationConnected() {
1005             if (DBG) {
1006                 log("registrationConnected ::");
1007             }
1008
1009             if (mListener != null) {
1010                 mListener.onImsConnected();
1011             }
1012         }
1013
1014         @Override
1015         public void registrationProgressing() {
1016             if (DBG) {
1017                 log("registrationProgressing ::");
1018             }
1019
1020             if (mListener != null) {
1021                 mListener.onImsProgressing();
1022             }
1023         }
1024
1025         @Override
1026         public void registrationDisconnected(ImsReasonInfo imsReasonInfo) {
1027             if (DBG) {
1028                 log("registrationDisconnected :: imsReasonInfo" + imsReasonInfo);
1029             }
1030
1031             if (mListener != null) {
1032                 mListener.onImsDisconnected(imsReasonInfo);
1033             }
1034         }
1035
1036         @Override
1037         public void registrationResumed() {
1038             if (DBG) {
1039                 log("registrationResumed ::");
1040             }
1041
1042             if (mListener != null) {
1043                 mListener.onImsResumed();
1044             }
1045         }
1046
1047         @Override
1048         public void registrationSuspended() {
1049             if (DBG) {
1050                 log("registrationSuspended ::");
1051             }
1052
1053             if (mListener != null) {
1054                 mListener.onImsSuspended();
1055             }
1056         }
1057
1058         @Override
1059         public void registrationServiceCapabilityChanged(int serviceClass, int event) {
1060             log("registrationServiceCapabilityChanged :: serviceClass=" +
1061                     serviceClass + ", event=" + event);
1062
1063             if (mListener != null) {
1064                 mListener.onImsConnected();
1065             }
1066         }
1067
1068         @Override
1069         public void registrationFeatureCapabilityChanged(int serviceClass,
1070                 int[] enabledFeatures, int[] disabledFeatures) {
1071             log("registrationFeatureCapabilityChanged :: serviceClass=" +
1072                     serviceClass);
1073             if (mListener != null) {
1074                 mListener.onFeatureCapabilityChanged(serviceClass,
1075                         enabledFeatures, disabledFeatures);
1076             }
1077         }
1078
1079     }
1080     /**
1081      * Gets the ECBM interface to request ECBM exit.
1082      *
1083      * @param serviceId a service id which is obtained from {@link ImsManager#open}
1084      * @return the ECBM interface instance
1085      * @throws ImsException if getting the ECBM interface results in an error
1086      */
1087     public ImsEcbm getEcbmInterface(int serviceId) throws ImsException {
1088         if (mEcbm == null) {
1089             checkAndThrowExceptionIfServiceUnavailable();
1090
1091             try {
1092                 IImsEcbm iEcbm = mImsService.getEcbmInterface(serviceId);
1093
1094                 if (iEcbm == null) {
1095                     throw new ImsException("getEcbmInterface()",
1096                             ImsReasonInfo.CODE_ECBM_NOT_SUPPORTED);
1097                 }
1098                 mEcbm = new ImsEcbm(iEcbm);
1099             } catch (RemoteException e) {
1100                 throw new ImsException("getEcbmInterface()", e,
1101                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1102             }
1103         }
1104         return mEcbm;
1105     }
1106 }