blob: 4025bbb542976d68656c9a0cdb6379da89a70613 [file] [log] [blame]
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001/**
2 * Copyright (c) 2015, 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
Jonathan Basseri6465afd2015-02-25 13:05:57 -080017package com.android.phone;
18
Jonathan Basseri65273c82017-07-25 15:08:42 -070019import static android.service.carrier.CarrierService.ICarrierServiceWrapper.KEY_CONFIG_BUNDLE;
20import static android.service.carrier.CarrierService.ICarrierServiceWrapper.RESULT_ERROR;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080021
Jonathan Basseri11f89572015-05-05 11:57:39 -070022import android.annotation.NonNull;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080023import android.content.BroadcastReceiver;
24import android.content.ComponentName;
25import android.content.Context;
26import android.content.Intent;
27import android.content.IntentFilter;
28import android.content.ServiceConnection;
Jonathan Basseri7697cae2015-07-06 15:49:23 -070029import android.content.SharedPreferences;
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070030import android.content.pm.PackageInfo;
Jonathan Basseric31f1f32015-05-12 10:13:03 -070031import android.content.pm.PackageManager;
Junda Liu43d723a2015-05-12 17:23:45 -070032import android.os.Binder;
Jonathan Basseri7697cae2015-07-06 15:49:23 -070033import android.os.Build;
Jonathan Basseri65273c82017-07-25 15:08:42 -070034import android.os.Bundle;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080035import android.os.Handler;
36import android.os.IBinder;
37import android.os.Message;
Jonathan Basseric31f1f32015-05-12 10:13:03 -070038import android.os.PersistableBundle;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080039import android.os.RemoteException;
Jonathan Basseri65273c82017-07-25 15:08:42 -070040import android.os.ResultReceiver;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080041import android.os.ServiceManager;
Jonathan Basseri7697cae2015-07-06 15:49:23 -070042import android.preference.PreferenceManager;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080043import android.service.carrier.CarrierIdentifier;
Zach Johnson36d7aab2015-05-22 15:43:00 -070044import android.service.carrier.CarrierService;
45import android.service.carrier.ICarrierService;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080046import android.telephony.CarrierConfigManager;
47import android.telephony.SubscriptionManager;
48import android.telephony.TelephonyManager;
chen xu3fd54572019-03-26 17:01:15 -070049import android.util.LocalLog;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080050import android.util.Log;
51
52import com.android.internal.telephony.ICarrierConfigLoader;
53import com.android.internal.telephony.IccCardConstants;
54import com.android.internal.telephony.Phone;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080055import com.android.internal.telephony.PhoneFactory;
Nathan Harold17daf212019-03-13 22:33:01 -070056import com.android.internal.telephony.SubscriptionInfoUpdater;
Jeff Davidsona8e4e242018-03-15 17:16:18 -070057import com.android.internal.telephony.TelephonyPermissions;
Qiongcheng Luoe7de61b2018-08-06 10:20:09 +080058import com.android.internal.util.ArrayUtils;
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070059import com.android.internal.util.FastXmlSerializer;
shuoq26a3a4c2016-12-16 11:06:48 -080060import com.android.internal.util.IndentingPrintWriter;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080061
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070062import org.xmlpull.v1.XmlPullParser;
63import org.xmlpull.v1.XmlPullParserException;
64import org.xmlpull.v1.XmlPullParserFactory;
65
66import java.io.File;
Junda Liu43d723a2015-05-12 17:23:45 -070067import java.io.FileDescriptor;
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070068import java.io.FileInputStream;
69import java.io.FileNotFoundException;
70import java.io.FileOutputStream;
Jonathan Basseri1f743c92015-05-15 00:19:46 -070071import java.io.FilenameFilter;
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070072import java.io.IOException;
Junda Liu43d723a2015-05-12 17:23:45 -070073import java.io.PrintWriter;
shuoq26a3a4c2016-12-16 11:06:48 -080074import java.util.ArrayList;
75import java.util.Arrays;
76import java.util.Collections;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080077import java.util.List;
78
79/**
80 * CarrierConfigLoader binds to privileged carrier apps to fetch carrier config overlays.
Jonathan Basseri6465afd2015-02-25 13:05:57 -080081 */
82
83public class CarrierConfigLoader extends ICarrierConfigLoader.Stub {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070084 private static final String LOG_TAG = "CarrierConfigLoader";
Meng Wang33ad2bc2017-03-16 20:21:20 -070085
86 // Package name for platform carrier config app, bundled with system image.
87 private final String mPlatformCarrierConfigPackage;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080088
89 /** The singleton instance. */
90 private static CarrierConfigLoader sInstance;
91 // The context for phone app, passed from PhoneGlobals.
92 private Context mContext;
93 // Carrier configs from default app, indexed by phoneID.
Jonathan Basseric31f1f32015-05-12 10:13:03 -070094 private PersistableBundle[] mConfigFromDefaultApp;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080095 // Carrier configs from privileged carrier config app, indexed by phoneID.
Jonathan Basseric31f1f32015-05-12 10:13:03 -070096 private PersistableBundle[] mConfigFromCarrierApp;
Hall Liu506724b2018-10-22 18:16:14 -070097 // Carrier configs that are provided via the override test API, indexed by phone ID.
98 private PersistableBundle[] mOverrideConfigs;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080099 // Service connection for binding to config app.
Zach Johnson36d7aab2015-05-22 15:43:00 -0700100 private CarrierServiceConnection[] mServiceConnection;
Junda Liu03aad762017-07-21 13:32:17 -0700101 // Whether we have sent config change bcast for each phone id.
102 private boolean[] mHasSentConfigChange;
Nathan Harold17daf212019-03-13 22:33:01 -0700103 // SubscriptionInfoUpdater
104 private final SubscriptionInfoUpdater mSubscriptionInfoUpdater;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800105
Nanxi Chen3d670502016-03-17 16:32:09 -0700106 // Broadcast receiver for Boot intents, register intent filter in construtor.
107 private final BroadcastReceiver mBootReceiver = new ConfigLoaderBroadcastReceiver();
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800108 // Broadcast receiver for SIM and pkg intents, register intent filter in constructor.
Nanxi Chen3d670502016-03-17 16:32:09 -0700109 private final BroadcastReceiver mPackageReceiver = new ConfigLoaderBroadcastReceiver();
chen xu3fd54572019-03-26 17:01:15 -0700110 private final LocalLog mCarrierConfigLoadingLog = new LocalLog(50);
111
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800112
113 // Message codes; see mHandler below.
114 // Request from SubscriptionInfoUpdater when SIM becomes absent or error.
115 private static final int EVENT_CLEAR_CONFIG = 0;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800116 // Has connected to default app.
117 private static final int EVENT_CONNECTED_TO_DEFAULT = 3;
118 // Has connected to carrier app.
119 private static final int EVENT_CONNECTED_TO_CARRIER = 4;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700120 // Config has been loaded from default app (or cache).
121 private static final int EVENT_FETCH_DEFAULT_DONE = 5;
122 // Config has been loaded from carrier app (or cache).
123 private static final int EVENT_FETCH_CARRIER_DONE = 6;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700124 // Attempt to fetch from default app or read from XML.
Jonathan Basseri65273c82017-07-25 15:08:42 -0700125 private static final int EVENT_DO_FETCH_DEFAULT = 7;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700126 // Attempt to fetch from carrier app or read from XML.
Jonathan Basseri65273c82017-07-25 15:08:42 -0700127 private static final int EVENT_DO_FETCH_CARRIER = 8;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700128 // A package has been installed, uninstalled, or updated.
129 private static final int EVENT_PACKAGE_CHANGED = 9;
Jonathan Basseri930701e2015-06-11 20:56:43 -0700130 // Bind timed out for the default app.
131 private static final int EVENT_BIND_DEFAULT_TIMEOUT = 10;
132 // Bind timed out for a carrier app.
133 private static final int EVENT_BIND_CARRIER_TIMEOUT = 11;
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700134 // Check if the system fingerprint has changed.
135 private static final int EVENT_CHECK_SYSTEM_UPDATE = 12;
Nanxi Chen3d670502016-03-17 16:32:09 -0700136 // Rerun carrier config binding after system is unlocked.
137 private static final int EVENT_SYSTEM_UNLOCKED = 13;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700138 // Fetching config timed out from the default app.
139 private static final int EVENT_FETCH_DEFAULT_TIMEOUT = 14;
140 // Fetching config timed out from a carrier app.
141 private static final int EVENT_FETCH_CARRIER_TIMEOUT = 15;
Nathan Harold17daf212019-03-13 22:33:01 -0700142 // SubscriptionInfoUpdater has finished updating the sub for the carrier config.
143 private static final int EVENT_SUBSCRIPTION_INFO_UPDATED = 16;
Jonathan Basseri930701e2015-06-11 20:56:43 -0700144
Junda Liu6cb45002016-03-22 17:18:20 -0700145 private static final int BIND_TIMEOUT_MILLIS = 30000;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800146
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700147 // Tags used for saving and restoring XML documents.
148 private static final String TAG_DOCUMENT = "carrier_config";
149 private static final String TAG_VERSION = "package_version";
150 private static final String TAG_BUNDLE = "bundle_data";
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800151
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700152 // SharedPreferences key for last known build fingerprint.
153 private static final String KEY_FINGERPRINT = "build_fingerprint";
154
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800155 // Handler to process various events.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700156 //
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700157 // For each phoneId, the event sequence should be:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700158 // fetch default, connected to default, fetch default (async), fetch default done,
159 // fetch carrier, connected to carrier, fetch carrier (async), fetch carrier done.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700160 //
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700161 // If there is a saved config file for either the default app or the carrier app, we skip
162 // binding to the app and go straight from fetch to loaded.
163 //
164 // At any time, at most one connection is active. If events are not in this order, previous
165 // connection will be unbound, so only latest event takes effect.
166 //
167 // We broadcast ACTION_CARRIER_CONFIG_CHANGED after:
168 // 1. loading from carrier app (even if read from a file)
169 // 2. loading from default app if there is no carrier app (even if read from a file)
170 // 3. clearing config (e.g. due to sim removal)
171 // 4. encountering bind or IPC error
Jonathan Basseri65273c82017-07-25 15:08:42 -0700172 private class ConfigHandler extends Handler {
173 @Override
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800174 public void handleMessage(Message msg) {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700175 final int phoneId = msg.arg1;
chen xu26b338c2019-04-17 23:44:43 -0700176 logWithLocalLog("mHandler: " + msg.what + " phoneId: " + phoneId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800177 switch (msg.what) {
178 case EVENT_CLEAR_CONFIG:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700179 {
Sooraj Sasindran52119cd2017-10-23 16:24:28 -0700180 /* Ignore clear configuration request if device is being shutdown. */
181 Phone phone = PhoneFactory.getPhone(phoneId);
182 if (phone != null) {
183 if (phone.isShuttingDown()) {
184 break;
185 }
186 }
187
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800188 mConfigFromDefaultApp[phoneId] = null;
189 mConfigFromCarrierApp[phoneId] = null;
190 mServiceConnection[phoneId] = null;
Amit Mahajanf8088ab2018-03-02 15:24:07 -0800191 broadcastConfigChangedIntent(phoneId, false);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800192 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700193 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700194
Nanxi Chen3d670502016-03-17 16:32:09 -0700195 case EVENT_SYSTEM_UNLOCKED:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700196 {
Nanxi Chen3d670502016-03-17 16:32:09 -0700197 for (int i = 0; i < TelephonyManager.from(mContext).getPhoneCount(); ++i) {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700198 // When user unlock device, we should only try to send broadcast again if we
199 // have sent it before unlock. This will avoid we try to load carrier config
200 // when SIM is still loading when unlock happens.
Junda Liu03aad762017-07-21 13:32:17 -0700201 if (mHasSentConfigChange[i]) {
202 updateConfigForPhoneId(i);
203 }
Nanxi Chen3d670502016-03-17 16:32:09 -0700204 }
205 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700206 }
Nanxi Chen3d670502016-03-17 16:32:09 -0700207
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700208 case EVENT_PACKAGE_CHANGED:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700209 {
210 final String carrierPackageName = (String) msg.obj;
211 // Only update if there are cached config removed to avoid updating config for
212 // unrelated packages.
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700213 if (clearCachedConfigForPackage(carrierPackageName)) {
Junda Liu8a8a53a2015-05-15 16:19:57 -0700214 int numPhones = TelephonyManager.from(mContext).getPhoneCount();
215 for (int i = 0; i < numPhones; ++i) {
216 updateConfigForPhoneId(i);
217 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700218 }
219 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700220 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700221
Jonathan Basseri65273c82017-07-25 15:08:42 -0700222 case EVENT_DO_FETCH_DEFAULT:
223 {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700224 final PersistableBundle config =
Yuchen Dongc15afed2018-04-26 17:05:22 +0800225 restoreConfigFromXml(mPlatformCarrierConfigPackage, phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700226 if (config != null) {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700227 log(
228 "Loaded config from XML. package="
229 + mPlatformCarrierConfigPackage
230 + " phoneId="
231 + phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700232 mConfigFromDefaultApp[phoneId] = config;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700233 Message newMsg = obtainMessage(EVENT_FETCH_DEFAULT_DONE, phoneId, -1);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700234 newMsg.getData().putBoolean("loaded_from_xml", true);
235 mHandler.sendMessage(newMsg);
236 } else {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700237 // No cached config, so fetch it from the default app.
238 if (bindToConfigPackage(
239 mPlatformCarrierConfigPackage,
240 phoneId,
241 EVENT_CONNECTED_TO_DEFAULT)) {
242 sendMessageDelayed(
243 obtainMessage(EVENT_BIND_DEFAULT_TIMEOUT, phoneId, -1),
Jonathan Basseri930701e2015-06-11 20:56:43 -0700244 BIND_TIMEOUT_MILLIS);
245 } else {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700246 // Send broadcast if bind fails.
Nathan Harold17daf212019-03-13 22:33:01 -0700247 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700248 // TODO: We *must* call unbindService even if bindService returns false.
249 // (And possibly if SecurityException was thrown.)
chen xu3fd54572019-03-26 17:01:15 -0700250 loge("binding to default app: "
251 + mPlatformCarrierConfigPackage + " fails");
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700252 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800253 }
254 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700255 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800256
257 case EVENT_CONNECTED_TO_DEFAULT:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700258 {
Jonathan Basseri930701e2015-06-11 20:56:43 -0700259 removeMessages(EVENT_BIND_DEFAULT_TIMEOUT);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700260 final CarrierServiceConnection conn = (CarrierServiceConnection) msg.obj;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800261 // If new service connection has been created, unbind.
262 if (mServiceConnection[phoneId] != conn || conn.service == null) {
263 mContext.unbindService(conn);
264 break;
265 }
chen xu02581692018-11-11 19:03:44 -0800266 final CarrierIdentifier carrierId = getCarrierIdentifierForPhoneId(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700267 // ResultReceiver callback will execute in this Handler's thread.
268 final ResultReceiver resultReceiver =
269 new ResultReceiver(this) {
270 @Override
271 public void onReceiveResult(int resultCode, Bundle resultData) {
272 mContext.unbindService(conn);
273 // If new service connection has been created, this is stale.
274 if (mServiceConnection[phoneId] != conn) {
275 loge("Received response for stale request.");
276 return;
277 }
278 removeMessages(EVENT_FETCH_DEFAULT_TIMEOUT);
279 if (resultCode == RESULT_ERROR || resultData == null) {
280 // On error, abort config fetching.
281 loge("Failed to get carrier config");
Nathan Harold17daf212019-03-13 22:33:01 -0700282 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700283 return;
284 }
285 PersistableBundle config =
286 resultData.getParcelable(KEY_CONFIG_BUNDLE);
Yuchen Dongc15afed2018-04-26 17:05:22 +0800287 saveConfigToXml(
288 mPlatformCarrierConfigPackage, phoneId, config);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700289 mConfigFromDefaultApp[phoneId] = config;
290 sendMessage(
291 obtainMessage(
292 EVENT_FETCH_DEFAULT_DONE, phoneId, -1));
293 }
294 };
295 // Now fetch the config asynchronously from the ICarrierService.
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800296 try {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700297 ICarrierService carrierService =
298 ICarrierService.Stub.asInterface(conn.service);
299 carrierService.getCarrierConfig(carrierId, resultReceiver);
chen xu3fd54572019-03-26 17:01:15 -0700300 logWithLocalLog("fetch config for default app: "
301 + mPlatformCarrierConfigPackage
302 + " carrierid: " + carrierId.toString());
Jonathan Basseri65273c82017-07-25 15:08:42 -0700303 } catch (RemoteException e) {
chen xu3fd54572019-03-26 17:01:15 -0700304 loge("Failed to get carrier config from default app: " +
305 mPlatformCarrierConfigPackage + " err: " + e.toString());
Jonathan Basseri65273c82017-07-25 15:08:42 -0700306 mContext.unbindService(conn);
307 break; // So we don't set a timeout.
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800308 }
Jonathan Basseri65273c82017-07-25 15:08:42 -0700309 sendMessageDelayed(
310 obtainMessage(EVENT_FETCH_DEFAULT_TIMEOUT, phoneId, -1),
311 BIND_TIMEOUT_MILLIS);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800312 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700313 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800314
Jonathan Basseri930701e2015-06-11 20:56:43 -0700315 case EVENT_BIND_DEFAULT_TIMEOUT:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700316 case EVENT_FETCH_DEFAULT_TIMEOUT:
317 {
318 // If a ResponseReceiver callback is in the queue when this happens, we will
319 // unbind twice and throw an exception.
Jonathan Basseri930701e2015-06-11 20:56:43 -0700320 mContext.unbindService(mServiceConnection[phoneId]);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700321 removeMessages(EVENT_FETCH_DEFAULT_TIMEOUT);
Jonathan Basseri930701e2015-06-11 20:56:43 -0700322 broadcastConfigChangedIntent(phoneId);
chen xu3fd54572019-03-26 17:01:15 -0700323 loge("bind/fetch time out from " + mPlatformCarrierConfigPackage);
Nathan Harold17daf212019-03-13 22:33:01 -0700324 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri930701e2015-06-11 20:56:43 -0700325 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700326 }
Jonathan Basseri930701e2015-06-11 20:56:43 -0700327
Jonathan Basseri65273c82017-07-25 15:08:42 -0700328 case EVENT_FETCH_DEFAULT_DONE:
329 {
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700330 // If we attempted to bind to the app, but the service connection is null, then
331 // config was cleared while we were waiting and we should not continue.
332 if (!msg.getData().getBoolean("loaded_from_xml", false)
333 && mServiceConnection[phoneId] == null) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800334 break;
335 }
Jonathan Basseri65273c82017-07-25 15:08:42 -0700336 final String carrierPackageName = getCarrierPackageForPhoneId(phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700337 if (carrierPackageName != null) {
338 log("Found carrier config app: " + carrierPackageName);
Jordan Liu38a614c2019-03-20 15:01:17 -0700339 sendMessage(obtainMessage(EVENT_DO_FETCH_CARRIER, phoneId, -1));
Jonathan Basserib919e932015-05-27 16:53:08 +0000340 } else {
Nathan Harold17daf212019-03-13 22:33:01 -0700341 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri4ae2e7c2015-05-15 00:19:46 -0700342 }
343 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700344 }
Jonathan Basseri4ae2e7c2015-05-15 00:19:46 -0700345
Jonathan Basseri65273c82017-07-25 15:08:42 -0700346 case EVENT_DO_FETCH_CARRIER:
347 {
348 final String carrierPackageName = getCarrierPackageForPhoneId(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700349 final PersistableBundle config =
Yuchen Dongc15afed2018-04-26 17:05:22 +0800350 restoreConfigFromXml(carrierPackageName, phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700351 if (config != null) {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700352 log(
353 "Loaded config from XML. package="
354 + carrierPackageName
355 + " phoneId="
356 + phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700357 mConfigFromCarrierApp[phoneId] = config;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700358 Message newMsg = obtainMessage(EVENT_FETCH_CARRIER_DONE, phoneId, -1);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700359 newMsg.getData().putBoolean("loaded_from_xml", true);
360 sendMessage(newMsg);
361 } else {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700362 // No cached config, so fetch it from a carrier app.
Jonathan Basseri40473a52015-08-14 14:36:29 -0700363 if (carrierPackageName != null
Jonathan Basseri65273c82017-07-25 15:08:42 -0700364 && bindToConfigPackage(
365 carrierPackageName,
366 phoneId,
367 EVENT_CONNECTED_TO_CARRIER)) {
368 sendMessageDelayed(
369 obtainMessage(EVENT_BIND_CARRIER_TIMEOUT, phoneId, -1),
Jonathan Basseri930701e2015-06-11 20:56:43 -0700370 BIND_TIMEOUT_MILLIS);
371 } else {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700372 // Send broadcast if bind fails.
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700373 broadcastConfigChangedIntent(phoneId);
chen xu3fd54572019-03-26 17:01:15 -0700374 loge("bind to carrier app: " + carrierPackageName + " fails");
Nathan Harold17daf212019-03-13 22:33:01 -0700375 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700376 }
377 }
378 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700379 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700380
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800381 case EVENT_CONNECTED_TO_CARRIER:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700382 {
Jonathan Basseri930701e2015-06-11 20:56:43 -0700383 removeMessages(EVENT_BIND_CARRIER_TIMEOUT);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700384 final CarrierServiceConnection conn = (CarrierServiceConnection) msg.obj;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800385 // If new service connection has been created, unbind.
Jonathan Basseri65273c82017-07-25 15:08:42 -0700386 if (mServiceConnection[phoneId] != conn || conn.service == null) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800387 mContext.unbindService(conn);
388 break;
389 }
chen xu02581692018-11-11 19:03:44 -0800390 final CarrierIdentifier carrierId = getCarrierIdentifierForPhoneId(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700391 // ResultReceiver callback will execute in this Handler's thread.
392 final ResultReceiver resultReceiver =
393 new ResultReceiver(this) {
394 @Override
395 public void onReceiveResult(int resultCode, Bundle resultData) {
396 mContext.unbindService(conn);
397 // If new service connection has been created, this is stale.
398 if (mServiceConnection[phoneId] != conn) {
399 loge("Received response for stale request.");
400 return;
401 }
402 removeMessages(EVENT_FETCH_CARRIER_TIMEOUT);
403 if (resultCode == RESULT_ERROR || resultData == null) {
404 // On error, abort config fetching.
chen xu3fd54572019-03-26 17:01:15 -0700405 loge("Failed to get carrier config from carrier app: "
406 + getCarrierPackageForPhoneId(phoneId));
Jonathan Basseri65273c82017-07-25 15:08:42 -0700407 broadcastConfigChangedIntent(phoneId);
Nathan Harold17daf212019-03-13 22:33:01 -0700408 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700409 return;
410 }
411 PersistableBundle config =
412 resultData.getParcelable(KEY_CONFIG_BUNDLE);
Yuchen Dongc15afed2018-04-26 17:05:22 +0800413 saveConfigToXml(
414 getCarrierPackageForPhoneId(phoneId), phoneId, config);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700415 mConfigFromCarrierApp[phoneId] = config;
416 sendMessage(
417 obtainMessage(
418 EVENT_FETCH_CARRIER_DONE, phoneId, -1));
419 }
420 };
421 // Now fetch the config asynchronously from the ICarrierService.
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800422 try {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700423 ICarrierService carrierService =
424 ICarrierService.Stub.asInterface(conn.service);
425 carrierService.getCarrierConfig(carrierId, resultReceiver);
chen xu3fd54572019-03-26 17:01:15 -0700426 logWithLocalLog("fetch config for carrier app: "
427 + getCarrierPackageForPhoneId(phoneId)
428 + " carrierid: " + carrierId.toString());
Jonathan Basseri65273c82017-07-25 15:08:42 -0700429 } catch (RemoteException e) {
430 loge("Failed to get carrier config: " + e.toString());
431 mContext.unbindService(conn);
432 break; // So we don't set a timeout.
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800433 }
Jonathan Basseri65273c82017-07-25 15:08:42 -0700434 sendMessageDelayed(
435 obtainMessage(EVENT_FETCH_CARRIER_TIMEOUT, phoneId, -1),
436 BIND_TIMEOUT_MILLIS);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800437 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700438 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800439
Jonathan Basseri930701e2015-06-11 20:56:43 -0700440 case EVENT_BIND_CARRIER_TIMEOUT:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700441 case EVENT_FETCH_CARRIER_TIMEOUT:
442 {
443 // If a ResponseReceiver callback is in the queue when this happens, we will
444 // unbind twice and throw an exception.
Jonathan Basseri930701e2015-06-11 20:56:43 -0700445 mContext.unbindService(mServiceConnection[phoneId]);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700446 removeMessages(EVENT_FETCH_CARRIER_TIMEOUT);
Jonathan Basseri930701e2015-06-11 20:56:43 -0700447 broadcastConfigChangedIntent(phoneId);
chen xu3fd54572019-03-26 17:01:15 -0700448 loge("bind/fetch from carrier app timeout");
Nathan Harold17daf212019-03-13 22:33:01 -0700449 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri930701e2015-06-11 20:56:43 -0700450 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700451 }
Jonathan Basseri930701e2015-06-11 20:56:43 -0700452
Jonathan Basseri65273c82017-07-25 15:08:42 -0700453 case EVENT_FETCH_CARRIER_DONE:
454 {
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700455 // If we attempted to bind to the app, but the service connection is null, then
456 // config was cleared while we were waiting and we should not continue.
457 if (!msg.getData().getBoolean("loaded_from_xml", false)
458 && mServiceConnection[phoneId] == null) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800459 break;
460 }
Nathan Harold17daf212019-03-13 22:33:01 -0700461 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800462 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700463 }
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700464
465 case EVENT_CHECK_SYSTEM_UPDATE:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700466 {
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700467 SharedPreferences sharedPrefs =
468 PreferenceManager.getDefaultSharedPreferences(mContext);
469 final String lastFingerprint = sharedPrefs.getString(KEY_FINGERPRINT, null);
470 if (!Build.FINGERPRINT.equals(lastFingerprint)) {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700471 log(
472 "Build fingerprint changed. old: "
473 + lastFingerprint
474 + " new: "
475 + Build.FINGERPRINT);
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700476 clearCachedConfigForPackage(null);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700477 sharedPrefs
478 .edit()
479 .putString(KEY_FINGERPRINT, Build.FINGERPRINT)
480 .apply();
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700481 }
482 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700483 }
Nathan Harold17daf212019-03-13 22:33:01 -0700484
485 case EVENT_SUBSCRIPTION_INFO_UPDATED:
486 broadcastConfigChangedIntent(phoneId);
487 break;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800488 }
489 }
Jonathan Basseri65273c82017-07-25 15:08:42 -0700490 }
491
492 private final Handler mHandler;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800493
494 /**
495 * Constructs a CarrierConfigLoader, registers it as a service, and registers a broadcast
496 * receiver for relevant events.
497 */
498 private CarrierConfigLoader(Context context) {
499 mContext = context;
Meng Wang33ad2bc2017-03-16 20:21:20 -0700500 mPlatformCarrierConfigPackage =
501 mContext.getString(R.string.platform_carrier_config_package);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700502 mHandler = new ConfigHandler();
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800503
Nanxi Chen3d670502016-03-17 16:32:09 -0700504 IntentFilter bootFilter = new IntentFilter();
505 bootFilter.addAction(Intent.ACTION_BOOT_COMPLETED);
506 context.registerReceiver(mBootReceiver, bootFilter);
507
Junda Liu8a8a53a2015-05-15 16:19:57 -0700508 // Register for package updates. Update app or uninstall app update will have all 3 intents,
509 // in the order or removed, added, replaced, all with extra_replace set to true.
510 IntentFilter pkgFilter = new IntentFilter();
511 pkgFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
512 pkgFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
513 pkgFilter.addAction(Intent.ACTION_PACKAGE_REPLACED);
514 pkgFilter.addDataScheme("package");
Jordan Liu5ca24762019-07-10 12:51:09 -0700515 context.registerReceiver(mPackageReceiver, pkgFilter);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800516
517 int numPhones = TelephonyManager.from(context).getPhoneCount();
Jonathan Basseric31f1f32015-05-12 10:13:03 -0700518 mConfigFromDefaultApp = new PersistableBundle[numPhones];
519 mConfigFromCarrierApp = new PersistableBundle[numPhones];
Hall Liu506724b2018-10-22 18:16:14 -0700520 mOverrideConfigs = new PersistableBundle[numPhones];
Zach Johnson36d7aab2015-05-22 15:43:00 -0700521 mServiceConnection = new CarrierServiceConnection[numPhones];
Junda Liu03aad762017-07-21 13:32:17 -0700522 mHasSentConfigChange = new boolean[numPhones];
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800523 // Make this service available through ServiceManager.
524 ServiceManager.addService(Context.CARRIER_CONFIG_SERVICE, this);
525 log("CarrierConfigLoader has started");
Nathan Harold17daf212019-03-13 22:33:01 -0700526 mSubscriptionInfoUpdater = PhoneFactory.getSubscriptionInfoUpdater();
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700527 mHandler.sendEmptyMessage(EVENT_CHECK_SYSTEM_UPDATE);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800528 }
529
530 /**
531 * Initialize the singleton CarrierConfigLoader instance.
532 *
533 * This is only done once, at startup, from {@link com.android.phone.PhoneApp#onCreate}.
534 */
535 /* package */
536 static CarrierConfigLoader init(Context context) {
537 synchronized (CarrierConfigLoader.class) {
538 if (sInstance == null) {
539 sInstance = new CarrierConfigLoader(context);
540 } else {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700541 Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800542 }
543 return sInstance;
544 }
545 }
546
Nathan Harold17daf212019-03-13 22:33:01 -0700547 private void notifySubscriptionInfoUpdater(int phoneId) {
548 String configPackagename;
549 PersistableBundle configToSend;
550 int carrierId = getSpecificCarrierIdForPhoneId(phoneId);
551 // Prefer the carrier privileged carrier app, but if there is not one, use the platform
552 // default carrier app.
553 if (mConfigFromCarrierApp[phoneId] != null) {
554 configPackagename = getCarrierPackageForPhoneId(phoneId);
555 configToSend = mConfigFromCarrierApp[phoneId];
556 } else {
557 configPackagename = mPlatformCarrierConfigPackage;
558 configToSend = mConfigFromDefaultApp[phoneId];
559 }
560 mSubscriptionInfoUpdater.updateSubscriptionByCarrierConfigAndNotifyComplete(
561 phoneId, configPackagename, configToSend,
562 mHandler.obtainMessage(EVENT_SUBSCRIPTION_INFO_UPDATED, phoneId, -1));
563 }
564
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800565 private void broadcastConfigChangedIntent(int phoneId) {
Amit Mahajanf8088ab2018-03-02 15:24:07 -0800566 broadcastConfigChangedIntent(phoneId, true);
567 }
568
569 private void broadcastConfigChangedIntent(int phoneId, boolean addSubIdExtra) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800570 Intent intent = new Intent(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
Christopher Tate38f55eb2017-02-14 14:43:49 -0800571 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT |
chen xuf9db49f2019-03-31 23:04:42 -0700572 Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND |
573 Intent.FLAG_RECEIVER_FOREGROUND);
Qiongcheng Luoe7de61b2018-08-06 10:20:09 +0800574 if (addSubIdExtra) {
575 int simApplicationState = TelephonyManager.SIM_STATE_UNKNOWN;
576 int[] subIds = SubscriptionManager.getSubId(phoneId);
577 if (!ArrayUtils.isEmpty(subIds)) {
578 TelephonyManager telMgr = TelephonyManager.from(mContext)
579 .createForSubscriptionId(subIds[0]);
580 simApplicationState = telMgr.getSimApplicationState();
581 }
582 // Include subId/carrier id extra only if SIM records are loaded
583 if (simApplicationState != TelephonyManager.SIM_STATE_UNKNOWN
584 && simApplicationState != TelephonyManager.SIM_STATE_NOT_READY) {
585 SubscriptionManager.putPhoneIdAndSubIdExtra(intent, phoneId);
586 intent.putExtra(TelephonyManager.EXTRA_SPECIFIC_CARRIER_ID,
587 getSpecificCarrierIdForPhoneId(phoneId));
588 intent.putExtra(TelephonyManager.EXTRA_CARRIER_ID, getCarrierIdForPhoneId(phoneId));
589 }
Amit Mahajanf8088ab2018-03-02 15:24:07 -0800590 }
Amit Mahajanb33bcda2018-01-24 12:56:44 -0800591 intent.putExtra(CarrierConfigManager.EXTRA_SLOT_INDEX, phoneId);
Jack Yu0c1d8842019-04-06 00:37:23 -0700592 log("Broadcast CARRIER_CONFIG_CHANGED for phone " + phoneId);
Jordan Liu5ca24762019-07-10 12:51:09 -0700593 mContext.sendBroadcast(intent);
Junda Liu03aad762017-07-21 13:32:17 -0700594 mHasSentConfigChange[phoneId] = true;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800595 }
596
597 /** Binds to the default or carrier config app. */
598 private boolean bindToConfigPackage(String pkgName, int phoneId, int eventId) {
chen xu3fd54572019-03-26 17:01:15 -0700599 logWithLocalLog("Binding to " + pkgName + " for phone " + phoneId);
Zach Johnsonfca8a8d2015-06-19 18:21:37 -0700600 Intent carrierService = new Intent(CarrierService.CARRIER_SERVICE_INTERFACE);
Zach Johnson36d7aab2015-05-22 15:43:00 -0700601 carrierService.setPackage(pkgName);
602 mServiceConnection[phoneId] = new CarrierServiceConnection(phoneId, eventId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800603 try {
Zach Johnson36d7aab2015-05-22 15:43:00 -0700604 return mContext.bindService(carrierService, mServiceConnection[phoneId],
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800605 Context.BIND_AUTO_CREATE);
606 } catch (SecurityException ex) {
607 return false;
608 }
609 }
610
chen xu02581692018-11-11 19:03:44 -0800611 private CarrierIdentifier getCarrierIdentifierForPhoneId(int phoneId) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800612 String mcc = "";
613 String mnc = "";
614 String imsi = "";
615 String gid1 = "";
616 String gid2 = "";
617 String spn = TelephonyManager.from(mContext).getSimOperatorNameForPhone(phoneId);
618 String simOperator = TelephonyManager.from(mContext).getSimOperatorNumericForPhone(phoneId);
chen xu02581692018-11-11 19:03:44 -0800619 int carrierId = TelephonyManager.UNKNOWN_CARRIER_ID;
chen xua31f22b2019-03-06 15:28:50 -0800620 int specificCarrierId = TelephonyManager.UNKNOWN_CARRIER_ID;
Jonathan Basseri1fa437c2015-04-20 11:08:18 -0700621 // A valid simOperator should be 5 or 6 digits, depending on the length of the MNC.
622 if (simOperator != null && simOperator.length() >= 3) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800623 mcc = simOperator.substring(0, 3);
624 mnc = simOperator.substring(3);
625 }
626 Phone phone = PhoneFactory.getPhone(phoneId);
627 if (phone != null) {
628 imsi = phone.getSubscriberId();
629 gid1 = phone.getGroupIdLevel1();
Junda Liu73183532015-05-14 13:55:40 -0700630 gid2 = phone.getGroupIdLevel2();
chen xu02581692018-11-11 19:03:44 -0800631 carrierId = phone.getCarrierId();
chen xua31f22b2019-03-06 15:28:50 -0800632 specificCarrierId = phone.getSpecificCarrierId();
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800633 }
chen xua31f22b2019-03-06 15:28:50 -0800634 return new CarrierIdentifier(mcc, mnc, spn, imsi, gid1, gid2, carrierId, specificCarrierId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800635 }
636
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700637 /** Returns the package name of a priveleged carrier app, or null if there is none. */
638 private String getCarrierPackageForPhoneId(int phoneId) {
639 List<String> carrierPackageNames = TelephonyManager.from(mContext)
640 .getCarrierPackageNamesForIntentAndPhone(
Zach Johnsonfca8a8d2015-06-19 18:21:37 -0700641 new Intent(CarrierService.CARRIER_SERVICE_INTERFACE), phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700642 if (carrierPackageNames != null && carrierPackageNames.size() > 0) {
643 return carrierPackageNames.get(0);
644 } else {
645 return null;
646 }
647 }
648
649 private String getIccIdForPhoneId(int phoneId) {
650 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
651 return null;
652 }
653 Phone phone = PhoneFactory.getPhone(phoneId);
654 if (phone == null) {
655 return null;
656 }
657 return phone.getIccSerialNumber();
658 }
659
chen xu02581692018-11-11 19:03:44 -0800660 /**
chen xua31f22b2019-03-06 15:28:50 -0800661 * Get the sim specific carrier id {@link TelephonyManager#getSimSpecificCarrierId()}
chen xu02581692018-11-11 19:03:44 -0800662 */
chen xua31f22b2019-03-06 15:28:50 -0800663 private int getSpecificCarrierIdForPhoneId(int phoneId) {
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700664 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
chen xu02581692018-11-11 19:03:44 -0800665 return TelephonyManager.UNKNOWN_CARRIER_ID;
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700666 }
667 Phone phone = PhoneFactory.getPhone(phoneId);
668 if (phone == null) {
chen xu02581692018-11-11 19:03:44 -0800669 return TelephonyManager.UNKNOWN_CARRIER_ID;
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700670 }
chen xua31f22b2019-03-06 15:28:50 -0800671 return phone.getSpecificCarrierId();
chen xu02581692018-11-11 19:03:44 -0800672 }
673
674 /**
675 * Get the sim carrier id {@link TelephonyManager#getSimCarrierId() }
676 */
677 private int getCarrierIdForPhoneId(int phoneId) {
678 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
679 return TelephonyManager.UNKNOWN_CARRIER_ID;
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700680 }
chen xu02581692018-11-11 19:03:44 -0800681 Phone phone = PhoneFactory.getPhone(phoneId);
682 if (phone == null) {
683 return TelephonyManager.UNKNOWN_CARRIER_ID;
684 }
685 return phone.getCarrierId();
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700686 }
687
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700688 /**
689 * Writes a bundle to an XML file.
690 *
chen xu02581692018-11-11 19:03:44 -0800691 * The bundle will be written to a file named after the package name, ICCID and
chen xua31f22b2019-03-06 15:28:50 -0800692 * specific carrier id {@link TelephonyManager#getSimSpecificCarrierId()}. the same carrier
chen xu02581692018-11-11 19:03:44 -0800693 * should have a single copy of XML file named after carrier id. However, it's still possible
694 * that platform doesn't recognize the current sim carrier, we will use iccid + carrierid as
695 * the canonical file name. carrierid can also handle the cases SIM OTA resolves to different
696 * carrier while iccid remains the same.
697 *
698 * The file can be restored later with {@link @restoreConfigFromXml}. The XML output will
699 * include the bundle and the current version of the specified package.
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700700 *
701 * In case of errors or invalid input, no file will be written.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700702 *
703 * @param packageName the name of the package from which we fetched this bundle.
Yuchen Dongc15afed2018-04-26 17:05:22 +0800704 * @param phoneId the phone ID.
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700705 * @param config the bundle to be written. Null will be treated as an empty bundle.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700706 */
Yuchen Dongc15afed2018-04-26 17:05:22 +0800707 private void saveConfigToXml(String packageName, int phoneId, PersistableBundle config) {
708 if (SubscriptionManager.getSimStateForSlotIndex(phoneId)
709 != TelephonyManager.SIM_STATE_LOADED) {
chen xu3fd54572019-03-26 17:01:15 -0700710 loge("Skip save config because SIM records are not loaded.");
Yuchen Dongc15afed2018-04-26 17:05:22 +0800711 return;
712 }
713
714 final String iccid = getIccIdForPhoneId(phoneId);
chen xua31f22b2019-03-06 15:28:50 -0800715 final int cid = getSpecificCarrierIdForPhoneId(phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700716 if (packageName == null || iccid == null) {
717 loge("Cannot save config with null packageName or iccid.");
718 return;
719 }
Junda Liu02596502016-11-15 13:46:43 -0800720 // b/32668103 Only save to file if config isn't empty.
721 // In case of failure, not caching an empty bundle will
722 // try loading config again on next power on or sim loaded.
723 // Downside is for genuinely empty bundle, will bind and load
724 // on every power on.
725 if (config == null || config.isEmpty()) {
726 return;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700727 }
728
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700729 final String version = getPackageVersion(packageName);
730 if (version == null) {
731 loge("Failed to get package version for: " + packageName);
732 return;
733 }
734
chen xu3fd54572019-03-26 17:01:15 -0700735 logWithLocalLog("save config to xml, packagename: " + packageName + " phoneId: " + phoneId);
736
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700737 FileOutputStream outFile = null;
738 try {
739 outFile = new FileOutputStream(
chen xu02581692018-11-11 19:03:44 -0800740 new File(mContext.getFilesDir(),
741 getFilenameForConfig(packageName, iccid, cid)));
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700742 FastXmlSerializer out = new FastXmlSerializer();
743 out.setOutput(outFile, "utf-8");
744 out.startDocument("utf-8", true);
745 out.startTag(null, TAG_DOCUMENT);
746 out.startTag(null, TAG_VERSION);
747 out.text(version);
748 out.endTag(null, TAG_VERSION);
749 out.startTag(null, TAG_BUNDLE);
750 config.saveToXml(out);
751 out.endTag(null, TAG_BUNDLE);
752 out.endTag(null, TAG_DOCUMENT);
753 out.endDocument();
754 out.flush();
755 outFile.close();
756 }
757 catch (IOException e) {
758 loge(e.toString());
759 }
760 catch (XmlPullParserException e) {
761 loge(e.toString());
762 }
763 }
764
765 /**
766 * Reads a bundle from an XML file.
767 *
768 * This restores a bundle that was written with {@link #saveConfigToXml}. This returns the saved
Yuchen Dongc15afed2018-04-26 17:05:22 +0800769 * config bundle for the given package and phone ID.
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700770 *
771 * In case of errors, or if the saved config is from a different package version than the
772 * current version, then null will be returned.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700773 *
774 * @param packageName the name of the package from which we fetched this bundle.
Yuchen Dongc15afed2018-04-26 17:05:22 +0800775 * @param phoneId the phone ID.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700776 * @return the bundle from the XML file. Returns null if there is no saved config, the saved
777 * version does not match, or reading config fails.
778 */
Yuchen Dongc15afed2018-04-26 17:05:22 +0800779 private PersistableBundle restoreConfigFromXml(String packageName, int phoneId) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700780 final String version = getPackageVersion(packageName);
781 if (version == null) {
782 loge("Failed to get package version for: " + packageName);
783 return null;
784 }
Yuchen Dongc15afed2018-04-26 17:05:22 +0800785 if (SubscriptionManager.getSimStateForSlotIndex(phoneId)
786 != TelephonyManager.SIM_STATE_LOADED) {
chen xu3fd54572019-03-26 17:01:15 -0700787 loge("Skip restoring config because SIM records are not yet loaded.");
Yuchen Dongc15afed2018-04-26 17:05:22 +0800788 return null;
789 }
790
791 final String iccid = getIccIdForPhoneId(phoneId);
chen xua31f22b2019-03-06 15:28:50 -0800792 final int cid = getSpecificCarrierIdForPhoneId(phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700793 if (packageName == null || iccid == null) {
794 loge("Cannot restore config with null packageName or iccid.");
795 return null;
796 }
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700797
798 PersistableBundle restoredBundle = null;
799 FileInputStream inFile = null;
800 try {
801 inFile = new FileInputStream(
chen xu02581692018-11-11 19:03:44 -0800802 new File(mContext.getFilesDir(),
803 getFilenameForConfig(packageName, iccid, cid)));
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700804 XmlPullParser parser = XmlPullParserFactory.newInstance().newPullParser();
805 parser.setInput(inFile, "utf-8");
806
807 int event;
808 while (((event = parser.next()) != XmlPullParser.END_DOCUMENT)) {
809
810 if (event == XmlPullParser.START_TAG && TAG_VERSION.equals(parser.getName())) {
811 String savedVersion = parser.nextText();
812 if (!version.equals(savedVersion)) {
chen xu3fd54572019-03-26 17:01:15 -0700813 loge("Saved version mismatch: " + version + " vs " + savedVersion);
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700814 break;
815 }
816 }
817
818 if (event == XmlPullParser.START_TAG && TAG_BUNDLE.equals(parser.getName())) {
819 restoredBundle = PersistableBundle.restoreFromXml(parser);
820 }
821 }
822 inFile.close();
823 }
824 catch (FileNotFoundException e) {
825 loge(e.toString());
826 }
827 catch (XmlPullParserException e) {
828 loge(e.toString());
829 }
830 catch (IOException e) {
831 loge(e.toString());
832 }
833
834 return restoredBundle;
835 }
836
Junda Liu8a8a53a2015-05-15 16:19:57 -0700837 /**
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700838 * Clears cached carrier config.
839 * This deletes all saved XML files associated with the given package name. If packageName is
840 * null, then it deletes all saved XML files.
841 *
842 * @param packageName the name of a carrier package, or null if all cached config should be
843 * cleared.
844 * @return true iff one or more files were deleted.
Junda Liu8a8a53a2015-05-15 16:19:57 -0700845 */
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700846 private boolean clearCachedConfigForPackage(final String packageName) {
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700847 File dir = mContext.getFilesDir();
848 File[] packageFiles = dir.listFiles(new FilenameFilter() {
849 public boolean accept(File dir, String filename) {
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700850 if (packageName != null) {
851 return filename.startsWith("carrierconfig-" + packageName + "-");
852 } else {
853 return filename.startsWith("carrierconfig-");
854 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700855 }
856 });
Junda Liu8a8a53a2015-05-15 16:19:57 -0700857 if (packageFiles == null || packageFiles.length < 1) return false;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700858 for (File f : packageFiles) {
859 log("deleting " + f.getName());
860 f.delete();
861 }
Junda Liu8a8a53a2015-05-15 16:19:57 -0700862 return true;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700863 }
864
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700865 /** Builds a canonical file name for a config file. */
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700866 private String getFilenameForConfig(@NonNull String packageName, @NonNull String iccid,
chen xu02581692018-11-11 19:03:44 -0800867 int cid) {
868 // the same carrier should have a single copy of XML file named after carrier id.
869 // However, it's still possible that platform doesn't recognize the current sim carrier,
870 // we will use iccid + carrierid as the canonical file name. carrierid can also handle the
871 // cases SIM OTA resolves to different carrier while iccid remains the same.
872 return "carrierconfig-" + packageName + "-" + iccid + "-" + cid + ".xml";
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700873 }
874
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700875 /** Return the current version code of a package, or null if the name is not found. */
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700876 private String getPackageVersion(String packageName) {
877 try {
878 PackageInfo info = mContext.getPackageManager().getPackageInfo(packageName, 0);
Dianne Hackbornb76ab202017-11-28 17:44:50 -0800879 return Long.toString(info.getLongVersionCode());
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700880 } catch (PackageManager.NameNotFoundException e) {
881 return null;
882 }
883 }
884
Jonathan Basseri65273c82017-07-25 15:08:42 -0700885 /**
886 * Read up to date config.
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700887 *
888 * This reads config bundles for the given phoneId. That means getting the latest bundle from
889 * the default app and a privileged carrier app, if present. This will not bind to an app if we
890 * have a saved config file to use instead.
891 */
892 private void updateConfigForPhoneId(int phoneId) {
Junda Liu8a8a53a2015-05-15 16:19:57 -0700893 // Clear in-memory cache for carrier app config, so when carrier app gets uninstalled, no
894 // stale config is left.
895 if (mConfigFromCarrierApp[phoneId] != null &&
896 getCarrierPackageForPhoneId(phoneId) == null) {
897 mConfigFromCarrierApp[phoneId] = null;
898 }
Jonathan Basseri65273c82017-07-25 15:08:42 -0700899 mHandler.sendMessage(mHandler.obtainMessage(EVENT_DO_FETCH_DEFAULT, phoneId, -1));
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700900 }
901
Hall Liu506724b2018-10-22 18:16:14 -0700902 @Override
903 public @NonNull PersistableBundle getConfigForSubId(int subId, String callingPackage) {
Malcolm Chen6d3d6b32018-03-01 13:58:03 -0800904 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(
905 mContext, subId, callingPackage, "getCarrierConfig")) {
906 return new PersistableBundle();
Amit Mahajan40b3fa52015-07-14 10:27:19 -0700907 }
Jeff Davidsona8e4e242018-03-15 17:16:18 -0700908
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800909 int phoneId = SubscriptionManager.getPhoneId(subId);
Jonathan Basseric31f1f32015-05-12 10:13:03 -0700910 PersistableBundle retConfig = CarrierConfigManager.getDefaultConfig();
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800911 if (SubscriptionManager.isValidPhoneId(phoneId)) {
Jonathan Basseric31f1f32015-05-12 10:13:03 -0700912 PersistableBundle config = mConfigFromDefaultApp[phoneId];
yinxuc5e27622017-11-29 15:08:50 -0800913 if (config != null) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700914 retConfig.putAll(config);
yinxuc5e27622017-11-29 15:08:50 -0800915 retConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CONFIG_APPLIED_BOOL, true);
916 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800917 config = mConfigFromCarrierApp[phoneId];
yinxuc5e27622017-11-29 15:08:50 -0800918 if (config != null) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700919 retConfig.putAll(config);
yinxuc5e27622017-11-29 15:08:50 -0800920 retConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CONFIG_APPLIED_BOOL, true);
921 }
Hall Liu506724b2018-10-22 18:16:14 -0700922 config = mOverrideConfigs[phoneId];
923 if (config != null) {
924 retConfig.putAll(config);
925 retConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CONFIG_APPLIED_BOOL, true);
926 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800927 }
928 return retConfig;
929 }
930
931 @Override
Hall Liu506724b2018-10-22 18:16:14 -0700932 public void overrideConfig(int subscriptionId, PersistableBundle overrides) {
933 mContext.enforceCallingOrSelfPermission(
934 android.Manifest.permission.MODIFY_PHONE_STATE, null);
Brad Ebinger9e66e842019-04-25 11:02:04 -0700935 //TODO: Also check for SHELL UID to restrict this method to testing only (b/131326259)
Hall Liu506724b2018-10-22 18:16:14 -0700936 int phoneId = SubscriptionManager.getPhoneId(subscriptionId);
937 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
938 log("Ignore invalid phoneId: " + phoneId + " for subId: " + subscriptionId);
939 return;
940 }
941
942 if (overrides == null) {
943 mOverrideConfigs[phoneId] = new PersistableBundle();
Brad Ebingerec45a2f2019-05-15 18:24:13 -0700944 } else if (mOverrideConfigs[phoneId] == null) {
Hall Liu506724b2018-10-22 18:16:14 -0700945 mOverrideConfigs[phoneId] = overrides;
946 } else {
947 mOverrideConfigs[phoneId].putAll(overrides);
948 }
Brad Ebingera3a75ff2019-04-15 17:07:23 -0700949
950 notifySubscriptionInfoUpdater(phoneId);
Hall Liu506724b2018-10-22 18:16:14 -0700951 }
952
953 @Override
Jonathan Basseri86030352015-06-08 12:27:56 -0700954 public void notifyConfigChangedForSubId(int subId) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800955 int phoneId = SubscriptionManager.getPhoneId(subId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700956 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800957 log("Ignore invalid phoneId: " + phoneId + " for subId: " + subId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700958 return;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800959 }
Jordan Liu92b10a82019-04-16 12:29:43 -0700960
961 // Requires the calling app to be either a carrier privileged app for this subId or
Junda Liufbd2bcb2016-06-15 11:15:42 -0700962 // system privileged app with MODIFY_PHONE_STATE permission.
Jordan Liu92b10a82019-04-16 12:29:43 -0700963 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mContext, subId,
964 "Require carrier privileges or MODIFY_PHONE_STATE permission.");
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700965
966 // This method should block until deleting has completed, so that an error which prevents us
967 // from clearing the cache is passed back to the carrier app. With the files successfully
968 // deleted, this can return and we will eventually bind to the carrier app.
Jordan Liu92b10a82019-04-16 12:29:43 -0700969 String callingPackageName = mContext.getPackageManager().getNameForUid(
970 Binder.getCallingUid());
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700971 clearCachedConfigForPackage(callingPackageName);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700972 updateConfigForPhoneId(phoneId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800973 }
974
975 @Override
976 public void updateConfigForPhoneId(int phoneId, String simState) {
Junda Liu1f2b34d2015-06-18 15:26:56 -0700977 mContext.enforceCallingOrSelfPermission(
978 android.Manifest.permission.MODIFY_PHONE_STATE, null);
chen xu26b338c2019-04-17 23:44:43 -0700979 logWithLocalLog("update config for phoneId: " + phoneId + " simState: " + simState);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800980 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
981 return;
982 }
983 // requires Java 7 for switch on string.
984 switch (simState) {
985 case IccCardConstants.INTENT_VALUE_ICC_ABSENT:
986 case IccCardConstants.INTENT_VALUE_ICC_CARD_IO_ERROR:
Junda Liu6f5fddf2016-05-24 16:14:41 -0700987 case IccCardConstants.INTENT_VALUE_ICC_CARD_RESTRICTED:
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800988 case IccCardConstants.INTENT_VALUE_ICC_UNKNOWN:
Junda Liu9f2d2712015-05-15 14:22:45 -0700989 mHandler.sendMessage(mHandler.obtainMessage(EVENT_CLEAR_CONFIG, phoneId, -1));
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800990 break;
991 case IccCardConstants.INTENT_VALUE_ICC_LOADED:
992 case IccCardConstants.INTENT_VALUE_ICC_LOCKED:
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700993 updateConfigForPhoneId(phoneId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800994 break;
995 }
996 }
997
Junda Liu43d723a2015-05-12 17:23:45 -0700998 @Override
Jeff Sharkeya6fcfed2017-07-20 14:18:39 -0600999 public String getDefaultCarrierServicePackageName() {
1000 return mPlatformCarrierConfigPackage;
1001 }
1002
1003 @Override
Junda Liu43d723a2015-05-12 17:23:45 -07001004 public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
1005 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
1006 != PackageManager.PERMISSION_GRANTED) {
1007 pw.println("Permission Denial: can't dump carrierconfig from from pid="
1008 + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid());
1009 return;
1010 }
1011 pw.println("CarrierConfigLoader: " + this);
1012 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
shuoq26a3a4c2016-12-16 11:06:48 -08001013 pw.println("Phone Id = " + i);
1014 // display default values in CarrierConfigManager
1015 printConfig(CarrierConfigManager.getDefaultConfig(), pw,
1016 "Default Values from CarrierConfigManager");
1017 pw.println("");
1018 // display ConfigFromDefaultApp
1019 printConfig(mConfigFromDefaultApp[i], pw, "mConfigFromDefaultApp");
1020 pw.println("");
1021 // display ConfigFromCarrierApp
1022 printConfig(mConfigFromCarrierApp[i], pw, "mConfigFromCarrierApp");
Hall Liu506724b2018-10-22 18:16:14 -07001023 pw.println("");
1024 printConfig(mOverrideConfigs[i], pw, "mOverrideConfigs");
shuoq26a3a4c2016-12-16 11:06:48 -08001025 }
chen xu3fd54572019-03-26 17:01:15 -07001026
1027 pw.println("CarrierConfigLoadingLog=");
1028 mCarrierConfigLoadingLog.dump(fd, pw, args);
shuoq26a3a4c2016-12-16 11:06:48 -08001029 }
1030
1031 private void printConfig(PersistableBundle configApp, PrintWriter pw, String name) {
1032 IndentingPrintWriter indentPW = new IndentingPrintWriter(pw, " ");
1033 if (configApp == null) {
1034 indentPW.increaseIndent();
1035 indentPW.println(name + " : null ");
1036 return;
1037 }
1038 indentPW.increaseIndent();
1039 indentPW.println(name + " : ");
1040 List<String> sortedKeys = new ArrayList<String>(configApp.keySet());
1041 Collections.sort(sortedKeys);
1042 indentPW.increaseIndent();
1043 indentPW.increaseIndent();
1044 for (String key : sortedKeys) {
1045 if (configApp.get(key) != null && configApp.get(key) instanceof Object[]) {
1046 indentPW.println(key + " = " +
1047 Arrays.toString((Object[]) configApp.get(key)));
1048 } else if (configApp.get(key) != null && configApp.get(key) instanceof int[]) {
1049 indentPW.println(key + " = " + Arrays.toString((int[]) configApp.get(key)));
1050 } else {
1051 indentPW.println(key + " = " + configApp.get(key));
1052 }
Junda Liu43d723a2015-05-12 17:23:45 -07001053 }
1054 }
1055
Zach Johnson36d7aab2015-05-22 15:43:00 -07001056 private class CarrierServiceConnection implements ServiceConnection {
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001057 int phoneId;
1058 int eventId;
1059 IBinder service;
1060
Zach Johnson36d7aab2015-05-22 15:43:00 -07001061 public CarrierServiceConnection(int phoneId, int eventId) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001062 this.phoneId = phoneId;
1063 this.eventId = eventId;
1064 }
1065
1066 @Override
1067 public void onServiceConnected(ComponentName name, IBinder service) {
1068 log("Connected to config app: " + name.flattenToString());
1069 this.service = service;
1070 mHandler.sendMessage(mHandler.obtainMessage(eventId, phoneId, -1, this));
1071 }
1072
1073 @Override
1074 public void onServiceDisconnected(ComponentName name) {
1075 this.service = null;
1076 }
1077 }
1078
1079 private class ConfigLoaderBroadcastReceiver extends BroadcastReceiver {
1080 @Override
1081 public void onReceive(Context context, Intent intent) {
1082 String action = intent.getAction();
Junda Liu8a8a53a2015-05-15 16:19:57 -07001083 boolean replace = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
1084 // If replace is true, only care ACTION_PACKAGE_REPLACED.
1085 if (replace && !Intent.ACTION_PACKAGE_REPLACED.equals(action))
1086 return;
1087
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001088 switch (action) {
Nanxi Chen3d670502016-03-17 16:32:09 -07001089 case Intent.ACTION_BOOT_COMPLETED:
1090 mHandler.sendMessage(mHandler.obtainMessage(EVENT_SYSTEM_UNLOCKED, null));
1091 break;
1092
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001093 case Intent.ACTION_PACKAGE_ADDED:
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001094 case Intent.ACTION_PACKAGE_REMOVED:
Junda Liu8a8a53a2015-05-15 16:19:57 -07001095 case Intent.ACTION_PACKAGE_REPLACED:
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001096 int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);
1097 String packageName = mContext.getPackageManager().getNameForUid(uid);
Junda Liu8a8a53a2015-05-15 16:19:57 -07001098 if (packageName != null) {
1099 // We don't have a phoneId for arg1.
1100 mHandler.sendMessage(
1101 mHandler.obtainMessage(EVENT_PACKAGE_CHANGED, packageName));
1102 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001103 break;
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001104 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001105 }
1106 }
1107
chen xu3fd54572019-03-26 17:01:15 -07001108 private void log(String msg) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -07001109 Log.d(LOG_TAG, msg);
1110 }
1111
chen xu3fd54572019-03-26 17:01:15 -07001112 private void logWithLocalLog(String msg) {
1113 Log.d(LOG_TAG, msg);
1114 mCarrierConfigLoadingLog.log(msg);
1115 }
1116
1117 private void loge(String msg) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -07001118 Log.e(LOG_TAG, msg);
chen xu3fd54572019-03-26 17:01:15 -07001119 mCarrierConfigLoadingLog.log(msg);
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001120 }
1121}