Remove Session Id from ImsService APIs that do not need it. am: b5f30c7854 am: 8dcc70a6a7
[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.content.Context;
21 import android.content.Intent;
22 import android.net.Uri;
23 import android.os.AsyncTask;
24 import android.os.IBinder;
25 import android.os.Message;
26 import android.os.Parcel;
27 import android.os.PersistableBundle;
28 import android.os.RemoteException;
29 import android.os.ServiceManager;
30 import android.os.SystemProperties;
31 import android.provider.Settings;
32 import android.telecom.TelecomManager;
33 import android.telephony.CarrierConfigManager;
34 import android.telephony.Rlog;
35 import android.telephony.ServiceState;
36 import android.telephony.SubscriptionManager;
37 import android.telephony.TelephonyManager;
38 import android.telephony.ims.ImsServiceProxy;
39 import android.telephony.ims.ImsServiceProxyCompat;
40 import android.telephony.ims.feature.ImsFeature;
41
42 import com.android.ims.internal.IImsCallSession;
43 import com.android.ims.internal.IImsConfig;
44 import com.android.ims.internal.IImsEcbm;
45 import com.android.ims.internal.IImsMultiEndpoint;
46 import com.android.ims.internal.IImsRegistrationListener;
47 import com.android.ims.internal.IImsServiceController;
48 import com.android.ims.internal.IImsUt;
49 import com.android.ims.internal.ImsCallSession;
50 import com.android.ims.internal.IImsConfig;
51 import com.android.internal.annotations.VisibleForTesting;
52
53 import java.io.FileDescriptor;
54 import java.io.PrintWriter;
55 import java.util.ArrayList;
56 import java.util.HashMap;
57 import java.util.concurrent.ConcurrentLinkedDeque;
58 import java.util.HashSet;
59 import java.util.Optional;
60 import java.util.Set;
61
62 /**
63  * Provides APIs for IMS services, such as initiating IMS calls, and provides access to
64  * the operator's IMS network. This class is the starting point for any IMS actions.
65  * You can acquire an instance of it with {@link #getInstance getInstance()}.</p>
66  * <p>The APIs in this class allows you to:</p>
67  *
68  * @hide
69  */
70 public class ImsManager {
71
72     /*
73      * Debug flag to override configuration flag
74      */
75     public static final String PROPERTY_DBG_VOLTE_AVAIL_OVERRIDE = "persist.dbg.volte_avail_ovr";
76     public static final int PROPERTY_DBG_VOLTE_AVAIL_OVERRIDE_DEFAULT = 0;
77     public static final String PROPERTY_DBG_VT_AVAIL_OVERRIDE = "persist.dbg.vt_avail_ovr";
78     public static final int PROPERTY_DBG_VT_AVAIL_OVERRIDE_DEFAULT = 0;
79     public static final String PROPERTY_DBG_WFC_AVAIL_OVERRIDE = "persist.dbg.wfc_avail_ovr";
80     public static final int PROPERTY_DBG_WFC_AVAIL_OVERRIDE_DEFAULT = 0;
81     public static final String PROPERTY_DBG_ALLOW_IMS_OFF_OVERRIDE = "persist.dbg.allow_ims_off";
82     public static final int PROPERTY_DBG_ALLOW_IMS_OFF_OVERRIDE_DEFAULT = 0;
83
84     /**
85      * For accessing the IMS related service.
86      * Internal use only.
87      * @hide
88      */
89     private static final String IMS_SERVICE = "ims";
90
91     /**
92      * The result code to be sent back with the incoming call {@link PendingIntent}.
93      * @see #open(PendingIntent, ImsConnectionStateListener)
94      */
95     public static final int INCOMING_CALL_RESULT_CODE = 101;
96
97     /**
98      * Key to retrieve the call ID from an incoming call intent.
99      * @see #open(PendingIntent, ImsConnectionStateListener)
100      */
101     public static final String EXTRA_CALL_ID = "android:imsCallID";
102
103     /**
104      * Action to broadcast when ImsService is up.
105      * Internal use only.
106      * @deprecated
107      * @hide
108      */
109     public static final String ACTION_IMS_SERVICE_UP =
110             "com.android.ims.IMS_SERVICE_UP";
111
112     /**
113      * Action to broadcast when ImsService is down.
114      * Internal use only.
115      * @deprecated
116      * @hide
117      */
118     public static final String ACTION_IMS_SERVICE_DOWN =
119             "com.android.ims.IMS_SERVICE_DOWN";
120
121     /**
122      * Action to broadcast when ImsService registration fails.
123      * Internal use only.
124      * @hide
125      */
126     public static final String ACTION_IMS_REGISTRATION_ERROR =
127             "com.android.ims.REGISTRATION_ERROR";
128
129     /**
130      * Part of the ACTION_IMS_SERVICE_UP or _DOWN intents.
131      * A long value; the phone ID corresponding to the IMS service coming up or down.
132      * Internal use only.
133      * @hide
134      */
135     public static final String EXTRA_PHONE_ID = "android:phone_id";
136
137     /**
138      * Action for the incoming call intent for the Phone app.
139      * Internal use only.
140      * @hide
141      */
142     public static final String ACTION_IMS_INCOMING_CALL =
143             "com.android.ims.IMS_INCOMING_CALL";
144
145     /**
146      * Part of the ACTION_IMS_INCOMING_CALL intents.
147      * An integer value; service identifier obtained from {@link ImsManager#open}.
148      * Internal use only.
149      * @hide
150      */
151     public static final String EXTRA_SERVICE_ID = "android:imsServiceId";
152
153     /**
154      * Part of the ACTION_IMS_INCOMING_CALL intents.
155      * An boolean value; Flag to indicate that the incoming call is a normal call or call for USSD.
156      * The value "true" indicates that the incoming call is for USSD.
157      * Internal use only.
158      * @hide
159      */
160     public static final String EXTRA_USSD = "android:ussd";
161
162     /**
163      * Part of the ACTION_IMS_INCOMING_CALL intents.
164      * A boolean value; Flag to indicate whether the call is an unknown
165      * dialing call. Such calls are originated by sending commands (like
166      * AT commands) directly to modem without Android involvement.
167      * Even though they are not incoming calls, they are propagated
168      * to Phone app using same ACTION_IMS_INCOMING_CALL intent.
169      * Internal use only.
170      * @hide
171      */
172     public static final String EXTRA_IS_UNKNOWN_CALL = "android:isUnknown";
173
174     private static final String TAG = "ImsManager";
175     private static final boolean DBG = true;
176
177     private static HashMap<Integer, ImsManager> sImsManagerInstances =
178             new HashMap<Integer, ImsManager>();
179
180     private Context mContext;
181     private int mPhoneId;
182     private final boolean mConfigDynamicBind;
183     private ImsServiceProxyCompat mImsServiceProxy = null;
184     private ImsServiceDeathRecipient mDeathRecipient = new ImsServiceDeathRecipient();
185     // Ut interface for the supplementary service configuration
186     private ImsUt mUt = null;
187     // Interface to get/set ims config items
188     private ImsConfig mConfig = null;
189     private boolean mConfigUpdated = false;
190
191     private ImsConfigListener mImsConfigListener;
192
193     // ECBM interface
194     private ImsEcbm mEcbm = null;
195
196     private ImsMultiEndpoint mMultiEndpoint = null;
197
198     private Set<ImsServiceProxy.INotifyStatusChanged> mStatusCallbacks = new HashSet<>();
199
200     // Keep track of the ImsRegistrationListenerProxys that have been created so that we can
201     // remove them from the ImsService.
202     private Set<ImsRegistrationListenerProxy> mRegistrationListeners = new HashSet<>();
203
204     // SystemProperties used as cache
205     private static final String VOLTE_PROVISIONED_PROP = "net.lte.ims.volte.provisioned";
206     private static final String WFC_PROVISIONED_PROP = "net.lte.ims.wfc.provisioned";
207     private static final String VT_PROVISIONED_PROP = "net.lte.ims.vt.provisioned";
208     // Flag indicating data enabled or not. This flag should be in sync with
209     // DcTracker.isDataEnabled(). The flag will be set later during boot up.
210     private static final String DATA_ENABLED_PROP = "net.lte.ims.data.enabled";
211
212     public static final String TRUE = "true";
213     public static final String FALSE = "false";
214
215     // mRecentDisconnectReasons stores the last 16 disconnect reasons
216     private static final int MAX_RECENT_DISCONNECT_REASONS = 16;
217     private ConcurrentLinkedDeque<ImsReasonInfo> mRecentDisconnectReasons =
218             new ConcurrentLinkedDeque<>();
219
220     /**
221      * Gets a manager instance.
222      *
223      * @param context application context for creating the manager object
224      * @param phoneId the phone ID for the IMS Service
225      * @return the manager instance corresponding to the phoneId
226      */
227     public static ImsManager getInstance(Context context, int phoneId) {
228         synchronized (sImsManagerInstances) {
229             if (sImsManagerInstances.containsKey(phoneId)) {
230                 return sImsManagerInstances.get(phoneId);
231             }
232
233             ImsManager mgr = new ImsManager(context, phoneId);
234             sImsManagerInstances.put(phoneId, mgr);
235
236             return mgr;
237         }
238     }
239
240     /**
241      * Returns the user configuration of Enhanced 4G LTE Mode setting
242      */
243     public static boolean isEnhanced4gLteModeSettingEnabledByUser(Context context) {
244         // If user can't edit Enhanced 4G LTE Mode, it assumes Enhanced 4G LTE Mode is always true.
245         // If user changes SIM from editable mode to uneditable mode, need to return true.
246         if (!getBooleanCarrierConfig(context,
247                     CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL)) {
248             return true;
249         }
250         int enabled = android.provider.Settings.Global.getInt(
251                     context.getContentResolver(),
252                     android.provider.Settings.Global.ENHANCED_4G_MODE_ENABLED, ImsConfig.FeatureValueConstants.ON);
253         return (enabled == 1) ? true : false;
254     }
255
256     /**
257      * Change persistent Enhanced 4G LTE Mode setting
258      */
259     public static void setEnhanced4gLteModeSetting(Context context, boolean enabled) {
260         int value = enabled ? 1 : 0;
261         android.provider.Settings.Global.putInt(
262                 context.getContentResolver(),
263                 android.provider.Settings.Global.ENHANCED_4G_MODE_ENABLED, value);
264
265         if (isNonTtyOrTtyOnVolteEnabled(context)) {
266             ImsManager imsManager = ImsManager.getInstance(context,
267                     SubscriptionManager.getDefaultVoicePhoneId());
268             if (imsManager != null) {
269                 try {
270                     imsManager.setAdvanced4GMode(enabled);
271                 } catch (ImsException ie) {
272                     // do nothing
273                 }
274             }
275         }
276     }
277
278     /**
279      * Indicates whether the call is non-TTY or if TTY - whether TTY on VoLTE is
280      * supported.
281      */
282     public static boolean isNonTtyOrTtyOnVolteEnabled(Context context) {
283         if (getBooleanCarrierConfig(context,
284                 CarrierConfigManager.KEY_CARRIER_VOLTE_TTY_SUPPORTED_BOOL)) {
285             return true;
286         }
287
288         return Settings.Secure.getInt(context.getContentResolver(),
289                 Settings.Secure.PREFERRED_TTY_MODE, TelecomManager.TTY_MODE_OFF)
290                 == TelecomManager.TTY_MODE_OFF;
291     }
292
293     /**
294      * Returns a platform configuration for VoLTE which may override the user setting.
295      */
296     public static boolean isVolteEnabledByPlatform(Context context) {
297         if (SystemProperties.getInt(PROPERTY_DBG_VOLTE_AVAIL_OVERRIDE,
298                 PROPERTY_DBG_VOLTE_AVAIL_OVERRIDE_DEFAULT) == 1) {
299             return true;
300         }
301
302         return context.getResources().getBoolean(
303                 com.android.internal.R.bool.config_device_volte_available)
304                 && getBooleanCarrierConfig(context,
305                         CarrierConfigManager.KEY_CARRIER_VOLTE_AVAILABLE_BOOL)
306                 && isGbaValid(context);
307     }
308
309     /**
310      * Indicates whether VoLTE is provisioned on device
311      */
312     public static boolean isVolteProvisionedOnDevice(Context context) {
313         if (getBooleanCarrierConfig(context,
314                     CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL)) {
315             ImsManager mgr = ImsManager.getInstance(context,
316                     SubscriptionManager.getDefaultVoicePhoneId());
317             if (mgr != null) {
318                 return mgr.isVolteProvisioned();
319             }
320         }
321
322         return true;
323     }
324
325     /**
326      * Indicates whether VoWifi is provisioned on device
327      */
328     public static boolean isWfcProvisionedOnDevice(Context context) {
329         if (getBooleanCarrierConfig(context,
330                 CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL)) {
331             ImsManager mgr = ImsManager.getInstance(context,
332                     SubscriptionManager.getDefaultVoicePhoneId());
333             if (mgr != null) {
334                 return mgr.isWfcProvisioned();
335             }
336         }
337
338         return true;
339     }
340
341     /**
342      * Indicates whether VT is provisioned on device
343      */
344     public static boolean isVtProvisionedOnDevice(Context context) {
345         if (getBooleanCarrierConfig(context,
346                 CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL)) {
347             ImsManager mgr = ImsManager.getInstance(context,
348                     SubscriptionManager.getDefaultVoicePhoneId());
349             if (mgr != null) {
350                 return mgr.isVtProvisioned();
351             }
352         }
353
354         return true;
355     }
356
357     /**
358      * Returns a platform configuration for VT which may override the user setting.
359      *
360      * Note: VT presumes that VoLTE is enabled (these are configuration settings
361      * which must be done correctly).
362      */
363     public static boolean isVtEnabledByPlatform(Context context) {
364         if (SystemProperties.getInt(PROPERTY_DBG_VT_AVAIL_OVERRIDE,
365                 PROPERTY_DBG_VT_AVAIL_OVERRIDE_DEFAULT) == 1) {
366             return true;
367         }
368
369         return
370                 context.getResources().getBoolean(
371                         com.android.internal.R.bool.config_device_vt_available) &&
372                 getBooleanCarrierConfig(context,
373                         CarrierConfigManager.KEY_CARRIER_VT_AVAILABLE_BOOL) &&
374                 isGbaValid(context);
375     }
376
377     /**
378      * Returns the user configuration of VT setting
379      */
380     public static boolean isVtEnabledByUser(Context context) {
381         int enabled = android.provider.Settings.Global.getInt(context.getContentResolver(),
382                 android.provider.Settings.Global.VT_IMS_ENABLED,
383                 ImsConfig.FeatureValueConstants.ON);
384         return (enabled == 1) ? true : false;
385     }
386
387     /**
388      * Change persistent VT enabled setting
389      */
390     public static void setVtSetting(Context context, boolean enabled) {
391         int value = enabled ? 1 : 0;
392         android.provider.Settings.Global.putInt(context.getContentResolver(),
393                 android.provider.Settings.Global.VT_IMS_ENABLED, value);
394
395         ImsManager imsManager = ImsManager.getInstance(context,
396                 SubscriptionManager.getDefaultVoicePhoneId());
397         if (imsManager != null) {
398             try {
399                 ImsConfig config = imsManager.getConfigInterface();
400                 config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VIDEO_OVER_LTE,
401                         TelephonyManager.NETWORK_TYPE_LTE,
402                         enabled ? ImsConfig.FeatureValueConstants.ON
403                                 : ImsConfig.FeatureValueConstants.OFF,
404                         imsManager.mImsConfigListener);
405
406                 if (enabled) {
407                     log("setVtSetting() : turnOnIms");
408                     imsManager.turnOnIms();
409                 } else if (isTurnOffImsAllowedByPlatform(context)
410                         && (!isVolteEnabledByPlatform(context)
411                         || !isEnhanced4gLteModeSettingEnabledByUser(context))) {
412                     log("setVtSetting() : imsServiceAllowTurnOff -> turnOffIms");
413                     imsManager.turnOffIms();
414                 }
415             } catch (ImsException e) {
416                 loge("setVtSetting(): ", e);
417             }
418         }
419     }
420
421     /*
422      * Returns whether turning off ims is allowed by platform.
423      * The platform property may override the carrier config.
424      */
425     private static boolean isTurnOffImsAllowedByPlatform(Context context) {
426         if (SystemProperties.getInt(PROPERTY_DBG_ALLOW_IMS_OFF_OVERRIDE,
427                 PROPERTY_DBG_ALLOW_IMS_OFF_OVERRIDE_DEFAULT) == 1) {
428             return true;
429         }
430         return getBooleanCarrierConfig(context,
431                 CarrierConfigManager.KEY_CARRIER_ALLOW_TURNOFF_IMS_BOOL);
432     }
433
434     /**
435      * Returns the user configuration of WFC setting
436      */
437     public static boolean isWfcEnabledByUser(Context context) {
438         int enabled = android.provider.Settings.Global.getInt(context.getContentResolver(),
439                 android.provider.Settings.Global.WFC_IMS_ENABLED,
440                 getBooleanCarrierConfig(context,
441                         CarrierConfigManager.KEY_CARRIER_DEFAULT_WFC_IMS_ENABLED_BOOL) ?
442                         ImsConfig.FeatureValueConstants.ON : ImsConfig.FeatureValueConstants.OFF);
443         return (enabled == 1) ? true : false;
444     }
445
446     /**
447      * Change persistent WFC enabled setting
448      */
449     public static void setWfcSetting(Context context, boolean enabled) {
450         int value = enabled ? 1 : 0;
451         android.provider.Settings.Global.putInt(context.getContentResolver(),
452                 android.provider.Settings.Global.WFC_IMS_ENABLED, value);
453
454         ImsManager imsManager = ImsManager.getInstance(context,
455                 SubscriptionManager.getDefaultVoicePhoneId());
456         if (imsManager != null) {
457             try {
458                 ImsConfig config = imsManager.getConfigInterface();
459                 config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_WIFI,
460                         TelephonyManager.NETWORK_TYPE_IWLAN,
461                         enabled ? ImsConfig.FeatureValueConstants.ON
462                                 : ImsConfig.FeatureValueConstants.OFF,
463                         imsManager.mImsConfigListener);
464
465                 if (enabled) {
466                     log("setWfcSetting() : turnOnIms");
467                     imsManager.turnOnIms();
468                 } else if (isTurnOffImsAllowedByPlatform(context)
469                         && (!isVolteEnabledByPlatform(context)
470                         || !isEnhanced4gLteModeSettingEnabledByUser(context))) {
471                     log("setWfcSetting() : imsServiceAllowTurnOff -> turnOffIms");
472                     imsManager.turnOffIms();
473                 }
474
475                 TelephonyManager tm = (TelephonyManager) context
476                         .getSystemService(Context.TELEPHONY_SERVICE);
477                 setWfcModeInternal(context, enabled
478                         // Choose wfc mode per current roaming preference
479                         ? getWfcMode(context, tm.isNetworkRoaming())
480                         // Force IMS to register over LTE when turning off WFC
481                         : ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED);
482             } catch (ImsException e) {
483                 loge("setWfcSetting(): ", e);
484             }
485         }
486     }
487
488     /**
489      * Returns the user configuration of WFC preference setting
490      */
491     public static int getWfcMode(Context context) {
492         int setting = android.provider.Settings.Global.getInt(context.getContentResolver(),
493                 android.provider.Settings.Global.WFC_IMS_MODE, getIntCarrierConfig(context,
494                         CarrierConfigManager.KEY_CARRIER_DEFAULT_WFC_IMS_MODE_INT));
495         if (DBG) log("getWfcMode - setting=" + setting);
496         return setting;
497     }
498
499     /**
500      * Change persistent WFC preference setting
501      */
502     public static void setWfcMode(Context context, int wfcMode) {
503         if (DBG) log("setWfcMode - setting=" + wfcMode);
504         android.provider.Settings.Global.putInt(context.getContentResolver(),
505                 android.provider.Settings.Global.WFC_IMS_MODE, wfcMode);
506
507         setWfcModeInternal(context, wfcMode);
508     }
509
510     /**
511      * Returns the user configuration of WFC preference setting
512      *
513      * @param roaming {@code false} for home network setting, {@code true} for roaming  setting
514      */
515     public static int getWfcMode(Context context, boolean roaming) {
516         int setting = 0;
517         if (!roaming) {
518             setting = android.provider.Settings.Global.getInt(context.getContentResolver(),
519                     android.provider.Settings.Global.WFC_IMS_MODE, getIntCarrierConfig(context,
520                             CarrierConfigManager.KEY_CARRIER_DEFAULT_WFC_IMS_MODE_INT));
521             if (DBG) log("getWfcMode - setting=" + setting);
522         } else {
523             setting = android.provider.Settings.Global.getInt(context.getContentResolver(),
524                     android.provider.Settings.Global.WFC_IMS_ROAMING_MODE,
525                     getIntCarrierConfig(context,
526                             CarrierConfigManager.KEY_CARRIER_DEFAULT_WFC_IMS_ROAMING_MODE_INT));
527             if (DBG) log("getWfcMode (roaming) - setting=" + setting);
528         }
529         return setting;
530     }
531
532     /**
533      * Change persistent WFC preference setting
534      *
535      * @param roaming {@code false} for home network setting, {@code true} for roaming setting
536      */
537     public static void setWfcMode(Context context, int wfcMode, boolean roaming) {
538         if (!roaming) {
539             if (DBG) log("setWfcMode - setting=" + wfcMode);
540             android.provider.Settings.Global.putInt(context.getContentResolver(),
541                     android.provider.Settings.Global.WFC_IMS_MODE, wfcMode);
542         } else {
543             if (DBG) log("setWfcMode (roaming) - setting=" + wfcMode);
544             android.provider.Settings.Global.putInt(context.getContentResolver(),
545                     android.provider.Settings.Global.WFC_IMS_ROAMING_MODE, wfcMode);
546         }
547
548         TelephonyManager tm = (TelephonyManager)
549                 context.getSystemService(Context.TELEPHONY_SERVICE);
550         if (roaming == tm.isNetworkRoaming()) {
551             setWfcModeInternal(context, wfcMode);
552         }
553     }
554
555     private static void setWfcModeInternal(Context context, int wfcMode) {
556         final ImsManager imsManager = ImsManager.getInstance(context,
557                 SubscriptionManager.getDefaultVoicePhoneId());
558         if (imsManager != null) {
559             final int value = wfcMode;
560             Thread thread = new Thread(new Runnable() {
561                 public void run() {
562                     try {
563                         imsManager.getConfigInterface().setProvisionedValue(
564                                 ImsConfig.ConfigConstants.VOICE_OVER_WIFI_MODE,
565                                 value);
566                     } catch (ImsException e) {
567                         // do nothing
568                     }
569                 }
570             });
571             thread.start();
572         }
573     }
574
575     /**
576      * Returns the user configuration of WFC roaming setting
577      */
578     public static boolean isWfcRoamingEnabledByUser(Context context) {
579         int enabled = android.provider.Settings.Global.getInt(context.getContentResolver(),
580                 android.provider.Settings.Global.WFC_IMS_ROAMING_ENABLED,
581                 getBooleanCarrierConfig(context,
582                         CarrierConfigManager.KEY_CARRIER_DEFAULT_WFC_IMS_ROAMING_ENABLED_BOOL) ?
583                         ImsConfig.FeatureValueConstants.ON : ImsConfig.FeatureValueConstants.OFF);
584         return (enabled == 1) ? true : false;
585     }
586
587     /**
588      * Change persistent WFC roaming enabled setting
589      */
590     public static void setWfcRoamingSetting(Context context, boolean enabled) {
591         android.provider.Settings.Global.putInt(context.getContentResolver(),
592                 android.provider.Settings.Global.WFC_IMS_ROAMING_ENABLED,
593                 enabled ? ImsConfig.FeatureValueConstants.ON
594                         : ImsConfig.FeatureValueConstants.OFF);
595
596         setWfcRoamingSettingInternal(context, enabled);
597     }
598
599     private static void setWfcRoamingSettingInternal(Context context, boolean enabled) {
600         final ImsManager imsManager = ImsManager.getInstance(context,
601                 SubscriptionManager.getDefaultVoicePhoneId());
602         if (imsManager != null) {
603             final int value = enabled
604                     ? ImsConfig.FeatureValueConstants.ON
605                     : ImsConfig.FeatureValueConstants.OFF;
606             Thread thread = new Thread(new Runnable() {
607                 public void run() {
608                     try {
609                         imsManager.getConfigInterface().setProvisionedValue(
610                                 ImsConfig.ConfigConstants.VOICE_OVER_WIFI_ROAMING,
611                                 value);
612                     } catch (ImsException e) {
613                         // do nothing
614                     }
615                 }
616             });
617             thread.start();
618         }
619     }
620
621     /**
622      * Returns a platform configuration for WFC which may override the user
623      * setting. Note: WFC presumes that VoLTE is enabled (these are
624      * configuration settings which must be done correctly).
625      */
626     public static boolean isWfcEnabledByPlatform(Context context) {
627         if (SystemProperties.getInt(PROPERTY_DBG_WFC_AVAIL_OVERRIDE,
628                 PROPERTY_DBG_WFC_AVAIL_OVERRIDE_DEFAULT) == 1) {
629             return true;
630         }
631
632         return
633                context.getResources().getBoolean(
634                        com.android.internal.R.bool.config_device_wfc_ims_available) &&
635                getBooleanCarrierConfig(context,
636                        CarrierConfigManager.KEY_CARRIER_WFC_IMS_AVAILABLE_BOOL) &&
637                isGbaValid(context);
638     }
639
640     /**
641      * If carrier requires that IMS is only available if GBA capable SIM is used,
642      * then this function checks GBA bit in EF IST.
643      *
644      * Format of EF IST is defined in 3GPP TS 31.103 (Section 4.2.7).
645      */
646     private static boolean isGbaValid(Context context) {
647         if (getBooleanCarrierConfig(context,
648                 CarrierConfigManager.KEY_CARRIER_IMS_GBA_REQUIRED_BOOL)) {
649             final TelephonyManager telephonyManager = TelephonyManager.getDefault();
650             String efIst = telephonyManager.getIsimIst();
651             if (efIst == null) {
652                 loge("ISF is NULL");
653                 return true;
654             }
655             boolean result = efIst != null && efIst.length() > 1 &&
656                     (0x02 & (byte)efIst.charAt(1)) != 0;
657             if (DBG) log("GBA capable=" + result + ", ISF=" + efIst);
658             return result;
659         }
660         return true;
661     }
662
663     /**
664      * This function should be called when ImsConfig.ACTION_IMS_CONFIG_CHANGED is received.
665      *
666      * We cannot register receiver in ImsManager because this would lead to resource leak.
667      * ImsManager can be created in different processes and it is not notified when that process
668      * is about to be terminated.
669      *
670      * @hide
671      * */
672     public static void onProvisionedValueChanged(Context context, int item, String value) {
673         if (DBG) Rlog.d(TAG, "onProvisionedValueChanged: item=" + item + " val=" + value);
674         ImsManager mgr = ImsManager.getInstance(context,
675                 SubscriptionManager.getDefaultVoicePhoneId());
676
677         switch (item) {
678             case ImsConfig.ConfigConstants.VLT_SETTING_ENABLED:
679                 mgr.setVolteProvisionedProperty(value.equals("1"));
680                 if (DBG) Rlog.d(TAG,"isVoLteProvisioned = " + mgr.isVolteProvisioned());
681                 break;
682
683             case ImsConfig.ConfigConstants.VOICE_OVER_WIFI_SETTING_ENABLED:
684                 mgr.setWfcProvisionedProperty(value.equals("1"));
685                 if (DBG) Rlog.d(TAG,"isWfcProvisioned = " + mgr.isWfcProvisioned());
686                 break;
687
688             case ImsConfig.ConfigConstants.LVC_SETTING_ENABLED:
689                 mgr.setVtProvisionedProperty(value.equals("1"));
690                 if (DBG) Rlog.d(TAG,"isVtProvisioned = " + mgr.isVtProvisioned());
691                 break;
692
693         }
694     }
695
696     private class AsyncUpdateProvisionedValues extends AsyncTask<Void, Void, Void> {
697         @Override
698         protected Void doInBackground(Void... params) {
699             // disable on any error
700             setVolteProvisionedProperty(false);
701             setWfcProvisionedProperty(false);
702             setVtProvisionedProperty(false);
703
704             try {
705                 ImsConfig config = getConfigInterface();
706                 if (config != null) {
707                     setVolteProvisionedProperty(getProvisionedBool(config,
708                             ImsConfig.ConfigConstants.VLT_SETTING_ENABLED));
709                     if (DBG) Rlog.d(TAG, "isVoLteProvisioned = " + isVolteProvisioned());
710
711                     setWfcProvisionedProperty(getProvisionedBool(config,
712                             ImsConfig.ConfigConstants.VOICE_OVER_WIFI_SETTING_ENABLED));
713                     if (DBG) Rlog.d(TAG, "isWfcProvisioned = " + isWfcProvisioned());
714
715                     setVtProvisionedProperty(getProvisionedBool(config,
716                             ImsConfig.ConfigConstants.LVC_SETTING_ENABLED));
717                     if (DBG) Rlog.d(TAG, "isVtProvisioned = " + isVtProvisioned());
718
719                 }
720             } catch (ImsException ie) {
721                 Rlog.e(TAG, "AsyncUpdateProvisionedValues error: ", ie);
722             }
723
724             return null;
725         }
726
727         private boolean getProvisionedBool(ImsConfig config, int item) throws ImsException {
728             return config.getProvisionedValue(item) == ImsConfig.FeatureValueConstants.ON;
729         }
730     }
731
732     /** Asynchronously get VoLTE, WFC, VT provisioning statuses */
733     private void updateProvisionedValues() {
734         if (getBooleanCarrierConfig(mContext,
735                 CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL)) {
736
737             new AsyncUpdateProvisionedValues().execute();
738         }
739     }
740
741     /**
742      * Sync carrier config and user settings with ImsConfig.
743      *
744      * @param context for the manager object
745      * @param phoneId phone id
746      * @param force update
747      */
748     public static void updateImsServiceConfig(Context context, int phoneId, boolean force) {
749         if (!force) {
750             if (TelephonyManager.getDefault().getSimState() != TelephonyManager.SIM_STATE_READY) {
751                 log("updateImsServiceConfig: SIM not ready");
752                 // Don't disable IMS if SIM is not ready
753                 return;
754             }
755         }
756
757         final ImsManager imsManager = ImsManager.getInstance(context, phoneId);
758         if (imsManager != null && (!imsManager.mConfigUpdated || force)) {
759             try {
760                 imsManager.updateProvisionedValues();
761
762                 // TODO: Extend ImsConfig API and set all feature values in single function call.
763
764                 // Note: currently the order of updates is set to produce different order of
765                 // setFeatureValue() function calls from setAdvanced4GMode(). This is done to
766                 // differentiate this code path from vendor code perspective.
767                 boolean isImsUsed = imsManager.updateVolteFeatureValue();
768                 isImsUsed |= imsManager.updateWfcFeatureAndProvisionedValues();
769                 isImsUsed |= imsManager.updateVideoCallFeatureValue();
770
771                 if (isImsUsed || !isTurnOffImsAllowedByPlatform(context)) {
772                     // Turn on IMS if it is used.
773                     // Also, if turning off is not allowed for current carrier,
774                     // we need to turn IMS on because it might be turned off before
775                     // phone switched to current carrier.
776                     log("updateImsServiceConfig: turnOnIms");
777                     imsManager.turnOnIms();
778                 } else {
779                     // Turn off IMS if it is not used AND turning off is allowed for carrier.
780                     log("updateImsServiceConfig: turnOffIms");
781                     imsManager.turnOffIms();
782                 }
783
784                 imsManager.mConfigUpdated = true;
785             } catch (ImsException e) {
786                 loge("updateImsServiceConfig: ", e);
787                 imsManager.mConfigUpdated = false;
788             }
789         }
790     }
791
792     /**
793      * Update VoLTE config
794      * @return whether feature is On
795      * @throws ImsException
796      */
797     private boolean updateVolteFeatureValue() throws ImsException {
798         boolean available = isVolteEnabledByPlatform(mContext);
799         boolean enabled = isEnhanced4gLteModeSettingEnabledByUser(mContext);
800         boolean isNonTty = isNonTtyOrTtyOnVolteEnabled(mContext);
801         boolean isFeatureOn = available && enabled && isNonTty;
802
803         log("updateVolteFeatureValue: available = " + available
804                 + ", enabled = " + enabled
805                 + ", nonTTY = " + isNonTty);
806
807         getConfigInterface().setFeatureValue(
808                 ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_LTE,
809                 TelephonyManager.NETWORK_TYPE_LTE,
810                 isFeatureOn ?
811                         ImsConfig.FeatureValueConstants.ON :
812                         ImsConfig.FeatureValueConstants.OFF,
813                 mImsConfigListener);
814
815         return isFeatureOn;
816     }
817
818     /**
819      * Update video call over LTE config
820      * @return whether feature is On
821      * @throws ImsException
822      */
823     private boolean updateVideoCallFeatureValue() throws ImsException {
824         boolean available = isVtEnabledByPlatform(mContext);
825         boolean enabled = isVtEnabledByUser(mContext);
826         boolean isNonTty = isNonTtyOrTtyOnVolteEnabled(mContext);
827         boolean isDataEnabled = isDataEnabled();
828         boolean ignoreDataEnabledChanged = getBooleanCarrierConfig(mContext,
829                 CarrierConfigManager.KEY_IGNORE_DATA_ENABLED_CHANGED_FOR_VIDEO_CALLS);
830
831         boolean isFeatureOn = available && enabled && isNonTty
832                 && (ignoreDataEnabledChanged || isDataEnabled);
833
834         log("updateVideoCallFeatureValue: available = " + available
835                 + ", enabled = " + enabled
836                 + ", nonTTY = " + isNonTty
837                 + ", data enabled = " + isDataEnabled);
838
839         getConfigInterface().setFeatureValue(
840                 ImsConfig.FeatureConstants.FEATURE_TYPE_VIDEO_OVER_LTE,
841                 TelephonyManager.NETWORK_TYPE_LTE,
842                 isFeatureOn ?
843                         ImsConfig.FeatureValueConstants.ON :
844                         ImsConfig.FeatureValueConstants.OFF,
845                 mImsConfigListener);
846
847         return isFeatureOn;
848     }
849
850     /**
851      * Update WFC config
852      * @return whether feature is On
853      * @throws ImsException
854      */
855     private boolean updateWfcFeatureAndProvisionedValues() throws ImsException {
856         boolean isNetworkRoaming = TelephonyManager.getDefault().isNetworkRoaming();
857         boolean available = isWfcEnabledByPlatform(mContext);
858         boolean enabled = isWfcEnabledByUser(mContext);
859         int mode = getWfcMode(mContext, isNetworkRoaming);
860         boolean roaming = isWfcRoamingEnabledByUser(mContext);
861         boolean isFeatureOn = available && enabled;
862
863         log("updateWfcFeatureAndProvisionedValues: available = " + available
864                 + ", enabled = " + enabled
865                 + ", mode = " + mode
866                 + ", roaming = " + roaming);
867
868         getConfigInterface().setFeatureValue(
869                 ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_WIFI,
870                 TelephonyManager.NETWORK_TYPE_IWLAN,
871                 isFeatureOn ?
872                         ImsConfig.FeatureValueConstants.ON :
873                         ImsConfig.FeatureValueConstants.OFF,
874                 mImsConfigListener);
875
876         if (!isFeatureOn) {
877             mode = ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED;
878             roaming = false;
879         }
880         setWfcModeInternal(mContext, mode);
881         setWfcRoamingSettingInternal(mContext, roaming);
882
883         return isFeatureOn;
884     }
885
886     /**
887      * Do NOT use this directly, instead use {@link #getInstance}.
888      */
889     @VisibleForTesting
890     public ImsManager(Context context, int phoneId) {
891         mContext = context;
892         mPhoneId = phoneId;
893         mConfigDynamicBind = mContext.getResources().getBoolean(
894                 com.android.internal.R.bool.config_dynamic_bind_ims);
895         addNotifyStatusChangedCallback(this::sendImsServiceIntent);
896         createImsService();
897     }
898
899     /**
900      * Provide backwards compatibility using deprecated service UP/DOWN intents.
901      */
902     private void sendImsServiceIntent() {
903         int status = mImsServiceProxy.getFeatureStatus();
904         Intent intent;
905         switch (status) {
906             case ImsFeature.STATE_NOT_AVAILABLE:
907             case ImsFeature.STATE_INITIALIZING:
908                 intent = new Intent(ACTION_IMS_SERVICE_DOWN);
909                 break;
910             case ImsFeature.STATE_READY:
911                 intent = new Intent(ACTION_IMS_SERVICE_UP);
912                 break;
913             default:
914                 intent = new Intent(ACTION_IMS_SERVICE_DOWN);
915         }
916         intent.putExtra(EXTRA_PHONE_ID, mPhoneId);
917         mContext.sendBroadcast(new Intent(intent));
918     }
919
920
921     /**
922      * @return Whether or not ImsManager is configured to Dynamically bind or not to support legacy
923      * devices.
924      */
925     public boolean isDynamicBinding() {
926         return mConfigDynamicBind;
927     }
928
929     /*
930      * Returns a flag indicating whether the IMS service is available.
931      */
932     public boolean isServiceAvailable() {
933         if (mImsServiceProxy == null) {
934             createImsService();
935         }
936         // mImsServiceProxy will always create an ImsServiceProxy.
937         return mImsServiceProxy.isBinderAlive();
938     }
939
940     public void setImsConfigListener(ImsConfigListener listener) {
941         mImsConfigListener = listener;
942     }
943
944     public void addNotifyStatusChangedCallback(ImsServiceProxy.INotifyStatusChanged c) {
945         if (c != null) {
946             mStatusCallbacks.add(c);
947         }
948     }
949
950     /**
951      * Opens the IMS service for making calls and/or receiving generic IMS calls.
952      * The caller may make subsquent calls through {@link #makeCall}.
953      * The IMS service will register the device to the operator's network with the credentials
954      * (from ISIM) periodically in order to receive calls from the operator's network.
955      * When the IMS service receives a new call, it will send out an intent with
956      * the provided action string.
957      * The intent contains a call ID extra {@link getCallId} and it can be used to take a call.
958      *
959      * @param serviceClass a service class specified in {@link ImsServiceClass}
960      *      For VoLTE service, it MUST be a {@link ImsServiceClass#MMTEL}.
961      * @param incomingCallPendingIntent When an incoming call is received,
962      *        the IMS service will call {@link PendingIntent#send(Context, int, Intent)} to
963      *        send back the intent to the caller with {@link #INCOMING_CALL_RESULT_CODE}
964      *        as the result code and the intent to fill in the call ID; It cannot be null
965      * @param listener To listen to IMS registration events; It cannot be null
966      * @return identifier (greater than 0) for the specified service
967      * @throws NullPointerException if {@code incomingCallPendingIntent}
968      *      or {@code listener} is null
969      * @throws ImsException if calling the IMS service results in an error
970      * @see #getCallId
971      * @see #getImsSessionId
972      */
973     public int open(int serviceClass, PendingIntent incomingCallPendingIntent,
974             ImsConnectionStateListener listener) throws ImsException {
975         checkAndThrowExceptionIfServiceUnavailable();
976
977         if (incomingCallPendingIntent == null) {
978             throw new NullPointerException("incomingCallPendingIntent can't be null");
979         }
980
981         if (listener == null) {
982             throw new NullPointerException("listener can't be null");
983         }
984
985         int result = 0;
986
987         try {
988             result = mImsServiceProxy.startSession(incomingCallPendingIntent,
989                     createRegistrationListenerProxy(serviceClass, listener));
990         } catch (RemoteException e) {
991             throw new ImsException("open()", e,
992                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
993         }
994
995         if (result <= 0) {
996             // If the return value is a minus value,
997             // it means that an error occurred in the service.
998             // So, it needs to convert to the reason code specified in ImsReasonInfo.
999             throw new ImsException("open()", (result * (-1)));
1000         }
1001
1002         return result;
1003     }
1004
1005     /**
1006      * Adds registration listener to the IMS service.
1007      *
1008      * @param serviceClass a service class specified in {@link ImsServiceClass}
1009      *      For VoLTE service, it MUST be a {@link ImsServiceClass#MMTEL}.
1010      * @param listener To listen to IMS registration events; It cannot be null
1011      * @throws NullPointerException if {@code listener} is null
1012      * @throws ImsException if calling the IMS service results in an error
1013      */
1014     public void addRegistrationListener(int serviceClass, ImsConnectionStateListener listener)
1015             throws ImsException {
1016         checkAndThrowExceptionIfServiceUnavailable();
1017
1018         if (listener == null) {
1019             throw new NullPointerException("listener can't be null");
1020         }
1021
1022         try {
1023             ImsRegistrationListenerProxy p = createRegistrationListenerProxy(serviceClass,
1024                     listener);
1025             mRegistrationListeners.add(p);
1026             mImsServiceProxy.addRegistrationListener(p);
1027         } catch (RemoteException e) {
1028             throw new ImsException("addRegistrationListener()", e,
1029                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1030         }
1031     }
1032
1033     /**
1034      * Removes the registration listener from the IMS service.
1035      *
1036      * @param listener Previously registered listener that will be removed. Can not be null.
1037      * @throws NullPointerException if {@code listener} is null
1038      * @throws ImsException if calling the IMS service results in an error
1039      * instead.
1040      */
1041     public void removeRegistrationListener(ImsConnectionStateListener listener)
1042             throws ImsException {
1043         checkAndThrowExceptionIfServiceUnavailable();
1044
1045         if (listener == null) {
1046             throw new NullPointerException("listener can't be null");
1047         }
1048
1049         try {
1050             Optional<ImsRegistrationListenerProxy> optionalProxy = mRegistrationListeners.stream()
1051                     .filter(l -> listener.equals(l.mListener)).findFirst();
1052             if(optionalProxy.isPresent()) {
1053                 ImsRegistrationListenerProxy p = optionalProxy.get();
1054                 mRegistrationListeners.remove(p);
1055                 mImsServiceProxy.removeRegistrationListener(p);
1056             }
1057         } catch (RemoteException e) {
1058             throw new ImsException("removeRegistrationListener()", e,
1059                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1060         }
1061     }
1062
1063     /**
1064      * Closes the specified service ({@link ImsServiceClass}) not to make/receive calls.
1065      * All the resources that were allocated to the service are also released.
1066      *
1067      * @param sessionId a session id to be closed which is obtained from {@link ImsManager#open}
1068      * @throws ImsException if calling the IMS service results in an error
1069      */
1070     public void close(int sessionId) throws ImsException {
1071         checkAndThrowExceptionIfServiceUnavailable();
1072
1073         try {
1074             mImsServiceProxy.endSession(sessionId);
1075         } catch (RemoteException e) {
1076             throw new ImsException("close()", e,
1077                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1078         } finally {
1079             mUt = null;
1080             mConfig = null;
1081             mEcbm = null;
1082             mMultiEndpoint = null;
1083         }
1084     }
1085
1086     /**
1087      * Gets the configuration interface to provision / withdraw the supplementary service settings.
1088      *
1089      * @return the Ut interface instance
1090      * @throws ImsException if getting the Ut interface results in an error
1091      */
1092     public ImsUtInterface getSupplementaryServiceConfiguration()
1093             throws ImsException {
1094         // FIXME: manage the multiple Ut interfaces based on the session id
1095         if (mUt == null || !mImsServiceProxy.isBinderAlive()) {
1096             checkAndThrowExceptionIfServiceUnavailable();
1097
1098             try {
1099                 IImsUt iUt = mImsServiceProxy.getUtInterface();
1100
1101                 if (iUt == null) {
1102                     throw new ImsException("getSupplementaryServiceConfiguration()",
1103                             ImsReasonInfo.CODE_UT_NOT_SUPPORTED);
1104                 }
1105
1106                 mUt = new ImsUt(iUt);
1107             } catch (RemoteException e) {
1108                 throw new ImsException("getSupplementaryServiceConfiguration()", e,
1109                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1110             }
1111         }
1112
1113         return mUt;
1114     }
1115
1116     /**
1117      * Checks if the IMS service has successfully registered to the IMS network
1118      * with the specified service & call type.
1119      *
1120      * @param serviceType a service type that is specified in {@link ImsCallProfile}
1121      *        {@link ImsCallProfile#SERVICE_TYPE_NORMAL}
1122      *        {@link ImsCallProfile#SERVICE_TYPE_EMERGENCY}
1123      * @param callType a call type that is specified in {@link ImsCallProfile}
1124      *        {@link ImsCallProfile#CALL_TYPE_VOICE_N_VIDEO}
1125      *        {@link ImsCallProfile#CALL_TYPE_VOICE}
1126      *        {@link ImsCallProfile#CALL_TYPE_VT}
1127      *        {@link ImsCallProfile#CALL_TYPE_VS}
1128      * @return true if the specified service id is connected to the IMS network;
1129      *        false otherwise
1130      * @throws ImsException if calling the IMS service results in an error
1131      */
1132     public boolean isConnected(int serviceType, int callType)
1133             throws ImsException {
1134         checkAndThrowExceptionIfServiceUnavailable();
1135
1136         try {
1137             return mImsServiceProxy.isConnected(serviceType, callType);
1138         } catch (RemoteException e) {
1139             throw new ImsException("isServiceConnected()", e,
1140                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1141         }
1142     }
1143
1144     /**
1145      * Checks if the specified IMS service is opend.
1146      *
1147      * @return true if the specified service id is opened; false otherwise
1148      * @throws ImsException if calling the IMS service results in an error
1149      */
1150     public boolean isOpened() throws ImsException {
1151         checkAndThrowExceptionIfServiceUnavailable();
1152
1153         try {
1154             return mImsServiceProxy.isOpened();
1155         } catch (RemoteException e) {
1156             throw new ImsException("isOpened()", e,
1157                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1158         }
1159     }
1160
1161     /**
1162      * Creates a {@link ImsCallProfile} from the service capabilities & IMS registration state.
1163      *
1164      * @param sessionId a session id which is obtained from {@link ImsManager#open}
1165      * @param serviceType a service type that is specified in {@link ImsCallProfile}
1166      *        {@link ImsCallProfile#SERVICE_TYPE_NONE}
1167      *        {@link ImsCallProfile#SERVICE_TYPE_NORMAL}
1168      *        {@link ImsCallProfile#SERVICE_TYPE_EMERGENCY}
1169      * @param callType a call type that is specified in {@link ImsCallProfile}
1170      *        {@link ImsCallProfile#CALL_TYPE_VOICE}
1171      *        {@link ImsCallProfile#CALL_TYPE_VT}
1172      *        {@link ImsCallProfile#CALL_TYPE_VT_TX}
1173      *        {@link ImsCallProfile#CALL_TYPE_VT_RX}
1174      *        {@link ImsCallProfile#CALL_TYPE_VT_NODIR}
1175      *        {@link ImsCallProfile#CALL_TYPE_VS}
1176      *        {@link ImsCallProfile#CALL_TYPE_VS_TX}
1177      *        {@link ImsCallProfile#CALL_TYPE_VS_RX}
1178      * @return a {@link ImsCallProfile} object
1179      * @throws ImsException if calling the IMS service results in an error
1180      */
1181     public ImsCallProfile createCallProfile(int sessionId, int serviceType, int callType)
1182             throws ImsException {
1183         checkAndThrowExceptionIfServiceUnavailable();
1184
1185         try {
1186             return mImsServiceProxy.createCallProfile(sessionId, serviceType, callType);
1187         } catch (RemoteException e) {
1188             throw new ImsException("createCallProfile()", e,
1189                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1190         }
1191     }
1192
1193     /**
1194      * Creates a {@link ImsCall} to make a call.
1195      *
1196      * @param sessionId a session id which is obtained from {@link ImsManager#open}
1197      * @param profile a call profile to make the call
1198      *      (it contains service type, call type, media information, etc.)
1199      * @param participants participants to invite the conference call
1200      * @param listener listen to the call events from {@link ImsCall}
1201      * @return a {@link ImsCall} object
1202      * @throws ImsException if calling the IMS service results in an error
1203      */
1204     public ImsCall makeCall(int sessionId, ImsCallProfile profile, String[] callees,
1205             ImsCall.Listener listener) throws ImsException {
1206         if (DBG) {
1207             log("makeCall :: sessionId=" + sessionId
1208                     + ", profile=" + profile);
1209         }
1210
1211         checkAndThrowExceptionIfServiceUnavailable();
1212
1213         ImsCall call = new ImsCall(mContext, profile);
1214
1215         call.setListener(listener);
1216         ImsCallSession session = createCallSession(sessionId, profile);
1217
1218         if ((callees != null) && (callees.length == 1)) {
1219             call.start(session, callees[0]);
1220         } else {
1221             call.start(session, callees);
1222         }
1223
1224         return call;
1225     }
1226
1227     /**
1228      * Creates a {@link ImsCall} to take an incoming call.
1229      *
1230      * @param sessionId a session id which is obtained from {@link ImsManager#open}
1231      * @param incomingCallIntent the incoming call broadcast intent
1232      * @param listener to listen to the call events from {@link ImsCall}
1233      * @return a {@link ImsCall} object
1234      * @throws ImsException if calling the IMS service results in an error
1235      */
1236     public ImsCall takeCall(int sessionId, Intent incomingCallIntent,
1237             ImsCall.Listener listener) throws ImsException {
1238         if (DBG) {
1239             log("takeCall :: sessionId=" + sessionId
1240                     + ", incomingCall=" + incomingCallIntent);
1241         }
1242
1243         checkAndThrowExceptionIfServiceUnavailable();
1244
1245         if (incomingCallIntent == null) {
1246             throw new ImsException("Can't retrieve session with null intent",
1247                     ImsReasonInfo.CODE_LOCAL_ILLEGAL_ARGUMENT);
1248         }
1249
1250         int incomingServiceId = getImsSessionId(incomingCallIntent);
1251
1252         if (sessionId != incomingServiceId) {
1253             throw new ImsException("Service id is mismatched in the incoming call intent",
1254                     ImsReasonInfo.CODE_LOCAL_ILLEGAL_ARGUMENT);
1255         }
1256
1257         String callId = getCallId(incomingCallIntent);
1258
1259         if (callId == null) {
1260             throw new ImsException("Call ID missing in the incoming call intent",
1261                     ImsReasonInfo.CODE_LOCAL_ILLEGAL_ARGUMENT);
1262         }
1263
1264         try {
1265             IImsCallSession session = mImsServiceProxy.getPendingCallSession(sessionId, callId);
1266
1267             if (session == null) {
1268                 throw new ImsException("No pending session for the call",
1269                         ImsReasonInfo.CODE_LOCAL_NO_PENDING_CALL);
1270             }
1271
1272             ImsCall call = new ImsCall(mContext, session.getCallProfile());
1273
1274             call.attachSession(new ImsCallSession(session));
1275             call.setListener(listener);
1276
1277             return call;
1278         } catch (Throwable t) {
1279             throw new ImsException("takeCall()", t, ImsReasonInfo.CODE_UNSPECIFIED);
1280         }
1281     }
1282
1283     /**
1284      * Gets the config interface to get/set service/capability parameters.
1285      *
1286      * @return the ImsConfig instance.
1287      * @throws ImsException if getting the setting interface results in an error.
1288      */
1289     public ImsConfig getConfigInterface() throws ImsException {
1290
1291         if (mConfig == null || !mImsServiceProxy.isBinderAlive()) {
1292             checkAndThrowExceptionIfServiceUnavailable();
1293
1294             try {
1295                 IImsConfig config = mImsServiceProxy.getConfigInterface();
1296                 if (config == null) {
1297                     throw new ImsException("getConfigInterface()",
1298                             ImsReasonInfo.CODE_LOCAL_SERVICE_UNAVAILABLE);
1299                 }
1300                 mConfig = new ImsConfig(config, mContext);
1301             } catch (RemoteException e) {
1302                 throw new ImsException("getConfigInterface()", e,
1303                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1304             }
1305         }
1306         if (DBG) log("getConfigInterface(), mConfig= " + mConfig);
1307         return mConfig;
1308     }
1309
1310     public void setUiTTYMode(Context context, int uiTtyMode, Message onComplete)
1311             throws ImsException {
1312
1313         checkAndThrowExceptionIfServiceUnavailable();
1314
1315         try {
1316             mImsServiceProxy.setUiTTYMode(uiTtyMode, onComplete);
1317         } catch (RemoteException e) {
1318             throw new ImsException("setTTYMode()", e,
1319                     ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1320         }
1321
1322         if (!getBooleanCarrierConfig(context,
1323                 CarrierConfigManager.KEY_CARRIER_VOLTE_TTY_SUPPORTED_BOOL)) {
1324             setAdvanced4GMode((uiTtyMode == TelecomManager.TTY_MODE_OFF) &&
1325                     isEnhanced4gLteModeSettingEnabledByUser(context));
1326         }
1327     }
1328
1329     private ImsReasonInfo makeACopy(ImsReasonInfo imsReasonInfo) {
1330         Parcel p = Parcel.obtain();
1331         imsReasonInfo.writeToParcel(p, 0);
1332         p.setDataPosition(0);
1333         ImsReasonInfo clonedReasonInfo = ImsReasonInfo.CREATOR.createFromParcel(p);
1334         p.recycle();
1335         return clonedReasonInfo;
1336     }
1337
1338     /**
1339      * Get Recent IMS Disconnect Reasons.
1340      *
1341      * @return ArrayList of ImsReasonInfo objects. MAX size of the arraylist
1342      * is MAX_RECENT_DISCONNECT_REASONS. The objects are in the
1343      * chronological order.
1344      */
1345     public ArrayList<ImsReasonInfo> getRecentImsDisconnectReasons() {
1346         ArrayList<ImsReasonInfo> disconnectReasons = new ArrayList<>();
1347
1348         for (ImsReasonInfo reason : mRecentDisconnectReasons) {
1349             disconnectReasons.add(makeACopy(reason));
1350         }
1351         return disconnectReasons;
1352     }
1353     
1354     public int getImsServiceStatus() throws ImsException {
1355         checkAndThrowExceptionIfServiceUnavailable();
1356
1357         return mImsServiceProxy.getFeatureStatus();
1358     }
1359
1360     /**
1361      * Get the boolean config from carrier config manager.
1362      *
1363      * @param context the context to get carrier service
1364      * @param key config key defined in CarrierConfigManager
1365      * @return boolean value of corresponding key.
1366      */
1367     private static boolean getBooleanCarrierConfig(Context context, String key) {
1368         CarrierConfigManager configManager = (CarrierConfigManager) context.getSystemService(
1369                 Context.CARRIER_CONFIG_SERVICE);
1370         PersistableBundle b = null;
1371         if (configManager != null) {
1372             b = configManager.getConfig();
1373         }
1374         if (b != null) {
1375             return b.getBoolean(key);
1376         } else {
1377             // Return static default defined in CarrierConfigManager.
1378             return CarrierConfigManager.getDefaultConfig().getBoolean(key);
1379         }
1380     }
1381
1382     /**
1383      * Get the int config from carrier config manager.
1384      *
1385      * @param context the context to get carrier service
1386      * @param key config key defined in CarrierConfigManager
1387      * @return integer value of corresponding key.
1388      */
1389     private static int getIntCarrierConfig(Context context, String key) {
1390         CarrierConfigManager configManager = (CarrierConfigManager) context.getSystemService(
1391                 Context.CARRIER_CONFIG_SERVICE);
1392         PersistableBundle b = null;
1393         if (configManager != null) {
1394             b = configManager.getConfig();
1395         }
1396         if (b != null) {
1397             return b.getInt(key);
1398         } else {
1399             // Return static default defined in CarrierConfigManager.
1400             return CarrierConfigManager.getDefaultConfig().getInt(key);
1401         }
1402     }
1403
1404     /**
1405      * Gets the call ID from the specified incoming call broadcast intent.
1406      *
1407      * @param incomingCallIntent the incoming call broadcast intent
1408      * @return the call ID or null if the intent does not contain it
1409      */
1410     private static String getCallId(Intent incomingCallIntent) {
1411         if (incomingCallIntent == null) {
1412             return null;
1413         }
1414
1415         return incomingCallIntent.getStringExtra(EXTRA_CALL_ID);
1416     }
1417
1418     /**
1419      * Gets the service type from the specified incoming call broadcast intent.
1420      *
1421      * @param incomingCallIntent the incoming call broadcast intent
1422      * @return the session identifier or -1 if the intent does not contain it
1423      */
1424     private static int getImsSessionId(Intent incomingCallIntent) {
1425         if (incomingCallIntent == null) {
1426             return (-1);
1427         }
1428
1429         return incomingCallIntent.getIntExtra(EXTRA_SERVICE_ID, -1);
1430     }
1431
1432     /**
1433      * Binds the IMS service only if the service is not created.
1434      */
1435     private void checkAndThrowExceptionIfServiceUnavailable()
1436             throws ImsException {
1437         if (mImsServiceProxy == null || !mImsServiceProxy.isBinderAlive()) {
1438             createImsService();
1439
1440             if (mImsServiceProxy == null) {
1441                 throw new ImsException("Service is unavailable",
1442                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1443             }
1444         }
1445     }
1446
1447     /**
1448      * Binds the IMS service to make/receive the call. Supports two methods of exposing an
1449      * ImsService:
1450      * 1) com.android.ims.ImsService implementation in ServiceManager (deprecated).
1451      * 2) android.telephony.ims.ImsService implementation through ImsResolver.
1452      */
1453     private void createImsService() {
1454         if (!mConfigDynamicBind) {
1455             // Old method of binding
1456             Rlog.i(TAG, "Creating ImsService using ServiceManager");
1457             mImsServiceProxy = getServiceProxyCompat();
1458         } else {
1459             Rlog.i(TAG, "Creating ImsService using ImsResolver");
1460             mImsServiceProxy = getServiceProxy();
1461         }
1462     }
1463
1464     // Deprecated method of binding with the ImsService defined in the ServiceManager.
1465     private ImsServiceProxyCompat getServiceProxyCompat() {
1466         IBinder binder = ServiceManager.checkService(IMS_SERVICE);
1467
1468         if (binder != null) {
1469             try {
1470                 binder.linkToDeath(mDeathRecipient, 0);
1471             } catch (RemoteException e) {
1472             }
1473         }
1474
1475         return new ImsServiceProxyCompat(mPhoneId, binder);
1476     }
1477
1478     // New method of binding with the ImsResolver
1479     private ImsServiceProxy getServiceProxy() {
1480         TelephonyManager tm = (TelephonyManager)
1481                 mContext.getSystemService(Context.TELEPHONY_SERVICE);
1482         ImsServiceProxy serviceProxy = new ImsServiceProxy(mPhoneId, ImsFeature.MMTEL);
1483         // Returns null if the service is not available.
1484         IImsServiceController b = tm.getImsServiceControllerAndListen(mPhoneId,
1485                 ImsFeature.MMTEL, serviceProxy.getListener());
1486         if (b != null) {
1487             serviceProxy.setBinder(b.asBinder());
1488             serviceProxy.setStatusCallback(() -> mStatusCallbacks.forEach(
1489                             ImsServiceProxy.INotifyStatusChanged::notifyStatusChanged));
1490             // Trigger the cache to be updated for feature status.
1491             serviceProxy.getFeatureStatus();
1492             // In order to keep backwards compatibility with other services such as RcsService,
1493             // we must broadcast the IMS_SERVICE_UP intent here. If it is not ready, IMS_SERVICE_UP
1494             // will be called in this::sendImsServiceIntent. IMS_SERVICE_UP is sent by ImsService
1495             // in the old ImsService implementation.
1496             if (serviceProxy.isBinderAlive()) {
1497                 Intent intent = new Intent(ACTION_IMS_SERVICE_UP);
1498                 intent.putExtra(EXTRA_PHONE_ID, mPhoneId);
1499                 mContext.sendBroadcast(new Intent(intent));
1500             }
1501         } else {
1502             Rlog.w(TAG, "getServiceProxy: b is null! Phone Id: " + mPhoneId);
1503         }
1504         return serviceProxy;
1505     }
1506
1507     /**
1508      * Creates a {@link ImsCallSession} with the specified call profile.
1509      * Use other methods, if applicable, instead of interacting with
1510      * {@link ImsCallSession} directly.
1511      *
1512      * @param serviceId a service id which is obtained from {@link ImsManager#open}
1513      * @param profile a call profile to make the call
1514      */
1515     private ImsCallSession createCallSession(int serviceId,
1516             ImsCallProfile profile) throws ImsException {
1517         try {
1518             return new ImsCallSession(mImsServiceProxy.createCallSession(serviceId, profile, null));
1519         } catch (RemoteException e) {
1520             return null;
1521         }
1522     }
1523
1524     private ImsRegistrationListenerProxy createRegistrationListenerProxy(int serviceClass,
1525             ImsConnectionStateListener listener) {
1526         ImsRegistrationListenerProxy proxy =
1527                 new ImsRegistrationListenerProxy(serviceClass, listener);
1528         return proxy;
1529     }
1530
1531     private static void log(String s) {
1532         Rlog.d(TAG, s);
1533     }
1534
1535     private static void loge(String s) {
1536         Rlog.e(TAG, s);
1537     }
1538
1539     private static void loge(String s, Throwable t) {
1540         Rlog.e(TAG, s, t);
1541     }
1542
1543     /**
1544      * Used for turning on IMS.if its off already
1545      */
1546     private void turnOnIms() throws ImsException {
1547         checkAndThrowExceptionIfServiceUnavailable();
1548
1549         try {
1550             mImsServiceProxy.turnOnIms();
1551         } catch (RemoteException e) {
1552             throw new ImsException("turnOnIms() ", e, ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1553         }
1554     }
1555
1556     private boolean isImsTurnOffAllowed() {
1557         return isTurnOffImsAllowedByPlatform(mContext)
1558                 && (!isWfcEnabledByPlatform(mContext)
1559                 || !isWfcEnabledByUser(mContext));
1560     }
1561
1562     private void setLteFeatureValues(boolean turnOn) {
1563         log("setLteFeatureValues: " + turnOn);
1564         try {
1565             ImsConfig config = getConfigInterface();
1566             if (config != null) {
1567                 config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VOICE_OVER_LTE,
1568                         TelephonyManager.NETWORK_TYPE_LTE, turnOn ? 1 : 0, mImsConfigListener);
1569
1570                 if (isVtEnabledByPlatform(mContext)) {
1571                     boolean ignoreDataEnabledChanged = getBooleanCarrierConfig(mContext,
1572                             CarrierConfigManager.KEY_IGNORE_DATA_ENABLED_CHANGED_FOR_VIDEO_CALLS);
1573                     boolean enableViLte = turnOn && isVtEnabledByUser(mContext) &&
1574                             (ignoreDataEnabledChanged || isDataEnabled());
1575                     config.setFeatureValue(ImsConfig.FeatureConstants.FEATURE_TYPE_VIDEO_OVER_LTE,
1576                             TelephonyManager.NETWORK_TYPE_LTE,
1577                             enableViLte ? 1 : 0,
1578                             mImsConfigListener);
1579                 }
1580             }
1581         } catch (ImsException e) {
1582             loge("setLteFeatureValues: exception ", e);
1583         }
1584     }
1585
1586     private void setAdvanced4GMode(boolean turnOn) throws ImsException {
1587         checkAndThrowExceptionIfServiceUnavailable();
1588
1589         // if turnOn: first set feature values then call turnOnIms()
1590         // if turnOff: only set feature values if IMS turn off is not allowed. If turn off is
1591         // allowed, first call turnOffIms() then set feature values
1592         if (turnOn) {
1593             setLteFeatureValues(turnOn);
1594             log("setAdvanced4GMode: turnOnIms");
1595             turnOnIms();
1596         } else {
1597             if (isImsTurnOffAllowed()) {
1598                 log("setAdvanced4GMode: turnOffIms");
1599                 turnOffIms();
1600             }
1601             setLteFeatureValues(turnOn);
1602         }
1603     }
1604
1605     /**
1606      * Used for turning off IMS completely in order to make the device CSFB'ed.
1607      * Once turned off, all calls will be over CS.
1608      */
1609     private void turnOffIms() throws ImsException {
1610         checkAndThrowExceptionIfServiceUnavailable();
1611
1612         try {
1613             mImsServiceProxy.turnOffIms();
1614         } catch (RemoteException e) {
1615             throw new ImsException("turnOffIms() ", e, ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1616         }
1617     }
1618
1619     private void addToRecentDisconnectReasons(ImsReasonInfo reason) {
1620         if (reason == null) return;
1621         while (mRecentDisconnectReasons.size() >= MAX_RECENT_DISCONNECT_REASONS) {
1622             mRecentDisconnectReasons.removeFirst();
1623         }
1624         mRecentDisconnectReasons.addLast(reason);
1625     }
1626
1627     /**
1628      * Death recipient class for monitoring IMS service.
1629      */
1630     private class ImsServiceDeathRecipient implements IBinder.DeathRecipient {
1631         @Override
1632         public void binderDied() {
1633             mImsServiceProxy = null;
1634             mUt = null;
1635             mConfig = null;
1636             mEcbm = null;
1637             mMultiEndpoint = null;
1638
1639             if (mContext != null && !isDynamicBinding()) {
1640                 Intent intent = new Intent(ACTION_IMS_SERVICE_DOWN);
1641                 intent.putExtra(EXTRA_PHONE_ID, mPhoneId);
1642                 mContext.sendBroadcast(new Intent(intent));
1643             }
1644         }
1645     }
1646
1647     /**
1648      * Adapter class for {@link IImsRegistrationListener}.
1649      */
1650     private class ImsRegistrationListenerProxy extends IImsRegistrationListener.Stub {
1651         private int mServiceClass;
1652         private ImsConnectionStateListener mListener;
1653
1654         public ImsRegistrationListenerProxy(int serviceClass,
1655                 ImsConnectionStateListener listener) {
1656             mServiceClass = serviceClass;
1657             mListener = listener;
1658         }
1659
1660         public boolean isSameProxy(int serviceClass) {
1661             return (mServiceClass == serviceClass);
1662         }
1663
1664         @Deprecated
1665         public void registrationConnected() {
1666             if (DBG) {
1667                 log("registrationConnected ::");
1668             }
1669
1670             if (mListener != null) {
1671                 mListener.onImsConnected(ServiceState.RIL_RADIO_TECHNOLOGY_UNKNOWN);
1672             }
1673         }
1674
1675         @Deprecated
1676         public void registrationProgressing() {
1677             if (DBG) {
1678                 log("registrationProgressing ::");
1679             }
1680
1681             if (mListener != null) {
1682                 mListener.onImsProgressing(ServiceState.RIL_RADIO_TECHNOLOGY_UNKNOWN);
1683             }
1684         }
1685
1686         @Override
1687         public void registrationConnectedWithRadioTech(int imsRadioTech) {
1688             // Note: imsRadioTech value maps to RIL_RADIO_TECHNOLOGY
1689             //       values in ServiceState.java.
1690             if (DBG) {
1691                 log("registrationConnectedWithRadioTech :: imsRadioTech=" + imsRadioTech);
1692             }
1693
1694             if (mListener != null) {
1695                 mListener.onImsConnected(imsRadioTech);
1696             }
1697         }
1698
1699         @Override
1700         public void registrationProgressingWithRadioTech(int imsRadioTech) {
1701             // Note: imsRadioTech value maps to RIL_RADIO_TECHNOLOGY
1702             //       values in ServiceState.java.
1703             if (DBG) {
1704                 log("registrationProgressingWithRadioTech :: imsRadioTech=" + imsRadioTech);
1705             }
1706
1707             if (mListener != null) {
1708                 mListener.onImsProgressing(imsRadioTech);
1709             }
1710         }
1711
1712         @Override
1713         public void registrationDisconnected(ImsReasonInfo imsReasonInfo) {
1714             if (DBG) {
1715                 log("registrationDisconnected :: imsReasonInfo" + imsReasonInfo);
1716             }
1717
1718             addToRecentDisconnectReasons(imsReasonInfo);
1719
1720             if (mListener != null) {
1721                 mListener.onImsDisconnected(imsReasonInfo);
1722             }
1723         }
1724
1725         @Override
1726         public void registrationResumed() {
1727             if (DBG) {
1728                 log("registrationResumed ::");
1729             }
1730
1731             if (mListener != null) {
1732                 mListener.onImsResumed();
1733             }
1734         }
1735
1736         @Override
1737         public void registrationSuspended() {
1738             if (DBG) {
1739                 log("registrationSuspended ::");
1740             }
1741
1742             if (mListener != null) {
1743                 mListener.onImsSuspended();
1744             }
1745         }
1746
1747         @Override
1748         public void registrationServiceCapabilityChanged(int serviceClass, int event) {
1749             log("registrationServiceCapabilityChanged :: serviceClass=" +
1750                     serviceClass + ", event=" + event);
1751
1752             if (mListener != null) {
1753                 mListener.onImsConnected(ServiceState.RIL_RADIO_TECHNOLOGY_UNKNOWN);
1754             }
1755         }
1756
1757         @Override
1758         public void registrationFeatureCapabilityChanged(int serviceClass,
1759                 int[] enabledFeatures, int[] disabledFeatures) {
1760             log("registrationFeatureCapabilityChanged :: serviceClass=" +
1761                     serviceClass);
1762             if (mListener != null) {
1763                 mListener.onFeatureCapabilityChanged(serviceClass,
1764                         enabledFeatures, disabledFeatures);
1765             }
1766         }
1767
1768         @Override
1769         public void voiceMessageCountUpdate(int count) {
1770             log("voiceMessageCountUpdate :: count=" + count);
1771
1772             if (mListener != null) {
1773                 mListener.onVoiceMessageCountChanged(count);
1774             }
1775         }
1776
1777         @Override
1778         public void registrationAssociatedUriChanged(Uri[] uris) {
1779             if (DBG) log("registrationAssociatedUriChanged ::");
1780
1781             if (mListener != null) {
1782                 mListener.registrationAssociatedUriChanged(uris);
1783             }
1784         }
1785
1786         @Override
1787         public void registrationChangeFailed(int targetAccessTech, ImsReasonInfo imsReasonInfo) {
1788             if (DBG) log("registrationChangeFailed :: targetAccessTech=" + targetAccessTech +
1789                     ", imsReasonInfo=" + imsReasonInfo);
1790
1791             if (mListener != null) {
1792                 mListener.onRegistrationChangeFailed(targetAccessTech, imsReasonInfo);
1793             }
1794         }
1795     }
1796
1797     /**
1798      * Gets the ECBM interface to request ECBM exit.
1799      *
1800      * @param serviceId a service id which is obtained from {@link ImsManager#open}
1801      * @return the ECBM interface instance
1802      * @throws ImsException if getting the ECBM interface results in an error
1803      */
1804     public ImsEcbm getEcbmInterface(int serviceId) throws ImsException {
1805         if (mEcbm == null || !mImsServiceProxy.isBinderAlive()) {
1806             checkAndThrowExceptionIfServiceUnavailable();
1807
1808             try {
1809                 IImsEcbm iEcbm = mImsServiceProxy.getEcbmInterface();
1810
1811                 if (iEcbm == null) {
1812                     throw new ImsException("getEcbmInterface()",
1813                             ImsReasonInfo.CODE_ECBM_NOT_SUPPORTED);
1814                 }
1815                 mEcbm = new ImsEcbm(iEcbm);
1816             } catch (RemoteException e) {
1817                 throw new ImsException("getEcbmInterface()", e,
1818                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1819             }
1820         }
1821         return mEcbm;
1822     }
1823
1824     /**
1825      * Gets the Multi-Endpoint interface to subscribe to multi-enpoint notifications..
1826      *
1827      * @param serviceId a service id which is obtained from {@link ImsManager#open}
1828      * @return the multi-endpoint interface instance
1829      * @throws ImsException if getting the multi-endpoint interface results in an error
1830      */
1831     public ImsMultiEndpoint getMultiEndpointInterface(int serviceId) throws ImsException {
1832         if (mMultiEndpoint == null || !mImsServiceProxy.isBinderAlive()) {
1833             checkAndThrowExceptionIfServiceUnavailable();
1834
1835             try {
1836                 IImsMultiEndpoint iImsMultiEndpoint = mImsServiceProxy.getMultiEndpointInterface();
1837
1838                 if (iImsMultiEndpoint == null) {
1839                     throw new ImsException("getMultiEndpointInterface()",
1840                             ImsReasonInfo.CODE_MULTIENDPOINT_NOT_SUPPORTED);
1841                 }
1842                 mMultiEndpoint = new ImsMultiEndpoint(iImsMultiEndpoint);
1843             } catch (RemoteException e) {
1844                 throw new ImsException("getMultiEndpointInterface()", e,
1845                         ImsReasonInfo.CODE_LOCAL_IMS_SERVICE_DOWN);
1846             }
1847         }
1848         return mMultiEndpoint;
1849     }
1850
1851     /**
1852      * Resets ImsManager settings back to factory defaults.
1853      *
1854      * @hide
1855      */
1856     public static void factoryReset(Context context) {
1857         // Set VoLTE to default
1858         android.provider.Settings.Global.putInt(context.getContentResolver(),
1859                 android.provider.Settings.Global.ENHANCED_4G_MODE_ENABLED,
1860                 ImsConfig.FeatureValueConstants.ON);
1861
1862         // Set VoWiFi to default
1863         android.provider.Settings.Global.putInt(context.getContentResolver(),
1864                 android.provider.Settings.Global.WFC_IMS_ENABLED,
1865                 getBooleanCarrierConfig(context,
1866                         CarrierConfigManager.KEY_CARRIER_DEFAULT_WFC_IMS_ENABLED_BOOL) ?
1867                         ImsConfig.FeatureValueConstants.ON : ImsConfig.FeatureValueConstants.OFF);
1868
1869         // Set VoWiFi mode to default
1870         android.provider.Settings.Global.putInt(context.getContentResolver(),
1871                 android.provider.Settings.Global.WFC_IMS_MODE,
1872                 getIntCarrierConfig(context,
1873                         CarrierConfigManager.KEY_CARRIER_DEFAULT_WFC_IMS_MODE_INT));
1874
1875         // Set VoWiFi roaming to default
1876         android.provider.Settings.Global.putInt(context.getContentResolver(),
1877                 android.provider.Settings.Global.WFC_IMS_ROAMING_ENABLED,
1878                 getBooleanCarrierConfig(context,
1879                         CarrierConfigManager.KEY_CARRIER_DEFAULT_WFC_IMS_ROAMING_ENABLED_BOOL) ?
1880                         ImsConfig.FeatureValueConstants.ON : ImsConfig.FeatureValueConstants.OFF);
1881
1882         // Set VT to default
1883         android.provider.Settings.Global.putInt(context.getContentResolver(),
1884                 android.provider.Settings.Global.VT_IMS_ENABLED,
1885                 ImsConfig.FeatureValueConstants.ON);
1886
1887         // Push settings to ImsConfig
1888         ImsManager.updateImsServiceConfig(context,
1889                 SubscriptionManager.getDefaultVoicePhoneId(), true);
1890     }
1891
1892     private boolean isDataEnabled() {
1893         return SystemProperties.getBoolean(DATA_ENABLED_PROP, true);
1894     }
1895
1896     /**
1897      * Set data enabled/disabled flag.
1898      * @param enabled True if data is enabled, otherwise disabled.
1899      */
1900     public void setDataEnabled(boolean enabled) {
1901         log("setDataEnabled: " + enabled);
1902         SystemProperties.set(DATA_ENABLED_PROP, enabled ? TRUE : FALSE);
1903     }
1904
1905     private boolean isVolteProvisioned() {
1906         return SystemProperties.getBoolean(VOLTE_PROVISIONED_PROP, true);
1907     }
1908
1909     private void setVolteProvisionedProperty(boolean provisioned) {
1910         SystemProperties.set(VOLTE_PROVISIONED_PROP, provisioned ? TRUE : FALSE);
1911     }
1912
1913     private boolean isWfcProvisioned() {
1914         return SystemProperties.getBoolean(WFC_PROVISIONED_PROP, true);
1915     }
1916
1917     private void setWfcProvisionedProperty(boolean provisioned) {
1918         SystemProperties.set(WFC_PROVISIONED_PROP, provisioned ? TRUE : FALSE);
1919     }
1920
1921     private boolean isVtProvisioned() {
1922         return SystemProperties.getBoolean(VT_PROVISIONED_PROP, true);
1923     }
1924
1925     private void setVtProvisionedProperty(boolean provisioned) {
1926         SystemProperties.set(VT_PROVISIONED_PROP, provisioned ? TRUE : FALSE);
1927     }
1928
1929     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
1930         pw.println("ImsManager:");
1931         pw.println("  mPhoneId = " + mPhoneId);
1932         pw.println("  mConfigUpdated = " + mConfigUpdated);
1933         pw.println("  mImsServiceProxy = " + mImsServiceProxy);
1934         pw.println("  mDataEnabled = " + isDataEnabled());
1935         pw.println("  ignoreDataEnabledChanged = " + getBooleanCarrierConfig(mContext,
1936                 CarrierConfigManager.KEY_IGNORE_DATA_ENABLED_CHANGED_FOR_VIDEO_CALLS));
1937
1938         pw.println("  isGbaValid = " + isGbaValid(mContext));
1939         pw.println("  isImsTurnOffAllowed = " + isImsTurnOffAllowed());
1940         pw.println("  isNonTtyOrTtyOnVolteEnabled = " + isNonTtyOrTtyOnVolteEnabled(mContext));
1941
1942         pw.println("  isVolteEnabledByPlatform = " + isVolteEnabledByPlatform(mContext));
1943         pw.println("  isVolteProvisionedOnDevice = " + isVolteProvisionedOnDevice(mContext));
1944         pw.println("  isEnhanced4gLteModeSettingEnabledByUser = " +
1945                 isEnhanced4gLteModeSettingEnabledByUser(mContext));
1946         pw.println("  isVtEnabledByPlatform = " + isVtEnabledByPlatform(mContext));
1947         pw.println("  isVtEnabledByUser = " + isVtEnabledByUser(mContext));
1948
1949         pw.println("  isWfcEnabledByPlatform = " + isWfcEnabledByPlatform(mContext));
1950         pw.println("  isWfcEnabledByUser = " + isWfcEnabledByUser(mContext));
1951         pw.println("  getWfcMode = " + getWfcMode(mContext));
1952         pw.println("  isWfcRoamingEnabledByUser = " + isWfcRoamingEnabledByUser(mContext));
1953
1954         pw.println("  isVtProvisionedOnDevice = " + isVtProvisionedOnDevice(mContext));
1955         pw.println("  isWfcProvisionedOnDevice = " + isWfcProvisionedOnDevice(mContext));
1956         pw.flush();
1957     }
1958 }