blob: b678b4eef0817f4e50f07f54d40cecf7df3f5226 [file] [log] [blame]
Santos Cordon7d4ddf62013-07-10 11:58:08 -07001/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.phone;
18
Jordan Liuff2ccd72019-07-23 15:54:41 -070019import android.annotation.IntDef;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070020import android.app.Activity;
21import android.app.KeyguardManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070022import android.app.ProgressDialog;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070023import android.content.BroadcastReceiver;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070024import android.content.ContentResolver;
25import android.content.Context;
26import android.content.ContextWrapper;
27import android.content.Intent;
28import android.content.IntentFilter;
Brad Ebinger05f52c22019-12-05 13:03:21 -080029import android.content.pm.PackageManager;
Youming Ye47a6adc2018-11-19 15:33:36 -080030import android.content.res.XmlResourceParser;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070031import android.media.AudioManager;
Santos Cordone18902f2016-03-22 17:16:04 -070032import android.net.ConnectivityManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070033import android.net.Uri;
Brad Ebinger533c6c12017-08-02 11:38:48 -070034import android.net.sip.SipManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070035import android.os.AsyncResult;
Junda Liu605148f2015-04-28 15:23:40 -070036import android.os.Bundle;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070037import android.os.Handler;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070038import android.os.Message;
Jonathan Basseric31f1f32015-05-12 10:13:03 -070039import android.os.PersistableBundle;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070040import android.os.PowerManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070041import android.os.SystemProperties;
Brad Ebinger3fa43462016-04-12 16:06:48 -070042import android.os.UserManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070043import android.preference.PreferenceManager;
Sanket Padawe4c699232016-02-09 11:07:22 -080044import android.provider.Settings;
Meng Wang61307622019-10-23 14:08:43 -070045import android.sysprop.TelephonyProperties;
Tyler Gunn900d8fd2018-09-21 09:22:12 -070046import android.telecom.TelecomManager;
Nathan Haroldf9df6ea2019-03-08 11:54:22 -080047import android.telephony.AnomalyReporter;
Junda Liu12f7d802015-05-01 12:06:44 -070048import android.telephony.CarrierConfigManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070049import android.telephony.ServiceState;
chen xubaf9fe52019-07-02 17:28:24 -070050import android.telephony.SubscriptionInfo;
Andrew Lee385019f2014-11-24 14:19:50 -080051import android.telephony.SubscriptionManager;
Jack Yu1a2fc352017-07-14 17:14:37 -070052import android.telephony.TelephonyManager;
Jack Yu311536f2018-11-26 11:20:48 -080053import android.telephony.data.ApnSetting;
Jack Yu1a2fc352017-07-14 17:14:37 -070054import android.util.LocalLog;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070055import android.util.Log;
Santos Cordone18902f2016-03-22 17:16:04 -070056import android.widget.Toast;
Ta-wei Yenb29425b2016-09-21 17:28:14 -070057
Santos Cordon7d4ddf62013-07-10 11:58:08 -070058import com.android.internal.telephony.CallManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070059import com.android.internal.telephony.IccCardConstants;
60import com.android.internal.telephony.MmiCode;
61import com.android.internal.telephony.Phone;
62import com.android.internal.telephony.PhoneConstants;
63import com.android.internal.telephony.PhoneFactory;
Jack Yu1a2fc352017-07-14 17:14:37 -070064import com.android.internal.telephony.SettingsObserver;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070065import com.android.internal.telephony.TelephonyCapabilities;
Youming Ye47a6adc2018-11-19 15:33:36 -080066import com.android.internal.telephony.TelephonyComponentFactory;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070067import com.android.internal.telephony.TelephonyIntents;
Jack Yu1a2fc352017-07-14 17:14:37 -070068import com.android.internal.telephony.dataconnection.DataConnectionReasons;
69import com.android.internal.telephony.dataconnection.DataConnectionReasons.DataDisallowedReasonType;
Brad Ebinger05f52c22019-12-05 13:03:21 -080070import com.android.internal.telephony.ims.ImsResolver;
Jack Yu1a2fc352017-07-14 17:14:37 -070071import com.android.internal.util.IndentingPrintWriter;
Andrew Leefb7f92e2015-02-26 16:23:32 -080072import com.android.phone.settings.SettingsConstants;
Ta-wei Yenf0a71bc2017-05-17 12:28:28 -070073import com.android.phone.vvm.CarrierVvmPackageInstalledReceiver;
James.cf Linc9f35a42020-01-15 02:35:22 +080074import com.android.services.telephony.rcs.TelephonyRcsService;
Brad Ebinger28626122017-08-10 14:13:35 -070075import com.android.services.telephony.sip.SipAccountRegistry;
Brad Ebinger3fa43462016-04-12 16:06:48 -070076import com.android.services.telephony.sip.SipUtil;
Santos Cordon7d4ddf62013-07-10 11:58:08 -070077
Jack Yu1a2fc352017-07-14 17:14:37 -070078import java.io.FileDescriptor;
79import java.io.PrintWriter;
Jordan Liuff2ccd72019-07-23 15:54:41 -070080import java.lang.annotation.Retention;
81import java.lang.annotation.RetentionPolicy;
chen xubaf9fe52019-07-02 17:28:24 -070082import java.util.List;
Jack Yu1a2fc352017-07-14 17:14:37 -070083
Santos Cordon7d4ddf62013-07-10 11:58:08 -070084/**
85 * Global state for the telephony subsystem when running in the primary
86 * phone process.
87 */
Sailesh Nepalbf900542014-07-15 16:18:32 -070088public class PhoneGlobals extends ContextWrapper {
Jack Yu1a2fc352017-07-14 17:14:37 -070089 public static final String LOG_TAG = "PhoneGlobals";
Santos Cordon7d4ddf62013-07-10 11:58:08 -070090
91 /**
92 * Phone app-wide debug level:
93 * 0 - no debug logging
94 * 1 - normal debug logging if ro.debuggable is set (which is true in
95 * "eng" and "userdebug" builds but not "user" builds)
96 * 2 - ultra-verbose debug logging
97 *
98 * Most individual classes in the phone app have a local DBG constant,
99 * typically set to
100 * (PhoneApp.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1)
101 * or else
102 * (PhoneApp.DBG_LEVEL >= 2)
103 * depending on the desired verbosity.
104 *
105 * ***** DO NOT SUBMIT WITH DBG_LEVEL > 0 *************
106 */
Andrew Lee88b51e22014-10-29 15:48:51 -0700107 public static final int DBG_LEVEL = 0;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700108
109 private static final boolean DBG =
110 (PhoneGlobals.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1);
111 private static final boolean VDBG = (PhoneGlobals.DBG_LEVEL >= 2);
112
113 // Message codes; see mHandler below.
114 private static final int EVENT_SIM_NETWORK_LOCKED = 3;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700115 private static final int EVENT_SIM_STATE_CHANGED = 8;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700116 private static final int EVENT_DATA_ROAMING_DISCONNECTED = 10;
Jordan Liuff2ccd72019-07-23 15:54:41 -0700117 private static final int EVENT_DATA_ROAMING_CONNECTED = 11;
118 private static final int EVENT_DATA_ROAMING_OK = 12;
119 private static final int EVENT_UNSOL_CDMA_INFO_RECORD = 13;
120 private static final int EVENT_RESTART_SIP = 14;
121 private static final int EVENT_DATA_ROAMING_SETTINGS_CHANGED = 15;
122 private static final int EVENT_MOBILE_DATA_SETTINGS_CHANGED = 16;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700123
124 // The MMI codes are also used by the InCallScreen.
125 public static final int MMI_INITIATE = 51;
126 public static final int MMI_COMPLETE = 52;
127 public static final int MMI_CANCEL = 53;
128 // Don't use message codes larger than 99 here; those are reserved for
129 // the individual Activities of the Phone UI.
130
Santos Cordone18902f2016-03-22 17:16:04 -0700131 public static final int AIRPLANE_ON = 1;
132 public static final int AIRPLANE_OFF = 0;
133
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700134 /**
135 * Allowable values for the wake lock code.
136 * SLEEP means the device can be put to sleep.
137 * PARTIAL means wake the processor, but we display can be kept off.
138 * FULL means wake both the processor and the display.
139 */
140 public enum WakeState {
141 SLEEP,
142 PARTIAL,
143 FULL
144 }
145
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700146 private static PhoneGlobals sMe;
147
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700148 CallManager mCM;
Santos Cordon63a84242013-07-23 13:32:52 -0700149 CallNotifier notifier;
150 CallerInfoCache callerInfoCache;
Santos Cordon63a84242013-07-23 13:32:52 -0700151 NotificationMgr notificationMgr;
Brad Ebinger05f52c22019-12-05 13:03:21 -0800152 ImsResolver mImsResolver;
James.cf Linc9f35a42020-01-15 02:35:22 +0800153 TelephonyRcsService mTelephonyRcsService;
Andrew Lee9431b832015-03-09 18:46:45 -0700154 public PhoneInterfaceManager phoneMgr;
James.cf Linaf3183c2019-10-24 00:59:00 +0800155 public ImsRcsController imsRcsController;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800156 CarrierConfigLoader configLoader;
Santos Cordon63a84242013-07-23 13:32:52 -0700157
Sandeep Kuntade73a6a2014-10-15 18:45:56 +0530158 private Phone phoneInEcm;
Santos Cordon63a84242013-07-23 13:32:52 -0700159
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700160 static boolean sVoiceCapable = true;
161
Santos Cordonc593d002015-06-03 15:41:15 -0700162 // TODO: Remove, no longer used.
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700163 CdmaPhoneCallState cdmaPhoneCallState;
164
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700165 // The currently-active PUK entry activity and progress dialog.
166 // Normally, these are the Emergency Dialer and the subsequent
167 // progress dialog. null if there is are no such objects in
168 // the foreground.
169 private Activity mPUKEntryActivity;
170 private ProgressDialog mPUKEntryProgressDialog;
171
Jordan Liuff2ccd72019-07-23 15:54:41 -0700172 /** @hide */
173 @Retention(RetentionPolicy.SOURCE)
174 @IntDef(prefix = {"ROAMING_NOTIFICATION_"},
175 value = {
176 ROAMING_NOTIFICATION_NO_NOTIFICATION,
177 ROAMING_NOTIFICATION_CONNECTED,
178 ROAMING_NOTIFICATION_DISCONNECTED})
179 public @interface RoamingNotification {}
180
181 private static final int ROAMING_NOTIFICATION_NO_NOTIFICATION = 0;
182 private static final int ROAMING_NOTIFICATION_CONNECTED = 1;
183 private static final int ROAMING_NOTIFICATION_DISCONNECTED = 2;
184
185 @RoamingNotification
186 private int mPrevRoamingNotification = ROAMING_NOTIFICATION_NO_NOTIFICATION;
Jack Yu953f9352017-05-18 14:41:06 -0700187
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700188 private WakeState mWakeState = WakeState.SLEEP;
189
190 private PowerManager mPowerManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700191 private PowerManager.WakeLock mWakeLock;
192 private PowerManager.WakeLock mPartialWakeLock;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700193 private KeyguardManager mKeyguardManager;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700194
Jack Yu1a2fc352017-07-14 17:14:37 -0700195 private int mDefaultDataSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
196 private final LocalLog mDataRoamingNotifLog = new LocalLog(50);
197
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700198 // Broadcast receiver for various intent broadcasts (see onCreate())
199 private final BroadcastReceiver mReceiver = new PhoneAppBroadcastReceiver();
Brad Ebinger533c6c12017-08-02 11:38:48 -0700200 // Broadcast receiver for SIP based intents (see onCreate())
Brad Ebinger28626122017-08-10 14:13:35 -0700201 private final SipReceiver mSipReceiver = new SipReceiver();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700202
Ta-wei Yenf0a71bc2017-05-17 12:28:28 -0700203 private final CarrierVvmPackageInstalledReceiver mCarrierVvmPackageInstalledReceiver =
204 new CarrierVvmPackageInstalledReceiver();
205
Jack Yu1a2fc352017-07-14 17:14:37 -0700206 private final SettingsObserver mSettingsObserver;
207
Nazish Tabassum160d2112019-12-23 17:31:33 +0530208 private static class EventSimStateChangedBag {
209 final int mPhoneId;
210 final String mIccStatus;
211
212 EventSimStateChangedBag(int phoneId, String iccStatus) {
213 mPhoneId = phoneId;
214 mIccStatus = iccStatus;
215 }
216 }
217
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700218 Handler mHandler = new Handler() {
219 @Override
220 public void handleMessage(Message msg) {
221 PhoneConstants.State phoneState;
Jack Yu1a2fc352017-07-14 17:14:37 -0700222 if (VDBG) Log.v(LOG_TAG, "event=" + msg.what);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700223 switch (msg.what) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700224 // TODO: This event should be handled by the lock screen, just
225 // like the "SIM missing" and "Sim locked" cases (bug 1804111).
226 case EVENT_SIM_NETWORK_LOCKED:
Jonathan Basseri9504c6b2015-06-04 14:23:32 -0700227 if (getCarrierConfig().getBoolean(
228 CarrierConfigManager.KEY_IGNORE_SIM_NETWORK_LOCKED_EVENTS_BOOL)) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700229 // Some products don't have the concept of a "SIM network lock"
230 Log.i(LOG_TAG, "Ignoring EVENT_SIM_NETWORK_LOCKED event; "
Eric Erfanian945409f2018-02-21 19:26:15 +0000231 + "not showing 'SIM network unlock' PIN entry screen");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700232 } else {
233 // Normal case: show the "SIM network unlock" PIN entry screen.
234 // The user won't be able to do anything else until
235 // they enter a valid SIM network PIN.
236 Log.i(LOG_TAG, "show sim depersonal panel");
Biljana Maneva96291112018-01-30 13:12:59 +0800237 Phone phone = (Phone) ((AsyncResult) msg.obj).userObj;
Nazish Tabassum160d2112019-12-23 17:31:33 +0530238 int subType = (Integer)((AsyncResult)msg.obj).result;
239 IccNetworkDepersonalizationPanel.showDialog(phone, subType);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700240 }
241 break;
242
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700243 case EVENT_DATA_ROAMING_DISCONNECTED:
Jordan Liuff2ccd72019-07-23 15:54:41 -0700244 notificationMgr.showDataRoamingNotification(msg.arg1, false);
245 break;
246
247 case EVENT_DATA_ROAMING_CONNECTED:
248 notificationMgr.showDataRoamingNotification(msg.arg1, true);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700249 break;
250
251 case EVENT_DATA_ROAMING_OK:
Jordan Liuff2ccd72019-07-23 15:54:41 -0700252 notificationMgr.hideDataRoamingNotification();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700253 break;
254
255 case MMI_COMPLETE:
256 onMMIComplete((AsyncResult) msg.obj);
257 break;
258
259 case MMI_CANCEL:
Stuart Scottdcf40a92014-12-09 10:45:01 -0800260 PhoneUtils.cancelMmiCode(mCM.getFgPhone());
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700261 break;
262
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700263 case EVENT_SIM_STATE_CHANGED:
264 // Marks the event where the SIM goes into ready state.
265 // Right now, this is only used for the PUK-unlocking
266 // process.
Nazish Tabassum160d2112019-12-23 17:31:33 +0530267 EventSimStateChangedBag bag = (EventSimStateChangedBag)msg.obj;
Tyler Gunn3fc09c02020-05-08 16:35:55 -0700268 if (IccCardConstants.INTENT_VALUE_ICC_READY.equals(bag.mIccStatus)
Nazish Tabassum59126a92020-07-03 21:44:49 +0530269 || IccCardConstants.INTENT_VALUE_ICC_LOADED.equals(bag.mIccStatus)
270 || IccCardConstants.INTENT_VALUE_ICC_NOT_READY.equals(bag.mIccStatus)
271 || IccCardConstants.INTENT_VALUE_ICC_ABSENT.equals(bag.mIccStatus)) {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700272 // when the right event is triggered and there
273 // are UI objects in the foreground, we close
274 // them to display the lock panel.
275 if (mPUKEntryActivity != null) {
Tyler Gunn3fc09c02020-05-08 16:35:55 -0700276 Log.i(LOG_TAG, "Dismiss puk entry activity");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700277 mPUKEntryActivity.finish();
278 mPUKEntryActivity = null;
279 }
280 if (mPUKEntryProgressDialog != null) {
Tyler Gunn3fc09c02020-05-08 16:35:55 -0700281 Log.i(LOG_TAG, "Dismiss puk progress dialog");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700282 mPUKEntryProgressDialog.dismiss();
283 mPUKEntryProgressDialog = null;
284 }
Nazish Tabassum59126a92020-07-03 21:44:49 +0530285 Log.i(LOG_TAG, "Dismissing depersonal panel" + (bag.mIccStatus));
Nazish Tabassum160d2112019-12-23 17:31:33 +0530286 IccNetworkDepersonalizationPanel.dialogDismiss(bag.mPhoneId);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700287 }
288 break;
289
290 case EVENT_UNSOL_CDMA_INFO_RECORD:
291 //TODO: handle message here;
292 break;
Brad Ebinger3fa43462016-04-12 16:06:48 -0700293 case EVENT_RESTART_SIP:
294 // This should only run if the Phone process crashed and was restarted. We do
295 // not want this running if the device is still in the FBE encrypted state.
Brad Ebinger28626122017-08-10 14:13:35 -0700296 // This is the same procedure that is triggered in the SipIncomingCallReceiver
Brad Ebinger3fa43462016-04-12 16:06:48 -0700297 // upon BOOT_COMPLETED.
Meng Wangc04cd2d2019-10-04 12:00:06 -0700298 UserManager userManager =
299 (UserManager) sMe.getSystemService(Context.USER_SERVICE);
Brad Ebinger3fa43462016-04-12 16:06:48 -0700300 if (userManager != null && userManager.isUserUnlocked()) {
301 SipUtil.startSipService();
302 }
303 break;
Jack Yu1a2fc352017-07-14 17:14:37 -0700304 case EVENT_DATA_ROAMING_SETTINGS_CHANGED:
305 case EVENT_MOBILE_DATA_SETTINGS_CHANGED:
306 updateDataRoamingStatus();
307 break;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700308 }
309 }
310 };
311
312 public PhoneGlobals(Context context) {
313 super(context);
314 sMe = this;
Jack Yu1a2fc352017-07-14 17:14:37 -0700315 mSettingsObserver = new SettingsObserver(context, mHandler);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700316 }
317
318 public void onCreate() {
319 if (VDBG) Log.v(LOG_TAG, "onCreate()...");
320
321 ContentResolver resolver = getContentResolver();
322
323 // Cache the "voice capable" flag.
324 // This flag currently comes from a resource (which is
325 // overrideable on a per-product basis):
Michele87262742020-01-16 12:23:53 -0800326 sVoiceCapable = ((TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE))
327 .isVoiceCapable();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700328 // ...but this might eventually become a PackageManager "system
329 // feature" instead, in which case we'd do something like:
330 // sVoiceCapable =
331 // getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY_VOICE_CALLS);
332
Stuart Scottdcf40a92014-12-09 10:45:01 -0800333 if (mCM == null) {
Nathan Haroldf9df6ea2019-03-08 11:54:22 -0800334 // Initialize AnomalyReporter early so that it can be used
335 AnomalyReporter.initialize(this);
Nathan Harold0db5c5e2019-01-22 20:18:56 -0800336
Youming Ye47a6adc2018-11-19 15:33:36 -0800337 // Inject telephony component factory if configured using other jars.
338 XmlResourceParser parser = getResources().getXml(R.xml.telephony_injection);
339 TelephonyComponentFactory.getInstance().injectTheComponentFactory(parser);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700340 // Initialize the telephony framework
341 PhoneFactory.makeDefaultPhones(this);
342
Brad Ebinger05f52c22019-12-05 13:03:21 -0800343 // Only bring up ImsResolver if the device supports having an IMS stack.
344 if (getPackageManager().hasSystemFeature(
345 PackageManager.FEATURE_TELEPHONY_IMS)) {
346 // Get the package name of the default IMS implementation.
347 String defaultImsMmtelPackage = getResources().getString(
348 R.string.config_ims_mmtel_package);
349 String defaultImsRcsPackage = getResources().getString(
350 R.string.config_ims_rcs_package);
351 mImsResolver = new ImsResolver(this, defaultImsMmtelPackage,
352 defaultImsRcsPackage, PhoneFactory.getPhones().length);
353 mImsResolver.initialize();
354 }
355
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700356 // Start TelephonyDebugService After the default phone is created.
357 Intent intent = new Intent(this, TelephonyDebugService.class);
358 startService(intent);
359
360 mCM = CallManager.getInstance();
Stuart Scottdcf40a92014-12-09 10:45:01 -0800361 for (Phone phone : PhoneFactory.getPhones()) {
362 mCM.registerPhone(phone);
Stuart Scottdcf40a92014-12-09 10:45:01 -0800363 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700364
365 // Create the NotificationMgr singleton, which is used to display
366 // status bar icons and control other status bar behavior.
367 notificationMgr = NotificationMgr.init(this);
368
Brad Ebinger3fa43462016-04-12 16:06:48 -0700369 // If PhoneGlobals has crashed and is being restarted, then restart.
370 mHandler.sendEmptyMessage(EVENT_RESTART_SIP);
371
Anthony Lee03ebdfc2015-07-27 08:12:02 -0700372 // Create an instance of CdmaPhoneCallState and initialize it to IDLE
373 cdmaPhoneCallState = new CdmaPhoneCallState();
374 cdmaPhoneCallState.CdmaPhoneCallStateInit();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700375
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700376 // before registering for phone state changes
377 mPowerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
378 mWakeLock = mPowerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, LOG_TAG);
379 // lock used to keep the processor awake, when we don't care for the display.
380 mPartialWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK
381 | PowerManager.ON_AFTER_RELEASE, LOG_TAG);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700382
383 mKeyguardManager = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE);
384
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700385 // Create the CallerInfoCache singleton, which remembers custom ring tone and
386 // send-to-voicemail settings.
387 //
388 // The asynchronous caching will start just after this call.
389 callerInfoCache = CallerInfoCache.init(this);
390
Nazanin Bakhshi2f2cc692018-12-11 15:15:39 -0800391 phoneMgr = PhoneInterfaceManager.init(this);
Santos Cordon406c0342013-08-28 00:07:47 -0700392
James.cf Linaf3183c2019-10-24 00:59:00 +0800393 imsRcsController = ImsRcsController.init(this);
394
James.cf Linc9f35a42020-01-15 02:35:22 +0800395 if (getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY_IMS)) {
Brad Ebingera68a4972020-01-30 17:31:23 -0800396 mTelephonyRcsService = new TelephonyRcsService(this,
397 PhoneFactory.getPhones().length);
398 mTelephonyRcsService.initialize();
James.cf Linc9f35a42020-01-15 02:35:22 +0800399 imsRcsController.setRcsService(mTelephonyRcsService);
400 }
401
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800402 configLoader = CarrierConfigLoader.init(this);
403
Jack Yu1a2fc352017-07-14 17:14:37 -0700404 // Create the CallNotifier singleton, which handles
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700405 // asynchronous events from the telephony layer (like
406 // launching the incoming-call UI when an incoming call comes
407 // in.)
Brad Ebingera9c6b6d2016-01-07 17:24:16 -0800408 notifier = CallNotifier.init(this);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700409
Stuart Scottdcf40a92014-12-09 10:45:01 -0800410 PhoneUtils.registerIccStatus(mHandler, EVENT_SIM_NETWORK_LOCKED);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700411
412 // register for MMI/USSD
413 mCM.registerForMmiComplete(mHandler, MMI_COMPLETE, null);
414
Qiong Liucc3fe812019-09-23 15:25:44 +0800415 // Initialize cell status using current airplane mode.
416 handleAirplaneModeChange(this, Settings.Global.getInt(getContentResolver(),
417 Settings.Global.AIRPLANE_MODE_ON, AIRPLANE_OFF));
418
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700419 // Register for misc other intent broadcasts.
420 IntentFilter intentFilter =
421 new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700422 intentFilter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
423 intentFilter.addAction(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED);
424 intentFilter.addAction(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED);
425 intentFilter.addAction(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED);
Jack Yu1a2fc352017-07-14 17:14:37 -0700426 intentFilter.addAction(TelephonyIntents.ACTION_DEFAULT_DATA_SUBSCRIPTION_CHANGED);
427 intentFilter.addAction(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700428 registerReceiver(mReceiver, intentFilter);
429
Brad Ebinger533c6c12017-08-02 11:38:48 -0700430 IntentFilter sipIntentFilter = new IntentFilter(Intent.ACTION_BOOT_COMPLETED);
Brad Ebinger533c6c12017-08-02 11:38:48 -0700431 sipIntentFilter.addAction(SipManager.ACTION_SIP_SERVICE_UP);
432 sipIntentFilter.addAction(SipManager.ACTION_SIP_CALL_OPTION_CHANGED);
Grace Jiab95592a2020-01-15 14:12:24 -0800433 sipIntentFilter.addAction(SipManager.ACTION_SIP_REMOVE_PROFILE);
Brad Ebinger28626122017-08-10 14:13:35 -0700434 registerReceiver(mSipReceiver, sipIntentFilter);
Brad Ebinger533c6c12017-08-02 11:38:48 -0700435
Ta-wei Yenf0a71bc2017-05-17 12:28:28 -0700436 mCarrierVvmPackageInstalledReceiver.register(this);
437
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700438 //set the default values for the preferences in the phone.
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700439 PreferenceManager.setDefaultValues(this, R.xml.call_feature_setting, false);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700440 }
441
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700442 // XXX pre-load the SimProvider so that it's ready
443 resolver.getType(Uri.parse("content://icc/adn"));
444
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700445 // TODO: Register for Cdma Information Records
446 // phone.registerCdmaInformationRecord(mHandler, EVENT_UNSOL_CDMA_INFO_RECORD, null);
447
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700448 // Read HAC settings and configure audio hardware
449 if (getResources().getBoolean(R.bool.hac_enabled)) {
Stuart Scottdcf40a92014-12-09 10:45:01 -0800450 int hac = android.provider.Settings.System.getInt(
451 getContentResolver(),
452 android.provider.Settings.System.HEARING_AID,
453 0);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700454 AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
Jordan Liuf71aeef2019-08-21 11:46:09 -0700455 audioManager.setParameters(
456 SettingsConstants.HAC_KEY + "=" + (hac == SettingsConstants.HAC_ENABLED
457 ? SettingsConstants.HAC_VAL_ON : SettingsConstants.HAC_VAL_OFF));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700458 }
Santos Cordonff506f52013-11-21 19:13:19 -0800459 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700460
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700461 /**
462 * Returns the singleton instance of the PhoneApp.
463 */
Sailesh Nepal1eaf22b2014-02-22 17:00:49 -0800464 public static PhoneGlobals getInstance() {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700465 if (sMe == null) {
466 throw new IllegalStateException("No PhoneGlobals here!");
467 }
468 return sMe;
469 }
470
471 /**
Stuart Scottdcf40a92014-12-09 10:45:01 -0800472 * Returns the default phone.
473 *
Andrew Lee385019f2014-11-24 14:19:50 -0800474 * WARNING: This method should be used carefully, now that there may be multiple phones.
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700475 */
Andrew Lee83383e42014-10-31 12:42:28 -0700476 public static Phone getPhone() {
Stuart Scottdcf40a92014-12-09 10:45:01 -0800477 return PhoneFactory.getDefaultPhone();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700478 }
479
Andrew Lee2fcb6c32014-12-04 14:52:35 -0800480 public static Phone getPhone(int subId) {
481 return PhoneFactory.getPhone(SubscriptionManager.getPhoneId(subId));
Andrew Lee385019f2014-11-24 14:19:50 -0800482 }
483
Brad Ebinger05f52c22019-12-05 13:03:21 -0800484 public ImsResolver getImsResolver() {
485 return mImsResolver;
486 }
487
Santos Cordonde10b752013-09-19 04:11:33 -0700488 /* package */ CallManager getCallManager() {
489 return mCM;
490 }
491
Chris Manton4e9fa912015-06-19 11:26:57 -0700492 public PersistableBundle getCarrierConfig() {
Shishir Agrawald3480e02016-01-25 13:05:49 -0800493 return getCarrierConfigForSubId(SubscriptionManager.getDefaultSubscriptionId());
Jonathan Basseri89b0ab42015-05-01 10:52:40 -0700494 }
495
Chris Manton4e9fa912015-06-19 11:26:57 -0700496 public PersistableBundle getCarrierConfigForSubId(int subId) {
Philip P. Moltmann9797cbb2020-01-07 13:45:00 -0800497 return configLoader.getConfigForSubIdWithFeature(subId, getOpPackageName(), null);
Junda Liu605148f2015-04-28 15:23:40 -0700498 }
499
Jack Yu1a2fc352017-07-14 17:14:37 -0700500 private void registerSettingsObserver() {
501 mSettingsObserver.unobserve();
502 String dataRoamingSetting = Settings.Global.DATA_ROAMING;
503 String mobileDataSetting = Settings.Global.MOBILE_DATA;
504 if (TelephonyManager.getDefault().getSimCount() > 1) {
505 int subId = mDefaultDataSubId;
506 if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
507 dataRoamingSetting += subId;
508 mobileDataSetting += subId;
509 }
510 }
511
512 // Listen for user data roaming setting changed event
513 mSettingsObserver.observe(Settings.Global.getUriFor(dataRoamingSetting),
514 EVENT_DATA_ROAMING_SETTINGS_CHANGED);
515
516 // Listen for mobile data setting changed event
517 mSettingsObserver.observe(Settings.Global.getUriFor(mobileDataSetting),
518 EVENT_MOBILE_DATA_SETTINGS_CHANGED);
519 }
520
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700521 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700522 * Sets the activity responsible for un-PUK-blocking the device
523 * so that we may close it when we receive a positive result.
524 * mPUKEntryActivity is also used to indicate to the device that
525 * we are trying to un-PUK-lock the phone. In other words, iff
526 * it is NOT null, then we are trying to unlock and waiting for
527 * the SIM to move to READY state.
528 *
529 * @param activity is the activity to close when PUK has
530 * finished unlocking. Can be set to null to indicate the unlock
531 * or SIM READYing process is over.
532 */
533 void setPukEntryActivity(Activity activity) {
Tyler Gunn3fc09c02020-05-08 16:35:55 -0700534 Log.i(LOG_TAG, "setPukEntryActivity - set to " + (activity == null ? "null" : "activity"));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700535 mPUKEntryActivity = activity;
536 }
537
538 Activity getPUKEntryActivity() {
539 return mPUKEntryActivity;
540 }
541
542 /**
543 * Sets the dialog responsible for notifying the user of un-PUK-
544 * blocking - SIM READYing progress, so that we may dismiss it
545 * when we receive a positive result.
546 *
547 * @param dialog indicates the progress dialog informing the user
548 * of the state of the device. Dismissed upon completion of
549 * READYing process
550 */
551 void setPukEntryProgressDialog(ProgressDialog dialog) {
Tyler Gunn3fc09c02020-05-08 16:35:55 -0700552 Log.i(LOG_TAG, "setPukEntryProgressDialog - set to "
553 + (dialog == null ? "null" : "activity"));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700554 mPUKEntryProgressDialog = dialog;
555 }
556
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700557 KeyguardManager getKeyguardManager() {
558 return mKeyguardManager;
559 }
560
561 private void onMMIComplete(AsyncResult r) {
562 if (VDBG) Log.d(LOG_TAG, "onMMIComplete()...");
563 MmiCode mmiCode = (MmiCode) r.result;
Stuart Scottdcf40a92014-12-09 10:45:01 -0800564 PhoneUtils.displayMMIComplete(mmiCode.getPhone(), getInstance(), mmiCode, null, null);
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700565 }
566
fionaxu80126972017-02-01 17:01:26 -0800567 private void initForNewRadioTechnology() {
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700568 if (DBG) Log.d(LOG_TAG, "initForNewRadioTechnology...");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700569 notifier.updateCallNotifierRegistrationsAfterRadioTechnologyChange();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700570 }
571
Chris Mantona09f3632016-02-09 14:48:42 -0800572 private void handleAirplaneModeChange(Context context, int newMode) {
573 int cellState = Settings.Global.getInt(context.getContentResolver(),
574 Settings.Global.CELL_ON, PhoneConstants.CELL_ON_FLAG);
575 boolean isAirplaneNewlyOn = (newMode == 1);
576 switch (cellState) {
577 case PhoneConstants.CELL_OFF_FLAG:
578 // Airplane mode does not affect the cell radio if user
579 // has turned it off.
580 break;
581 case PhoneConstants.CELL_ON_FLAG:
582 maybeTurnCellOff(context, isAirplaneNewlyOn);
583 break;
584 case PhoneConstants.CELL_OFF_DUE_TO_AIRPLANE_MODE_FLAG:
585 maybeTurnCellOn(context, isAirplaneNewlyOn);
586 break;
587 }
Hall Liu7f56e1a2019-07-10 14:41:14 -0700588 for (Phone phone : PhoneFactory.getPhones()) {
589 phone.getServiceStateTracker().onAirplaneModeChanged(isAirplaneNewlyOn);
590 }
Chris Mantona09f3632016-02-09 14:48:42 -0800591 }
592
593 /*
594 * Returns true if the radio must be turned off when entering airplane mode.
595 */
596 private boolean isCellOffInAirplaneMode(Context context) {
597 String airplaneModeRadios = Settings.Global.getString(context.getContentResolver(),
598 Settings.Global.AIRPLANE_MODE_RADIOS);
599 return airplaneModeRadios == null
600 || airplaneModeRadios.contains(Settings.Global.RADIO_CELL);
601 }
602
603 private void setRadioPowerOff(Context context) {
604 Log.i(LOG_TAG, "Turning radio off - airplane");
605 Settings.Global.putInt(context.getContentResolver(), Settings.Global.CELL_ON,
Eric Erfanian945409f2018-02-21 19:26:15 +0000606 PhoneConstants.CELL_OFF_DUE_TO_AIRPLANE_MODE_FLAG);
Meng Wang61307622019-10-23 14:08:43 -0700607 TelephonyProperties.airplane_mode_on(true); // true means int value 1
Chris Mantona09f3632016-02-09 14:48:42 -0800608 Settings.Global.putInt(getContentResolver(), Settings.Global.ENABLE_CELLULAR_ON_BOOT, 0);
609 PhoneUtils.setRadioPower(false);
610 }
611
612 private void setRadioPowerOn(Context context) {
613 Log.i(LOG_TAG, "Turning radio on - airplane");
614 Settings.Global.putInt(context.getContentResolver(), Settings.Global.CELL_ON,
615 PhoneConstants.CELL_ON_FLAG);
616 Settings.Global.putInt(getContentResolver(), Settings.Global.ENABLE_CELLULAR_ON_BOOT,
617 1);
Meng Wang61307622019-10-23 14:08:43 -0700618 TelephonyProperties.airplane_mode_on(false); // false means int value 0
Chris Mantona09f3632016-02-09 14:48:42 -0800619 PhoneUtils.setRadioPower(true);
620 }
621
622 private void maybeTurnCellOff(Context context, boolean isAirplaneNewlyOn) {
623 if (isAirplaneNewlyOn) {
Santos Cordone18902f2016-03-22 17:16:04 -0700624 // If we are trying to turn off the radio, make sure there are no active
625 // emergency calls. If there are, switch airplane mode back to off.
Tyler Gunn900d8fd2018-09-21 09:22:12 -0700626 TelecomManager tm = (TelecomManager) context.getSystemService(TELECOM_SERVICE);
627
628 if (tm != null && tm.isInEmergencyCall()) {
Santos Cordone18902f2016-03-22 17:16:04 -0700629 // Switch airplane mode back to off.
Jordan Liu0e819b12019-08-28 15:33:05 -0700630 ConnectivityManager cm =
631 (ConnectivityManager) context.getSystemService(CONNECTIVITY_SERVICE);
632 cm.setAirplaneMode(false);
Santos Cordone18902f2016-03-22 17:16:04 -0700633 Toast.makeText(this, R.string.radio_off_during_emergency_call, Toast.LENGTH_LONG)
634 .show();
635 Log.i(LOG_TAG, "Ignoring airplane mode: emergency call. Turning airplane off");
Chris Mantona09f3632016-02-09 14:48:42 -0800636 } else if (isCellOffInAirplaneMode(context)) {
637 setRadioPowerOff(context);
Santos Cordone18902f2016-03-22 17:16:04 -0700638 } else {
Chris Mantona09f3632016-02-09 14:48:42 -0800639 Log.i(LOG_TAG, "Ignoring airplane mode: settings prevent cell radio power off");
Santos Cordone18902f2016-03-22 17:16:04 -0700640 }
Chris Mantona09f3632016-02-09 14:48:42 -0800641 }
642 }
643
644 private void maybeTurnCellOn(Context context, boolean isAirplaneNewlyOn) {
645 if (!isAirplaneNewlyOn) {
646 setRadioPowerOn(context);
Santos Cordone18902f2016-03-22 17:16:04 -0700647 }
648 }
649
Santos Cordon593ab382013-08-06 21:58:23 -0700650 /**
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700651 * Receiver for misc intent broadcasts the Phone app cares about.
652 */
653 private class PhoneAppBroadcastReceiver extends BroadcastReceiver {
654 @Override
655 public void onReceive(Context context, Intent intent) {
656 String action = intent.getAction();
657 if (action.equals(Intent.ACTION_AIRPLANE_MODE_CHANGED)) {
Santos Cordone18902f2016-03-22 17:16:04 -0700658 int airplaneMode = Settings.Global.getInt(getContentResolver(),
659 Settings.Global.AIRPLANE_MODE_ON, AIRPLANE_OFF);
660 // Treat any non-OFF values as ON.
661 if (airplaneMode != AIRPLANE_OFF) {
662 airplaneMode = AIRPLANE_ON;
663 }
Chris Mantona09f3632016-02-09 14:48:42 -0800664 handleAirplaneModeChange(context, airplaneMode);
Amit Mahajanf5d92c82018-11-02 17:44:40 -0700665 } else if (action.equals(TelephonyIntents.ACTION_SIM_STATE_CHANGED)) {
666 // re-register as it may be a new IccCard
667 int phoneId = intent.getIntExtra(PhoneConstants.PHONE_KEY,
668 SubscriptionManager.INVALID_PHONE_INDEX);
669 if (SubscriptionManager.isValidPhoneId(phoneId)) {
670 PhoneUtils.unregisterIccStatus(mHandler, phoneId);
671 PhoneUtils.registerIccStatus(mHandler, EVENT_SIM_NETWORK_LOCKED, phoneId);
672 }
Nazish Tabassum160d2112019-12-23 17:31:33 +0530673 String iccStatus = intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE);
674 mHandler.sendMessage(mHandler.obtainMessage(EVENT_SIM_STATE_CHANGED,
675 new EventSimStateChangedBag(phoneId, iccStatus)));
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700676 } else if (action.equals(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED)) {
677 String newPhone = intent.getStringExtra(PhoneConstants.PHONE_NAME_KEY);
fionaxu80126972017-02-01 17:01:26 -0800678 Log.d(LOG_TAG, "Radio technology switched. Now " + newPhone + " is active.");
679 initForNewRadioTechnology();
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700680 } else if (action.equals(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED)) {
681 handleServiceStateChanged(intent);
682 } else if (action.equals(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED)) {
Sandeep Kuntade73a6a2014-10-15 18:45:56 +0530683 int phoneId = intent.getIntExtra(PhoneConstants.PHONE_KEY, 0);
Srikanth Chintala079912a2016-03-03 16:35:01 +0530684 phoneInEcm = PhoneFactory.getPhone(phoneId);
Sandeep Kuntade73a6a2014-10-15 18:45:56 +0530685 Log.d(LOG_TAG, "Emergency Callback Mode. phoneId:" + phoneId);
686 if (phoneInEcm != null) {
687 if (TelephonyCapabilities.supportsEcm(phoneInEcm)) {
688 Log.d(LOG_TAG, "Emergency Callback Mode arrived in PhoneApp.");
689 // Start Emergency Callback Mode service
Daniel Bright30efde42020-01-09 22:11:15 -0800690 if (intent.getBooleanExtra(
691 TelephonyManager.EXTRA_PHONE_IN_ECM_STATE, false)) {
Sandeep Kuntade73a6a2014-10-15 18:45:56 +0530692 context.startService(new Intent(context,
693 EmergencyCallbackModeService.class));
694 } else {
695 phoneInEcm = null;
696 }
697 } else {
698 // It doesn't make sense to get ACTION_EMERGENCY_CALLBACK_MODE_CHANGED
699 // on a device that doesn't support ECM in the first place.
700 Log.e(LOG_TAG, "Got ACTION_EMERGENCY_CALLBACK_MODE_CHANGED, but "
701 + "ECM isn't supported for phone: " + phoneInEcm.getPhoneName());
702 phoneInEcm = null;
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700703 }
704 } else {
Sandeep Kuntade73a6a2014-10-15 18:45:56 +0530705 Log.w(LOG_TAG, "phoneInEcm is null.");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700706 }
Jack Yu1a2fc352017-07-14 17:14:37 -0700707 } else if (action.equals(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED)) {
708 // Roaming status could be overridden by carrier config, so we need to update it.
709 if (VDBG) Log.v(LOG_TAG, "carrier config changed.");
710 updateDataRoamingStatus();
chen xubaf9fe52019-07-02 17:28:24 -0700711 updateLimitedSimFunctionForDualSim();
Jack Yu1a2fc352017-07-14 17:14:37 -0700712 } else if (action.equals(TelephonyIntents.ACTION_DEFAULT_DATA_SUBSCRIPTION_CHANGED)) {
713 // We also need to pay attention when default data subscription changes.
714 if (VDBG) Log.v(LOG_TAG, "default data sub changed.");
715 mDefaultDataSubId = SubscriptionManager.getDefaultDataSubscriptionId();
716 registerSettingsObserver();
717 Phone phone = getPhone(mDefaultDataSubId);
718 if (phone != null) {
719 updateDataRoamingStatus();
720 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700721 }
722 }
723 }
724
Brad Ebinger28626122017-08-10 14:13:35 -0700725 private class SipReceiver extends BroadcastReceiver {
726
727 @Override
728 public void onReceive(Context context, Intent intent) {
729 String action = intent.getAction();
730
731 SipAccountRegistry sipAccountRegistry = SipAccountRegistry.getInstance();
732 if (action.equals(Intent.ACTION_BOOT_COMPLETED)) {
733 SipUtil.startSipService();
734 } else if (action.equals(SipManager.ACTION_SIP_SERVICE_UP)
735 || action.equals(SipManager.ACTION_SIP_CALL_OPTION_CHANGED)) {
736 sipAccountRegistry.setup(context);
Grace Jiab95592a2020-01-15 14:12:24 -0800737 } else if (action.equals(SipManager.ACTION_SIP_REMOVE_PROFILE)) {
Brad Ebinger28626122017-08-10 14:13:35 -0700738 if (DBG) {
739 Log.d(LOG_TAG, "SIP_REMOVE_PHONE "
740 + intent.getStringExtra(SipManager.EXTRA_LOCAL_URI));
741 }
742 sipAccountRegistry.removeSipProfile(intent.getStringExtra(
743 SipManager.EXTRA_LOCAL_URI));
744 } else {
745 if (DBG) Log.d(LOG_TAG, "onReceive, action not processed: " + action);
746 }
747 }
748 }
749
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700750 private void handleServiceStateChanged(Intent intent) {
751 /**
752 * This used to handle updating EriTextWidgetProvider this routine
753 * and and listening for ACTION_SERVICE_STATE_CHANGED intents could
754 * be removed. But leaving just in case it might be needed in the near
755 * future.
756 */
757
Jack Yu1a2fc352017-07-14 17:14:37 -0700758 if (VDBG) Log.v(LOG_TAG, "handleServiceStateChanged");
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700759 // If service just returned, start sending out the queued messages
Santos Cordonc593d002015-06-03 15:41:15 -0700760 Bundle extras = intent.getExtras();
761 if (extras != null) {
762 ServiceState ss = ServiceState.newFromBundle(extras);
763 if (ss != null) {
764 int state = ss.getState();
Jayachandran C2ef9a482017-05-12 22:07:47 -0700765 int subId = intent.getIntExtra(PhoneConstants.SUBSCRIPTION_KEY,
766 SubscriptionManager.INVALID_SUBSCRIPTION_ID);
767 notificationMgr.updateNetworkSelection(state, subId);
Jack Yu1a2fc352017-07-14 17:14:37 -0700768
769 if (VDBG) {
770 Log.v(LOG_TAG, "subId=" + subId + ",mDefaultDataSubId="
771 + mDefaultDataSubId + ",ss roaming=" + ss.getDataRoaming());
772 }
773 if (subId == mDefaultDataSubId) {
774 updateDataRoamingStatus();
775 }
Santos Cordonc593d002015-06-03 15:41:15 -0700776 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700777 }
778 }
779
Jack Yu1a2fc352017-07-14 17:14:37 -0700780 /**
Jordan Liuff2ccd72019-07-23 15:54:41 -0700781 * @return whether or not we should show a notification when connecting to data roaming if the
782 * user has data roaming enabled
783 */
784 private boolean shouldShowDataConnectedRoaming(int subId) {
785 PersistableBundle config = getCarrierConfigForSubId(subId);
786 return config.getBoolean(CarrierConfigManager
787 .KEY_SHOW_DATA_CONNECTED_ROAMING_NOTIFICATION_BOOL);
788 }
789
790 /**
Jack Yu1a2fc352017-07-14 17:14:37 -0700791 * When roaming, if mobile data cannot be established due to data roaming not enabled, we need
792 * to notify the user so they can enable it through settings. Vise versa if the condition
793 * changes, we need to dismiss the notification.
794 */
795 private void updateDataRoamingStatus() {
796 if (VDBG) Log.v(LOG_TAG, "updateDataRoamingStatus");
797 Phone phone = getPhone(mDefaultDataSubId);
798 if (phone == null) {
799 Log.w(LOG_TAG, "Can't get phone with sub id = " + mDefaultDataSubId);
800 return;
801 }
802
803 DataConnectionReasons reasons = new DataConnectionReasons();
Jack Yu311536f2018-11-26 11:20:48 -0800804 boolean dataAllowed = phone.isDataAllowed(ApnSetting.TYPE_DEFAULT, reasons);
Jack Yu1a2fc352017-07-14 17:14:37 -0700805 mDataRoamingNotifLog.log("dataAllowed=" + dataAllowed + ", reasons=" + reasons);
806 if (VDBG) Log.v(LOG_TAG, "dataAllowed=" + dataAllowed + ", reasons=" + reasons);
Jordan Liuff2ccd72019-07-23 15:54:41 -0700807 if (!dataAllowed && reasons.containsOnly(DataDisallowedReasonType.ROAMING_DISABLED)) {
808 // No need to show it again if we never cancelled it explicitly.
809 if (mPrevRoamingNotification == ROAMING_NOTIFICATION_DISCONNECTED) return;
Jack Yu1a2fc352017-07-14 17:14:37 -0700810 // If the only reason of no data is data roaming disabled, then we notify the user
811 // so the user can turn on data roaming.
Jordan Liuff2ccd72019-07-23 15:54:41 -0700812 mPrevRoamingNotification = ROAMING_NOTIFICATION_DISCONNECTED;
Jack Yu1a2fc352017-07-14 17:14:37 -0700813 Log.d(LOG_TAG, "Show roaming disconnected notification");
Jordan Liuff2ccd72019-07-23 15:54:41 -0700814 mDataRoamingNotifLog.log("Show roaming off.");
Pengquan Meng8783d932017-10-16 14:57:40 -0700815 Message msg = mHandler.obtainMessage(EVENT_DATA_ROAMING_DISCONNECTED);
816 msg.arg1 = mDefaultDataSubId;
817 msg.sendToTarget();
Jordan Liuff2ccd72019-07-23 15:54:41 -0700818 } else if (dataAllowed && dataIsNowRoaming(mDefaultDataSubId)
819 && shouldShowDataConnectedRoaming(mDefaultDataSubId)) {
820 // No need to show it again if we never cancelled it explicitly, or carrier config
821 // indicates this is not needed.
822 if (mPrevRoamingNotification == ROAMING_NOTIFICATION_CONNECTED) return;
823 mPrevRoamingNotification = ROAMING_NOTIFICATION_CONNECTED;
824 Log.d(LOG_TAG, "Show roaming connected notification");
825 mDataRoamingNotifLog.log("Show roaming on.");
826 Message msg = mHandler.obtainMessage(EVENT_DATA_ROAMING_CONNECTED);
827 msg.arg1 = mDefaultDataSubId;
828 msg.sendToTarget();
829 } else if (mPrevRoamingNotification != ROAMING_NOTIFICATION_NO_NOTIFICATION) {
830 // Otherwise we either 1) we are not roaming or 2) roaming is off but ROAMING_DISABLED
831 // is not the only data disable reason. In this case we dismiss the notification we
832 // showed earlier.
833 mPrevRoamingNotification = ROAMING_NOTIFICATION_NO_NOTIFICATION;
834 Log.d(LOG_TAG, "Dismiss roaming notification");
Jack Yu1a2fc352017-07-14 17:14:37 -0700835 mDataRoamingNotifLog.log("Hide. data allowed=" + dataAllowed + ", reasons=" + reasons);
836 mHandler.sendEmptyMessage(EVENT_DATA_ROAMING_OK);
837 }
838 }
839
Jordan Liuff2ccd72019-07-23 15:54:41 -0700840 /**
841 *
842 * @param subId to check roaming on
843 * @return whether we have transitioned to dataRoaming
844 */
845 private boolean dataIsNowRoaming(int subId) {
846 return getPhone(subId).getServiceState().getDataRoaming();
847 }
848
chen xubaf9fe52019-07-02 17:28:24 -0700849 private void updateLimitedSimFunctionForDualSim() {
850 if (DBG) Log.d(LOG_TAG, "updateLimitedSimFunctionForDualSim");
851 // check conditions to display limited SIM function notification under dual SIM
852 SubscriptionManager subMgr = (SubscriptionManager) getSystemService(
853 Context.TELEPHONY_SUBSCRIPTION_SERVICE);
854 List<SubscriptionInfo> subList = subMgr.getActiveSubscriptionInfoList(false);
855 if (subList != null && subList.size() > 1) {
856 CarrierConfigManager configMgr = (CarrierConfigManager)
857 getSystemService(Context.CARRIER_CONFIG_SERVICE);
858 for (SubscriptionInfo info : subList) {
859 PersistableBundle b = configMgr.getConfigForSubId(info.getSubscriptionId());
860 if (b != null) {
861 if (b.getBoolean(CarrierConfigManager
862 .KEY_LIMITED_SIM_FUNCTION_NOTIFICATION_FOR_DSDS_BOOL)) {
863 notificationMgr.showLimitedSimFunctionWarningNotification(
864 info.getSubscriptionId(),
865 info.getDisplayName().toString());
866 } else {
867 notificationMgr.dismissLimitedSimFunctionWarningNotification(
868 info.getSubscriptionId());
869 }
870 }
871 }
872 } else {
873 // cancel notifications for all subs
874 notificationMgr.dismissLimitedSimFunctionWarningNotification(
875 SubscriptionManager.INVALID_SUBSCRIPTION_ID);
876 }
877 notificationMgr.dismissLimitedSimFunctionWarningNotificationForInactiveSubs();
878
879 }
880
Sandeep Kuntade73a6a2014-10-15 18:45:56 +0530881 public Phone getPhoneInEcm() {
882 return phoneInEcm;
883 }
884
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700885 /**
Tyler Gunn9c1071f2014-12-09 10:07:54 -0800886 * Triggers a refresh of the message waiting (voicemail) indicator.
887 *
888 * @param subId the subscription id we should refresh the notification for.
889 */
890 public void refreshMwiIndicator(int subId) {
891 notificationMgr.refreshMwi(subId);
892 }
893
894 /**
Pengquan Mengdd9ac822018-09-20 15:25:35 -0700895 * Called when the network selection on the subscription {@code subId} is changed by the user.
896 *
897 * @param subId the subscription id.
898 */
899 public void onNetworkSelectionChanged(int subId) {
900 Phone phone = getPhone(subId);
901 if (phone != null) {
902 notificationMgr.updateNetworkSelection(phone.getServiceState().getState(), subId);
903 } else {
904 Log.w(LOG_TAG, "onNetworkSelectionChanged on null phone, subId: " + subId);
905 }
906 }
907
908 /**
Jack Yu1a2fc352017-07-14 17:14:37 -0700909 * Dump the state of the object, add calls to other objects as desired.
910 *
911 * @param fd File descriptor
912 * @param printWriter Print writer
913 * @param args Arguments
914 */
915 public void dump(FileDescriptor fd, PrintWriter printWriter, String[] args) {
916 IndentingPrintWriter pw = new IndentingPrintWriter(printWriter, " ");
917 pw.println("------- PhoneGlobals -------");
918 pw.increaseIndent();
Jordan Liuff2ccd72019-07-23 15:54:41 -0700919 pw.println("mPrevRoamingNotification=" + mPrevRoamingNotification);
Jack Yu1a2fc352017-07-14 17:14:37 -0700920 pw.println("mDefaultDataSubId=" + mDefaultDataSubId);
921 pw.println("mDataRoamingNotifLog:");
Keun young Parkdebb8532019-05-30 16:35:27 -0700922 pw.println("isSmsCapable=" + TelephonyManager.from(this).isSmsCapable());
Jack Yu1a2fc352017-07-14 17:14:37 -0700923 pw.increaseIndent();
924 mDataRoamingNotifLog.dump(fd, pw, args);
925 pw.decreaseIndent();
Brad Ebinger05f52c22019-12-05 13:03:21 -0800926 pw.println("ImsResolver:");
927 pw.increaseIndent();
928 try {
929 if (mImsResolver != null) mImsResolver.dump(fd, pw, args);
930 } catch (Exception e) {
931 e.printStackTrace();
932 }
933 pw.decreaseIndent();
Brad Ebingera68a4972020-01-30 17:31:23 -0800934 pw.println("RcsService:");
935 try {
936 if (mTelephonyRcsService != null) mTelephonyRcsService.dump(fd, pw, args);
937 } catch (Exception e) {
938 e.printStackTrace();
939 }
Jack Yu1a2fc352017-07-14 17:14:37 -0700940 pw.decreaseIndent();
941 pw.println("------- End PhoneGlobals -------");
942 }
Santos Cordon7d4ddf62013-07-10 11:58:08 -0700943}