blob: 9f8d2f6ed8a50e719980b3ced43804c1771f58bc [file] [log] [blame]
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001/*
Jonathan Basseri6465afd2015-02-25 13:05:57 -08002 * 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;
Torbjorn Eklund723527a2019-02-13 11:16:25 +010023import android.annotation.Nullable;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080024import android.content.BroadcastReceiver;
25import android.content.ComponentName;
26import android.content.Context;
27import android.content.Intent;
28import android.content.IntentFilter;
29import android.content.ServiceConnection;
Jonathan Basseri7697cae2015-07-06 15:49:23 -070030import android.content.SharedPreferences;
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070031import android.content.pm.PackageInfo;
Jonathan Basseric31f1f32015-05-12 10:13:03 -070032import android.content.pm.PackageManager;
Junda Liu43d723a2015-05-12 17:23:45 -070033import android.os.Binder;
Jonathan Basseri7697cae2015-07-06 15:49:23 -070034import android.os.Build;
Jonathan Basseri65273c82017-07-25 15:08:42 -070035import android.os.Bundle;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080036import android.os.Handler;
37import android.os.IBinder;
38import android.os.Message;
Jonathan Basseric31f1f32015-05-12 10:13:03 -070039import android.os.PersistableBundle;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080040import android.os.RemoteException;
Jonathan Basseri65273c82017-07-25 15:08:42 -070041import android.os.ResultReceiver;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080042import android.os.ServiceManager;
Jonathan Basseri7697cae2015-07-06 15:49:23 -070043import android.preference.PreferenceManager;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080044import android.service.carrier.CarrierIdentifier;
Zach Johnson36d7aab2015-05-22 15:43:00 -070045import android.service.carrier.CarrierService;
46import android.service.carrier.ICarrierService;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080047import android.telephony.CarrierConfigManager;
48import android.telephony.SubscriptionManager;
49import android.telephony.TelephonyManager;
chen xudb04c292019-03-26 17:01:15 -070050import android.util.LocalLog;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080051import android.util.Log;
52
53import com.android.internal.telephony.ICarrierConfigLoader;
54import com.android.internal.telephony.IccCardConstants;
55import com.android.internal.telephony.Phone;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080056import com.android.internal.telephony.PhoneFactory;
Nathan Harold48ac0972019-03-13 22:33:01 -070057import com.android.internal.telephony.SubscriptionInfoUpdater;
Jeff Davidsona8e4e242018-03-15 17:16:18 -070058import com.android.internal.telephony.TelephonyPermissions;
Meng Wanga320b942019-11-25 11:21:26 -080059import com.android.internal.telephony.util.ArrayUtils;
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 java.io.File;
Junda Liu43d723a2015-05-12 17:23:45 -070063import java.io.FileDescriptor;
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070064import java.io.FileInputStream;
65import java.io.FileNotFoundException;
66import java.io.FileOutputStream;
Jonathan Basseri1f743c92015-05-15 00:19:46 -070067import java.io.FilenameFilter;
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070068import java.io.IOException;
Junda Liu43d723a2015-05-12 17:23:45 -070069import java.io.PrintWriter;
shuoq26a3a4c2016-12-16 11:06:48 -080070import java.util.ArrayList;
71import java.util.Arrays;
72import java.util.Collections;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080073import java.util.List;
74
75/**
76 * CarrierConfigLoader binds to privileged carrier apps to fetch carrier config overlays.
Jonathan Basseri6465afd2015-02-25 13:05:57 -080077 */
Jonathan Basseri6465afd2015-02-25 13:05:57 -080078public class CarrierConfigLoader extends ICarrierConfigLoader.Stub {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -070079 private static final String LOG_TAG = "CarrierConfigLoader";
Meng Wang33ad2bc2017-03-16 20:21:20 -070080
81 // Package name for platform carrier config app, bundled with system image.
82 private final String mPlatformCarrierConfigPackage;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080083
84 /** The singleton instance. */
85 private static CarrierConfigLoader sInstance;
86 // The context for phone app, passed from PhoneGlobals.
87 private Context mContext;
88 // Carrier configs from default app, indexed by phoneID.
Jonathan Basseric31f1f32015-05-12 10:13:03 -070089 private PersistableBundle[] mConfigFromDefaultApp;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080090 // Carrier configs from privileged carrier config app, indexed by phoneID.
Jonathan Basseric31f1f32015-05-12 10:13:03 -070091 private PersistableBundle[] mConfigFromCarrierApp;
Torbjorn Eklund723527a2019-02-13 11:16:25 +010092 // Persistent Carrier configs that are provided via the override test API, indexed by phone ID.
93 private PersistableBundle[] mPersistentOverrideConfigs;
Hall Liu506724b2018-10-22 18:16:14 -070094 // Carrier configs that are provided via the override test API, indexed by phone ID.
95 private PersistableBundle[] mOverrideConfigs;
Jonathan Basseri6465afd2015-02-25 13:05:57 -080096 // Service connection for binding to config app.
Zach Johnson36d7aab2015-05-22 15:43:00 -070097 private CarrierServiceConnection[] mServiceConnection;
Jordan Liu178430d2020-02-10 14:32:15 -080098 // Whether we are bound to a service for each phone
99 private boolean[] mServiceBound;
Junda Liu03aad762017-07-21 13:32:17 -0700100 // Whether we have sent config change bcast for each phone id.
101 private boolean[] mHasSentConfigChange;
Nathan Harold48ac0972019-03-13 22:33:01 -0700102 // SubscriptionInfoUpdater
103 private final SubscriptionInfoUpdater mSubscriptionInfoUpdater;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800104
Nanxi Chen3d670502016-03-17 16:32:09 -0700105 // Broadcast receiver for Boot intents, register intent filter in construtor.
106 private final BroadcastReceiver mBootReceiver = new ConfigLoaderBroadcastReceiver();
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800107 // Broadcast receiver for SIM and pkg intents, register intent filter in constructor.
Nanxi Chen3d670502016-03-17 16:32:09 -0700108 private final BroadcastReceiver mPackageReceiver = new ConfigLoaderBroadcastReceiver();
Jack Yu67663de2019-10-17 15:19:48 -0700109 private final LocalLog mCarrierConfigLoadingLog = new LocalLog(100);
chen xudb04c292019-03-26 17:01:15 -0700110
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800111
112 // Message codes; see mHandler below.
113 // Request from SubscriptionInfoUpdater when SIM becomes absent or error.
114 private static final int EVENT_CLEAR_CONFIG = 0;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800115 // Has connected to default app.
116 private static final int EVENT_CONNECTED_TO_DEFAULT = 3;
117 // Has connected to carrier app.
118 private static final int EVENT_CONNECTED_TO_CARRIER = 4;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700119 // Config has been loaded from default app (or cache).
120 private static final int EVENT_FETCH_DEFAULT_DONE = 5;
121 // Config has been loaded from carrier app (or cache).
122 private static final int EVENT_FETCH_CARRIER_DONE = 6;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700123 // Attempt to fetch from default app or read from XML.
Jonathan Basseri65273c82017-07-25 15:08:42 -0700124 private static final int EVENT_DO_FETCH_DEFAULT = 7;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700125 // Attempt to fetch from carrier app or read from XML.
Jonathan Basseri65273c82017-07-25 15:08:42 -0700126 private static final int EVENT_DO_FETCH_CARRIER = 8;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700127 // A package has been installed, uninstalled, or updated.
128 private static final int EVENT_PACKAGE_CHANGED = 9;
Jonathan Basseri930701e2015-06-11 20:56:43 -0700129 // Bind timed out for the default app.
130 private static final int EVENT_BIND_DEFAULT_TIMEOUT = 10;
131 // Bind timed out for a carrier app.
132 private static final int EVENT_BIND_CARRIER_TIMEOUT = 11;
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700133 // Check if the system fingerprint has changed.
134 private static final int EVENT_CHECK_SYSTEM_UPDATE = 12;
Nanxi Chen3d670502016-03-17 16:32:09 -0700135 // Rerun carrier config binding after system is unlocked.
136 private static final int EVENT_SYSTEM_UNLOCKED = 13;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700137 // Fetching config timed out from the default app.
138 private static final int EVENT_FETCH_DEFAULT_TIMEOUT = 14;
139 // Fetching config timed out from a carrier app.
140 private static final int EVENT_FETCH_CARRIER_TIMEOUT = 15;
Nathan Harold48ac0972019-03-13 22:33:01 -0700141 // SubscriptionInfoUpdater has finished updating the sub for the carrier config.
142 private static final int EVENT_SUBSCRIPTION_INFO_UPDATED = 16;
Malcolm Chen5ea18532019-10-24 19:55:44 -0700143 // Multi-SIM config changed.
144 private static final int EVENT_MULTI_SIM_CONFIG_CHANGED = 17;
Jonathan Basseri930701e2015-06-11 20:56:43 -0700145
Junda Liu6cb45002016-03-22 17:18:20 -0700146 private static final int BIND_TIMEOUT_MILLIS = 30000;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800147
Meng Wang0f6b2ea2020-01-06 18:31:16 -0800148 // Keys used for saving and restoring config bundle from file.
149 private static final String KEY_VERSION = "__carrier_config_package_version__";
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800150
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100151 private static final String OVERRIDE_PACKAGE_ADDITION = "-override";
152
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700153 // SharedPreferences key for last known build fingerprint.
154 private static final String KEY_FINGERPRINT = "build_fingerprint";
155
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800156 // Handler to process various events.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700157 //
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700158 // For each phoneId, the event sequence should be:
Jonathan Basseri65273c82017-07-25 15:08:42 -0700159 // fetch default, connected to default, fetch default (async), fetch default done,
160 // fetch carrier, connected to carrier, fetch carrier (async), fetch carrier done.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700161 //
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700162 // If there is a saved config file for either the default app or the carrier app, we skip
163 // binding to the app and go straight from fetch to loaded.
164 //
165 // At any time, at most one connection is active. If events are not in this order, previous
166 // connection will be unbound, so only latest event takes effect.
167 //
168 // We broadcast ACTION_CARRIER_CONFIG_CHANGED after:
169 // 1. loading from carrier app (even if read from a file)
170 // 2. loading from default app if there is no carrier app (even if read from a file)
171 // 3. clearing config (e.g. due to sim removal)
172 // 4. encountering bind or IPC error
Jonathan Basseri65273c82017-07-25 15:08:42 -0700173 private class ConfigHandler extends Handler {
174 @Override
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800175 public void handleMessage(Message msg) {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700176 final int phoneId = msg.arg1;
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800177 logdWithLocalLog("mHandler: " + msg.what + " phoneId: " + phoneId);
Malcolm Chen5ea18532019-10-24 19:55:44 -0700178 if (!SubscriptionManager.isValidPhoneId(phoneId)
179 && msg.what != EVENT_MULTI_SIM_CONFIG_CHANGED) {
180 return;
181 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800182 switch (msg.what) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800183 case EVENT_CLEAR_CONFIG: {
Malcolm Chen5ea18532019-10-24 19:55:44 -0700184 clearConfigForPhone(phoneId, true);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800185 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700186 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700187
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800188 case EVENT_SYSTEM_UNLOCKED: {
Malcolm Chen5ea18532019-10-24 19:55:44 -0700189 for (int i = 0; i < TelephonyManager.from(mContext).getActiveModemCount();
190 ++i) {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700191 // When user unlock device, we should only try to send broadcast again if we
192 // have sent it before unlock. This will avoid we try to load carrier config
193 // when SIM is still loading when unlock happens.
Junda Liu03aad762017-07-21 13:32:17 -0700194 if (mHasSentConfigChange[i]) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800195 logdWithLocalLog("System unlocked");
Junda Liu03aad762017-07-21 13:32:17 -0700196 updateConfigForPhoneId(i);
197 }
Nanxi Chen3d670502016-03-17 16:32:09 -0700198 }
199 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700200 }
Nanxi Chen3d670502016-03-17 16:32:09 -0700201
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800202 case EVENT_PACKAGE_CHANGED: {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700203 final String carrierPackageName = (String) msg.obj;
204 // Only update if there are cached config removed to avoid updating config for
205 // unrelated packages.
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700206 if (clearCachedConfigForPackage(carrierPackageName)) {
Malcolm Chen5ea18532019-10-24 19:55:44 -0700207 int numPhones = TelephonyManager.from(mContext).getActiveModemCount();
Junda Liu8a8a53a2015-05-15 16:19:57 -0700208 for (int i = 0; i < numPhones; ++i) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800209 logdWithLocalLog("Package changed: " + carrierPackageName
Jack Yu67663de2019-10-17 15:19:48 -0700210 + ", phone=" + i);
Junda Liu8a8a53a2015-05-15 16:19:57 -0700211 updateConfigForPhoneId(i);
212 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700213 }
214 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700215 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700216
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800217 case EVENT_DO_FETCH_DEFAULT: {
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100218 // Restore persistent override values.
219 PersistableBundle config = restoreConfigFromXml(
220 mPlatformCarrierConfigPackage, OVERRIDE_PACKAGE_ADDITION, phoneId);
221 if (config != null) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800222 logd("Loaded persistent override config from XML. package="
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100223 + mPlatformCarrierConfigPackage
224 + " phoneId=" + phoneId);
225 mPersistentOverrideConfigs[phoneId] = config;
226 }
227
228 config = restoreConfigFromXml(mPlatformCarrierConfigPackage, "", phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700229 if (config != null) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800230 logd(
Jonathan Basseri65273c82017-07-25 15:08:42 -0700231 "Loaded config from XML. package="
232 + mPlatformCarrierConfigPackage
233 + " phoneId="
234 + phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700235 mConfigFromDefaultApp[phoneId] = config;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700236 Message newMsg = obtainMessage(EVENT_FETCH_DEFAULT_DONE, phoneId, -1);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700237 newMsg.getData().putBoolean("loaded_from_xml", true);
238 mHandler.sendMessage(newMsg);
239 } else {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700240 // No cached config, so fetch it from the default app.
241 if (bindToConfigPackage(
242 mPlatformCarrierConfigPackage,
243 phoneId,
244 EVENT_CONNECTED_TO_DEFAULT)) {
245 sendMessageDelayed(
246 obtainMessage(EVENT_BIND_DEFAULT_TIMEOUT, phoneId, -1),
Jonathan Basseri930701e2015-06-11 20:56:43 -0700247 BIND_TIMEOUT_MILLIS);
248 } else {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700249 // Send broadcast if bind fails.
Nathan Harold48ac0972019-03-13 22:33:01 -0700250 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700251 // TODO: We *must* call unbindService even if bindService returns false.
252 // (And possibly if SecurityException was thrown.)
chen xudb04c292019-03-26 17:01:15 -0700253 loge("binding to default app: "
254 + mPlatformCarrierConfigPackage + " fails");
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700255 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800256 }
257 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700258 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800259
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800260 case EVENT_CONNECTED_TO_DEFAULT: {
Jonathan Basseri930701e2015-06-11 20:56:43 -0700261 removeMessages(EVENT_BIND_DEFAULT_TIMEOUT);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700262 final CarrierServiceConnection conn = (CarrierServiceConnection) msg.obj;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800263 // If new service connection has been created, unbind.
264 if (mServiceConnection[phoneId] != conn || conn.service == null) {
Jordan Liu178430d2020-02-10 14:32:15 -0800265 unbindIfBound(mContext, conn, phoneId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800266 break;
267 }
chen xu02581692018-11-11 19:03:44 -0800268 final CarrierIdentifier carrierId = getCarrierIdentifierForPhoneId(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700269 // ResultReceiver callback will execute in this Handler's thread.
270 final ResultReceiver resultReceiver =
271 new ResultReceiver(this) {
272 @Override
273 public void onReceiveResult(int resultCode, Bundle resultData) {
Jordan Liu178430d2020-02-10 14:32:15 -0800274 unbindIfBound(mContext, conn, phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700275 // If new service connection has been created, this is stale.
276 if (mServiceConnection[phoneId] != conn) {
277 loge("Received response for stale request.");
278 return;
279 }
280 removeMessages(EVENT_FETCH_DEFAULT_TIMEOUT);
281 if (resultCode == RESULT_ERROR || resultData == null) {
282 // On error, abort config fetching.
283 loge("Failed to get carrier config");
Nathan Harold48ac0972019-03-13 22:33:01 -0700284 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700285 return;
286 }
287 PersistableBundle config =
288 resultData.getParcelable(KEY_CONFIG_BUNDLE);
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100289 saveConfigToXml(mPlatformCarrierConfigPackage, "", phoneId,
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800290 carrierId, config);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700291 mConfigFromDefaultApp[phoneId] = config;
292 sendMessage(
293 obtainMessage(
294 EVENT_FETCH_DEFAULT_DONE, phoneId, -1));
295 }
296 };
297 // Now fetch the config asynchronously from the ICarrierService.
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800298 try {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700299 ICarrierService carrierService =
300 ICarrierService.Stub.asInterface(conn.service);
301 carrierService.getCarrierConfig(carrierId, resultReceiver);
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800302 logdWithLocalLog("Fetch config for default app: "
chen xudb04c292019-03-26 17:01:15 -0700303 + mPlatformCarrierConfigPackage
304 + " carrierid: " + carrierId.toString());
Jonathan Basseri65273c82017-07-25 15:08:42 -0700305 } catch (RemoteException e) {
chen xudb04c292019-03-26 17:01:15 -0700306 loge("Failed to get carrier config from default app: " +
307 mPlatformCarrierConfigPackage + " err: " + e.toString());
Jordan Liu178430d2020-02-10 14:32:15 -0800308 unbindIfBound(mContext, conn, phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700309 break; // So we don't set a timeout.
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800310 }
Jonathan Basseri65273c82017-07-25 15:08:42 -0700311 sendMessageDelayed(
312 obtainMessage(EVENT_FETCH_DEFAULT_TIMEOUT, phoneId, -1),
313 BIND_TIMEOUT_MILLIS);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800314 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700315 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800316
Jonathan Basseri930701e2015-06-11 20:56:43 -0700317 case EVENT_BIND_DEFAULT_TIMEOUT:
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800318 case EVENT_FETCH_DEFAULT_TIMEOUT: {
319 loge("Bind/fetch time out from " + mPlatformCarrierConfigPackage);
chen xuf60b3162019-05-01 21:31:05 -0700320 removeMessages(EVENT_FETCH_DEFAULT_TIMEOUT);
321 // If we attempted to bind to the app, but the service connection is null due to
322 // the race condition that clear config event happens before bind/fetch complete
323 // then config was cleared while we were waiting and we should not continue.
324 if (mServiceConnection[phoneId] != null) {
325 // If a ResponseReceiver callback is in the queue when this happens, we will
326 // unbind twice and throw an exception.
Jordan Liu178430d2020-02-10 14:32:15 -0800327 unbindIfBound(mContext, mServiceConnection[phoneId], phoneId);
chen xuf60b3162019-05-01 21:31:05 -0700328 broadcastConfigChangedIntent(phoneId);
329 }
Nathan Harold48ac0972019-03-13 22:33:01 -0700330 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri930701e2015-06-11 20:56:43 -0700331 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700332 }
Jonathan Basseri930701e2015-06-11 20:56:43 -0700333
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800334 case EVENT_FETCH_DEFAULT_DONE: {
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700335 // If we attempted to bind to the app, but the service connection is null, then
336 // config was cleared while we were waiting and we should not continue.
337 if (!msg.getData().getBoolean("loaded_from_xml", false)
338 && mServiceConnection[phoneId] == null) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800339 break;
340 }
Jonathan Basseri65273c82017-07-25 15:08:42 -0700341 final String carrierPackageName = getCarrierPackageForPhoneId(phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700342 if (carrierPackageName != null) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800343 logd("Found carrier config app: " + carrierPackageName);
Jordan Liu38a614c2019-03-20 15:01:17 -0700344 sendMessage(obtainMessage(EVENT_DO_FETCH_CARRIER, phoneId, -1));
Jonathan Basserib919e932015-05-27 16:53:08 +0000345 } else {
Nathan Harold48ac0972019-03-13 22:33:01 -0700346 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri4ae2e7c2015-05-15 00:19:46 -0700347 }
348 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700349 }
Jonathan Basseri4ae2e7c2015-05-15 00:19:46 -0700350
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800351 case EVENT_DO_FETCH_CARRIER: {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700352 final String carrierPackageName = getCarrierPackageForPhoneId(phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700353 final PersistableBundle config =
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100354 restoreConfigFromXml(carrierPackageName, "", phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700355 if (config != null) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800356 logd(
Jonathan Basseri65273c82017-07-25 15:08:42 -0700357 "Loaded config from XML. package="
358 + carrierPackageName
359 + " phoneId="
360 + phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700361 mConfigFromCarrierApp[phoneId] = config;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700362 Message newMsg = obtainMessage(EVENT_FETCH_CARRIER_DONE, phoneId, -1);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700363 newMsg.getData().putBoolean("loaded_from_xml", true);
364 sendMessage(newMsg);
365 } else {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700366 // No cached config, so fetch it from a carrier app.
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800367 if (carrierPackageName != null && bindToConfigPackage(carrierPackageName,
368 phoneId, EVENT_CONNECTED_TO_CARRIER)) {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700369 sendMessageDelayed(
370 obtainMessage(EVENT_BIND_CARRIER_TIMEOUT, phoneId, -1),
Jonathan Basseri930701e2015-06-11 20:56:43 -0700371 BIND_TIMEOUT_MILLIS);
372 } else {
Jonathan Basseri65273c82017-07-25 15:08:42 -0700373 // Send broadcast if bind fails.
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700374 broadcastConfigChangedIntent(phoneId);
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800375 loge("Bind to carrier app: " + carrierPackageName + " fails");
Nathan Harold48ac0972019-03-13 22:33:01 -0700376 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700377 }
378 }
379 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700380 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700381
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800382 case EVENT_CONNECTED_TO_CARRIER: {
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) {
Jordan Liu178430d2020-02-10 14:32:15 -0800387 unbindIfBound(mContext, conn, phoneId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800388 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) {
Jordan Liu178430d2020-02-10 14:32:15 -0800396 unbindIfBound(mContext, conn, phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700397 // 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 xudb04c292019-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 Harold48ac0972019-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);
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100413 saveConfigToXml(getCarrierPackageForPhoneId(phoneId), "",
414 phoneId, carrierId, 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);
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800426 logdWithLocalLog("Fetch config for carrier app: "
chen xudb04c292019-03-26 17:01:15 -0700427 + 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());
Jordan Liu178430d2020-02-10 14:32:15 -0800431 unbindIfBound(mContext, conn, phoneId);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700432 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:
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800441 case EVENT_FETCH_CARRIER_TIMEOUT: {
442 loge("Bind/fetch from carrier app timeout");
chen xuf60b3162019-05-01 21:31:05 -0700443 removeMessages(EVENT_FETCH_CARRIER_TIMEOUT);
444 // If we attempted to bind to the app, but the service connection is null due to
445 // the race condition that clear config event happens before bind/fetch complete
446 // then config was cleared while we were waiting and we should not continue.
447 if (mServiceConnection[phoneId] != null) {
448 // If a ResponseReceiver callback is in the queue when this happens, we will
449 // unbind twice and throw an exception.
Jordan Liu178430d2020-02-10 14:32:15 -0800450 unbindIfBound(mContext, mServiceConnection[phoneId], phoneId);
chen xuf60b3162019-05-01 21:31:05 -0700451 broadcastConfigChangedIntent(phoneId);
452 }
Nathan Harold48ac0972019-03-13 22:33:01 -0700453 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri930701e2015-06-11 20:56:43 -0700454 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700455 }
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800456 case EVENT_FETCH_CARRIER_DONE: {
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700457 // If we attempted to bind to the app, but the service connection is null, then
458 // config was cleared while we were waiting and we should not continue.
459 if (!msg.getData().getBoolean("loaded_from_xml", false)
460 && mServiceConnection[phoneId] == null) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800461 break;
462 }
Nathan Harold48ac0972019-03-13 22:33:01 -0700463 notifySubscriptionInfoUpdater(phoneId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800464 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700465 }
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700466
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800467 case EVENT_CHECK_SYSTEM_UPDATE: {
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700468 SharedPreferences sharedPrefs =
469 PreferenceManager.getDefaultSharedPreferences(mContext);
470 final String lastFingerprint = sharedPrefs.getString(KEY_FINGERPRINT, null);
471 if (!Build.FINGERPRINT.equals(lastFingerprint)) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800472 logd(
Jonathan Basseri65273c82017-07-25 15:08:42 -0700473 "Build fingerprint changed. old: "
474 + lastFingerprint
475 + " new: "
476 + Build.FINGERPRINT);
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700477 clearCachedConfigForPackage(null);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700478 sharedPrefs
479 .edit()
480 .putString(KEY_FINGERPRINT, Build.FINGERPRINT)
481 .apply();
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700482 }
483 break;
Jonathan Basseri65273c82017-07-25 15:08:42 -0700484 }
Nathan Harold48ac0972019-03-13 22:33:01 -0700485
486 case EVENT_SUBSCRIPTION_INFO_UPDATED:
487 broadcastConfigChangedIntent(phoneId);
488 break;
Malcolm Chen5ea18532019-10-24 19:55:44 -0700489 case EVENT_MULTI_SIM_CONFIG_CHANGED:
490 onMultiSimConfigChanged();
491 break;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800492 }
493 }
Jonathan Basseri65273c82017-07-25 15:08:42 -0700494 }
495
496 private final Handler mHandler;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800497
498 /**
499 * Constructs a CarrierConfigLoader, registers it as a service, and registers a broadcast
500 * receiver for relevant events.
501 */
502 private CarrierConfigLoader(Context context) {
503 mContext = context;
Meng Wang33ad2bc2017-03-16 20:21:20 -0700504 mPlatformCarrierConfigPackage =
505 mContext.getString(R.string.platform_carrier_config_package);
Jonathan Basseri65273c82017-07-25 15:08:42 -0700506 mHandler = new ConfigHandler();
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800507
Nanxi Chen3d670502016-03-17 16:32:09 -0700508 IntentFilter bootFilter = new IntentFilter();
509 bootFilter.addAction(Intent.ACTION_BOOT_COMPLETED);
510 context.registerReceiver(mBootReceiver, bootFilter);
511
Junda Liu8a8a53a2015-05-15 16:19:57 -0700512 // Register for package updates. Update app or uninstall app update will have all 3 intents,
513 // in the order or removed, added, replaced, all with extra_replace set to true.
514 IntentFilter pkgFilter = new IntentFilter();
515 pkgFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
516 pkgFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
517 pkgFilter.addAction(Intent.ACTION_PACKAGE_REPLACED);
518 pkgFilter.addDataScheme("package");
Jordan Liu5ca24762019-07-10 12:51:09 -0700519 context.registerReceiver(mPackageReceiver, pkgFilter);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800520
Malcolm Chen978dda52019-10-08 18:15:25 -0700521 int numPhones = TelephonyManager.from(context).getSupportedModemCount();
Jonathan Basseric31f1f32015-05-12 10:13:03 -0700522 mConfigFromDefaultApp = new PersistableBundle[numPhones];
523 mConfigFromCarrierApp = new PersistableBundle[numPhones];
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100524 mPersistentOverrideConfigs = new PersistableBundle[numPhones];
Hall Liu506724b2018-10-22 18:16:14 -0700525 mOverrideConfigs = new PersistableBundle[numPhones];
Zach Johnson36d7aab2015-05-22 15:43:00 -0700526 mServiceConnection = new CarrierServiceConnection[numPhones];
Jordan Liu178430d2020-02-10 14:32:15 -0800527 mServiceBound = new boolean[numPhones];
Junda Liu03aad762017-07-21 13:32:17 -0700528 mHasSentConfigChange = new boolean[numPhones];
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800529 // Make this service available through ServiceManager.
530 ServiceManager.addService(Context.CARRIER_CONFIG_SERVICE, this);
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800531 logd("CarrierConfigLoader has started");
Nathan Harold48ac0972019-03-13 22:33:01 -0700532 mSubscriptionInfoUpdater = PhoneFactory.getSubscriptionInfoUpdater();
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700533 mHandler.sendEmptyMessage(EVENT_CHECK_SYSTEM_UPDATE);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800534 }
535
536 /**
537 * Initialize the singleton CarrierConfigLoader instance.
538 *
539 * This is only done once, at startup, from {@link com.android.phone.PhoneApp#onCreate}.
540 */
541 /* package */
542 static CarrierConfigLoader init(Context context) {
543 synchronized (CarrierConfigLoader.class) {
544 if (sInstance == null) {
545 sInstance = new CarrierConfigLoader(context);
546 } else {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700547 Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800548 }
549 return sInstance;
550 }
551 }
552
Malcolm Chen5ea18532019-10-24 19:55:44 -0700553 private void clearConfigForPhone(int phoneId, boolean sendBroadcast) {
554 /* Ignore clear configuration request if device is being shutdown. */
555 Phone phone = PhoneFactory.getPhone(phoneId);
556 if (phone != null) {
557 if (phone.isShuttingDown()) {
558 return;
559 }
560 }
561
562 mConfigFromDefaultApp[phoneId] = null;
563 mConfigFromCarrierApp[phoneId] = null;
564 mServiceConnection[phoneId] = null;
565 mHasSentConfigChange[phoneId] = false;
566
567 if (sendBroadcast) broadcastConfigChangedIntent(phoneId, false);
568 }
569
Nathan Harold48ac0972019-03-13 22:33:01 -0700570 private void notifySubscriptionInfoUpdater(int phoneId) {
571 String configPackagename;
572 PersistableBundle configToSend;
573 int carrierId = getSpecificCarrierIdForPhoneId(phoneId);
574 // Prefer the carrier privileged carrier app, but if there is not one, use the platform
575 // default carrier app.
576 if (mConfigFromCarrierApp[phoneId] != null) {
577 configPackagename = getCarrierPackageForPhoneId(phoneId);
578 configToSend = mConfigFromCarrierApp[phoneId];
579 } else {
580 configPackagename = mPlatformCarrierConfigPackage;
581 configToSend = mConfigFromDefaultApp[phoneId];
582 }
Nazanin Bakhshi6fcc3342019-09-18 17:54:01 -0700583
Malcolm Chenefafd1c2020-02-20 13:27:08 -0800584 if (configToSend == null) {
585 configToSend = new PersistableBundle();
586 }
587
Nazanin Bakhshi6fcc3342019-09-18 17:54:01 -0700588 // mOverrideConfigs is for testing. And it will override current configs.
589 PersistableBundle config = mOverrideConfigs[phoneId];
590 if (config != null) {
Torbjorn Eklund1050cb02018-11-16 14:05:38 +0100591 configToSend = new PersistableBundle(configToSend);
Nazanin Bakhshi6fcc3342019-09-18 17:54:01 -0700592 configToSend.putAll(config);
593 }
594
Nathan Harold48ac0972019-03-13 22:33:01 -0700595 mSubscriptionInfoUpdater.updateSubscriptionByCarrierConfigAndNotifyComplete(
596 phoneId, configPackagename, configToSend,
597 mHandler.obtainMessage(EVENT_SUBSCRIPTION_INFO_UPDATED, phoneId, -1));
598 }
599
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800600 private void broadcastConfigChangedIntent(int phoneId) {
Amit Mahajanf8088ab2018-03-02 15:24:07 -0800601 broadcastConfigChangedIntent(phoneId, true);
602 }
603
604 private void broadcastConfigChangedIntent(int phoneId, boolean addSubIdExtra) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800605 Intent intent = new Intent(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
Christopher Tate38f55eb2017-02-14 14:43:49 -0800606 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT |
chen xuf9db49f2019-03-31 23:04:42 -0700607 Intent.FLAG_RECEIVER_FOREGROUND);
Qiongcheng Luoe7de61b2018-08-06 10:20:09 +0800608 if (addSubIdExtra) {
609 int simApplicationState = TelephonyManager.SIM_STATE_UNKNOWN;
610 int[] subIds = SubscriptionManager.getSubId(phoneId);
611 if (!ArrayUtils.isEmpty(subIds)) {
612 TelephonyManager telMgr = TelephonyManager.from(mContext)
613 .createForSubscriptionId(subIds[0]);
614 simApplicationState = telMgr.getSimApplicationState();
615 }
616 // Include subId/carrier id extra only if SIM records are loaded
617 if (simApplicationState != TelephonyManager.SIM_STATE_UNKNOWN
618 && simApplicationState != TelephonyManager.SIM_STATE_NOT_READY) {
619 SubscriptionManager.putPhoneIdAndSubIdExtra(intent, phoneId);
620 intent.putExtra(TelephonyManager.EXTRA_SPECIFIC_CARRIER_ID,
621 getSpecificCarrierIdForPhoneId(phoneId));
622 intent.putExtra(TelephonyManager.EXTRA_CARRIER_ID, getCarrierIdForPhoneId(phoneId));
623 }
Amit Mahajanf8088ab2018-03-02 15:24:07 -0800624 }
Amit Mahajanb33bcda2018-01-24 12:56:44 -0800625 intent.putExtra(CarrierConfigManager.EXTRA_SLOT_INDEX, phoneId);
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800626 logd("Broadcast CARRIER_CONFIG_CHANGED for phone " + phoneId);
Jordan Liu5ca24762019-07-10 12:51:09 -0700627 mContext.sendBroadcast(intent);
Junda Liu03aad762017-07-21 13:32:17 -0700628 mHasSentConfigChange[phoneId] = true;
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800629 }
630
631 /** Binds to the default or carrier config app. */
632 private boolean bindToConfigPackage(String pkgName, int phoneId, int eventId) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800633 logdWithLocalLog("Binding to " + pkgName + " for phone " + phoneId);
Zach Johnsonfca8a8d2015-06-19 18:21:37 -0700634 Intent carrierService = new Intent(CarrierService.CARRIER_SERVICE_INTERFACE);
Zach Johnson36d7aab2015-05-22 15:43:00 -0700635 carrierService.setPackage(pkgName);
636 mServiceConnection[phoneId] = new CarrierServiceConnection(phoneId, eventId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800637 try {
Jordan Liu178430d2020-02-10 14:32:15 -0800638 if (mContext.bindService(carrierService, mServiceConnection[phoneId],
639 Context.BIND_AUTO_CREATE)) {
640 mServiceBound[phoneId] = true;
641 return true;
642 } else {
643 return false;
644 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800645 } catch (SecurityException ex) {
646 return false;
647 }
648 }
649
chen xu02581692018-11-11 19:03:44 -0800650 private CarrierIdentifier getCarrierIdentifierForPhoneId(int phoneId) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800651 String mcc = "";
652 String mnc = "";
653 String imsi = "";
654 String gid1 = "";
655 String gid2 = "";
656 String spn = TelephonyManager.from(mContext).getSimOperatorNameForPhone(phoneId);
657 String simOperator = TelephonyManager.from(mContext).getSimOperatorNumericForPhone(phoneId);
chen xu02581692018-11-11 19:03:44 -0800658 int carrierId = TelephonyManager.UNKNOWN_CARRIER_ID;
chen xua31f22b2019-03-06 15:28:50 -0800659 int specificCarrierId = TelephonyManager.UNKNOWN_CARRIER_ID;
Jonathan Basseri1fa437c2015-04-20 11:08:18 -0700660 // A valid simOperator should be 5 or 6 digits, depending on the length of the MNC.
661 if (simOperator != null && simOperator.length() >= 3) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800662 mcc = simOperator.substring(0, 3);
663 mnc = simOperator.substring(3);
664 }
665 Phone phone = PhoneFactory.getPhone(phoneId);
666 if (phone != null) {
667 imsi = phone.getSubscriberId();
668 gid1 = phone.getGroupIdLevel1();
Junda Liu73183532015-05-14 13:55:40 -0700669 gid2 = phone.getGroupIdLevel2();
chen xu02581692018-11-11 19:03:44 -0800670 carrierId = phone.getCarrierId();
chen xua31f22b2019-03-06 15:28:50 -0800671 specificCarrierId = phone.getSpecificCarrierId();
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800672 }
chen xua31f22b2019-03-06 15:28:50 -0800673 return new CarrierIdentifier(mcc, mnc, spn, imsi, gid1, gid2, carrierId, specificCarrierId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800674 }
675
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700676 /** Returns the package name of a priveleged carrier app, or null if there is none. */
677 private String getCarrierPackageForPhoneId(int phoneId) {
678 List<String> carrierPackageNames = TelephonyManager.from(mContext)
679 .getCarrierPackageNamesForIntentAndPhone(
Zach Johnsonfca8a8d2015-06-19 18:21:37 -0700680 new Intent(CarrierService.CARRIER_SERVICE_INTERFACE), phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700681 if (carrierPackageNames != null && carrierPackageNames.size() > 0) {
682 return carrierPackageNames.get(0);
683 } else {
684 return null;
685 }
686 }
687
688 private String getIccIdForPhoneId(int phoneId) {
689 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
690 return null;
691 }
692 Phone phone = PhoneFactory.getPhone(phoneId);
693 if (phone == null) {
694 return null;
695 }
696 return phone.getIccSerialNumber();
697 }
698
chen xu02581692018-11-11 19:03:44 -0800699 /**
chen xua31f22b2019-03-06 15:28:50 -0800700 * Get the sim specific carrier id {@link TelephonyManager#getSimSpecificCarrierId()}
chen xu02581692018-11-11 19:03:44 -0800701 */
chen xua31f22b2019-03-06 15:28:50 -0800702 private int getSpecificCarrierIdForPhoneId(int phoneId) {
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700703 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
chen xu02581692018-11-11 19:03:44 -0800704 return TelephonyManager.UNKNOWN_CARRIER_ID;
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700705 }
706 Phone phone = PhoneFactory.getPhone(phoneId);
707 if (phone == null) {
chen xu02581692018-11-11 19:03:44 -0800708 return TelephonyManager.UNKNOWN_CARRIER_ID;
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700709 }
chen xua31f22b2019-03-06 15:28:50 -0800710 return phone.getSpecificCarrierId();
chen xu02581692018-11-11 19:03:44 -0800711 }
712
713 /**
714 * Get the sim carrier id {@link TelephonyManager#getSimCarrierId() }
715 */
716 private int getCarrierIdForPhoneId(int phoneId) {
717 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
718 return TelephonyManager.UNKNOWN_CARRIER_ID;
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700719 }
chen xu02581692018-11-11 19:03:44 -0800720 Phone phone = PhoneFactory.getPhone(phoneId);
721 if (phone == null) {
722 return TelephonyManager.UNKNOWN_CARRIER_ID;
723 }
724 return phone.getCarrierId();
Naina Nalluri86fc7b02018-08-03 10:38:30 -0700725 }
726
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700727 /**
728 * Writes a bundle to an XML file.
729 *
chen xu02581692018-11-11 19:03:44 -0800730 * The bundle will be written to a file named after the package name, ICCID and
chen xua31f22b2019-03-06 15:28:50 -0800731 * specific carrier id {@link TelephonyManager#getSimSpecificCarrierId()}. the same carrier
chen xu02581692018-11-11 19:03:44 -0800732 * should have a single copy of XML file named after carrier id. However, it's still possible
733 * that platform doesn't recognize the current sim carrier, we will use iccid + carrierid as
734 * the canonical file name. carrierid can also handle the cases SIM OTA resolves to different
735 * carrier while iccid remains the same.
736 *
737 * The file can be restored later with {@link @restoreConfigFromXml}. The XML output will
738 * include the bundle and the current version of the specified package.
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700739 *
740 * In case of errors or invalid input, no file will be written.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700741 *
742 * @param packageName the name of the package from which we fetched this bundle.
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100743 * @param extraString An extra string to be used in the XML file name.
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800744 * @param phoneId the phone ID.
745 * @param carrierId contains all carrier-identifying information.
746 * @param config the bundle to be written. Null will be treated as an empty bundle.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700747 */
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100748 private void saveConfigToXml(String packageName, @NonNull String extraString, int phoneId,
749 CarrierIdentifier carrierId, PersistableBundle config) {
Yuchen Dongc15afed2018-04-26 17:05:22 +0800750 if (SubscriptionManager.getSimStateForSlotIndex(phoneId)
751 != TelephonyManager.SIM_STATE_LOADED) {
chen xudb04c292019-03-26 17:01:15 -0700752 loge("Skip save config because SIM records are not loaded.");
Yuchen Dongc15afed2018-04-26 17:05:22 +0800753 return;
754 }
755
756 final String iccid = getIccIdForPhoneId(phoneId);
Chen Xucd4a6372019-07-29 16:34:52 -0700757 final int cid = carrierId.getSpecificCarrierId();
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700758 if (packageName == null || iccid == null) {
759 loge("Cannot save config with null packageName or iccid.");
760 return;
761 }
Junda Liu02596502016-11-15 13:46:43 -0800762 // b/32668103 Only save to file if config isn't empty.
763 // In case of failure, not caching an empty bundle will
764 // try loading config again on next power on or sim loaded.
765 // Downside is for genuinely empty bundle, will bind and load
766 // on every power on.
767 if (config == null || config.isEmpty()) {
768 return;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700769 }
770
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700771 final String version = getPackageVersion(packageName);
772 if (version == null) {
773 loge("Failed to get package version for: " + packageName);
774 return;
775 }
776
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800777 logdWithLocalLog(
778 "Save config to xml, packagename: " + packageName + " phoneId: " + phoneId);
chen xudb04c292019-03-26 17:01:15 -0700779
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700780 FileOutputStream outFile = null;
781 try {
782 outFile = new FileOutputStream(
chen xu02581692018-11-11 19:03:44 -0800783 new File(mContext.getFilesDir(),
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100784 getFilenameForConfig(packageName, extraString, iccid, cid)));
Meng Wang0f6b2ea2020-01-06 18:31:16 -0800785 config.putString(KEY_VERSION, version);
786 config.writeToStream(outFile);
787 outFile.flush();
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700788 outFile.close();
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800789 } catch (IOException e) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700790 loge(e.toString());
791 }
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700792 }
793
794 /**
795 * Reads a bundle from an XML file.
796 *
797 * This restores a bundle that was written with {@link #saveConfigToXml}. This returns the saved
Yuchen Dongc15afed2018-04-26 17:05:22 +0800798 * config bundle for the given package and phone ID.
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700799 *
800 * In case of errors, or if the saved config is from a different package version than the
801 * current version, then null will be returned.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700802 *
803 * @param packageName the name of the package from which we fetched this bundle.
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100804 * @param extraString An extra string to be used in the XML file name.
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800805 * @param phoneId the phone ID.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700806 * @return the bundle from the XML file. Returns null if there is no saved config, the saved
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800807 * version does not match, or reading config fails.
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700808 */
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100809 private PersistableBundle restoreConfigFromXml(String packageName, @NonNull String extraString,
810 int phoneId) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700811 final String version = getPackageVersion(packageName);
812 if (version == null) {
813 loge("Failed to get package version for: " + packageName);
814 return null;
815 }
Yuchen Dongc15afed2018-04-26 17:05:22 +0800816 if (SubscriptionManager.getSimStateForSlotIndex(phoneId)
817 != TelephonyManager.SIM_STATE_LOADED) {
chen xudb04c292019-03-26 17:01:15 -0700818 loge("Skip restoring config because SIM records are not yet loaded.");
Yuchen Dongc15afed2018-04-26 17:05:22 +0800819 return null;
820 }
821
822 final String iccid = getIccIdForPhoneId(phoneId);
chen xua31f22b2019-03-06 15:28:50 -0800823 final int cid = getSpecificCarrierIdForPhoneId(phoneId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700824 if (packageName == null || iccid == null) {
825 loge("Cannot restore config with null packageName or iccid.");
826 return null;
827 }
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700828
829 PersistableBundle restoredBundle = null;
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100830 File file = null;
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700831 FileInputStream inFile = null;
832 try {
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100833 file = new File(mContext.getFilesDir(),
834 getFilenameForConfig(packageName, extraString, iccid, cid));
835 inFile = new FileInputStream(file);
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700836
Meng Wang0f6b2ea2020-01-06 18:31:16 -0800837 restoredBundle = PersistableBundle.readFromStream(inFile);
838 String savedVersion = restoredBundle.getString(KEY_VERSION);
839 restoredBundle.remove(KEY_VERSION);
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700840
Meng Wang0f6b2ea2020-01-06 18:31:16 -0800841 if (!version.equals(savedVersion)) {
842 loge("Saved version mismatch: " + version + " vs " + savedVersion);
843 restoredBundle = null;
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700844 }
Meng Wang0f6b2ea2020-01-06 18:31:16 -0800845
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700846 inFile.close();
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800847 } catch (FileNotFoundException e) {
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100848 // Missing file is normal occurrence that might occur with a new sim or when restoring
849 // an override file during boot and should not be treated as an error.
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800850 if (file != null) logd("File not found: " + file.getPath());
851 } catch (IOException e) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700852 loge(e.toString());
853 }
854
855 return restoredBundle;
856 }
857
Junda Liu8a8a53a2015-05-15 16:19:57 -0700858 /**
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700859 * Clears cached carrier config.
860 * This deletes all saved XML files associated with the given package name. If packageName is
861 * null, then it deletes all saved XML files.
862 *
863 * @param packageName the name of a carrier package, or null if all cached config should be
864 * cleared.
865 * @return true iff one or more files were deleted.
Junda Liu8a8a53a2015-05-15 16:19:57 -0700866 */
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700867 private boolean clearCachedConfigForPackage(final String packageName) {
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700868 File dir = mContext.getFilesDir();
869 File[] packageFiles = dir.listFiles(new FilenameFilter() {
870 public boolean accept(File dir, String filename) {
Jonathan Basseri7697cae2015-07-06 15:49:23 -0700871 if (packageName != null) {
872 return filename.startsWith("carrierconfig-" + packageName + "-");
873 } else {
874 return filename.startsWith("carrierconfig-");
875 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700876 }
877 });
Junda Liu8a8a53a2015-05-15 16:19:57 -0700878 if (packageFiles == null || packageFiles.length < 1) return false;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700879 for (File f : packageFiles) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800880 logd("Deleting " + f.getName());
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700881 f.delete();
882 }
Junda Liu8a8a53a2015-05-15 16:19:57 -0700883 return true;
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700884 }
885
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700886 /** Builds a canonical file name for a config file. */
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100887 private String getFilenameForConfig(@NonNull String packageName, @NonNull String extraString,
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800888 @NonNull String iccid, int cid) {
chen xu02581692018-11-11 19:03:44 -0800889 // the same carrier should have a single copy of XML file named after carrier id.
890 // However, it's still possible that platform doesn't recognize the current sim carrier,
891 // we will use iccid + carrierid as the canonical file name. carrierid can also handle the
892 // cases SIM OTA resolves to different carrier while iccid remains the same.
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100893 return "carrierconfig-" + packageName + extraString + "-" + iccid + "-" + cid + ".xml";
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700894 }
895
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700896 /** Return the current version code of a package, or null if the name is not found. */
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700897 private String getPackageVersion(String packageName) {
898 try {
899 PackageInfo info = mContext.getPackageManager().getPackageInfo(packageName, 0);
Dianne Hackbornb76ab202017-11-28 17:44:50 -0800900 return Long.toString(info.getLongVersionCode());
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700901 } catch (PackageManager.NameNotFoundException e) {
902 return null;
903 }
904 }
905
Jonathan Basseri65273c82017-07-25 15:08:42 -0700906 /**
907 * Read up to date config.
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700908 *
909 * This reads config bundles for the given phoneId. That means getting the latest bundle from
910 * the default app and a privileged carrier app, if present. This will not bind to an app if we
911 * have a saved config file to use instead.
912 */
913 private void updateConfigForPhoneId(int phoneId) {
Junda Liu8a8a53a2015-05-15 16:19:57 -0700914 // Clear in-memory cache for carrier app config, so when carrier app gets uninstalled, no
915 // stale config is left.
916 if (mConfigFromCarrierApp[phoneId] != null &&
917 getCarrierPackageForPhoneId(phoneId) == null) {
918 mConfigFromCarrierApp[phoneId] = null;
919 }
Jonathan Basseri65273c82017-07-25 15:08:42 -0700920 mHandler.sendMessage(mHandler.obtainMessage(EVENT_DO_FETCH_DEFAULT, phoneId, -1));
Jonathan Basseri1f743c92015-05-15 00:19:46 -0700921 }
922
Malcolm Chen5ea18532019-10-24 19:55:44 -0700923 private void onMultiSimConfigChanged() {
924 for (int i = TelephonyManager.from(mContext).getActiveModemCount();
925 i < mConfigFromDefaultApp.length; i++) {
926 clearConfigForPhone(i, false);
927 }
928 }
929
Hall Liu506724b2018-10-22 18:16:14 -0700930 @Override
931 public @NonNull PersistableBundle getConfigForSubId(int subId, String callingPackage) {
Philip P. Moltmann9797cbb2020-01-07 13:45:00 -0800932 return getConfigForSubIdWithFeature(subId, callingPackage, null);
933 }
934
935 @Override
936 public @NonNull PersistableBundle getConfigForSubIdWithFeature(int subId, String callingPackage,
937 String callingFeatureId) {
938 if (!TelephonyPermissions.checkCallingOrSelfReadPhoneState(mContext, subId, callingPackage,
939 callingFeatureId, "getCarrierConfig")) {
Malcolm Chen6d3d6b32018-03-01 13:58:03 -0800940 return new PersistableBundle();
Amit Mahajan40b3fa52015-07-14 10:27:19 -0700941 }
Jeff Davidsona8e4e242018-03-15 17:16:18 -0700942
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800943 int phoneId = SubscriptionManager.getPhoneId(subId);
Jonathan Basseric31f1f32015-05-12 10:13:03 -0700944 PersistableBundle retConfig = CarrierConfigManager.getDefaultConfig();
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800945 if (SubscriptionManager.isValidPhoneId(phoneId)) {
Jonathan Basseric31f1f32015-05-12 10:13:03 -0700946 PersistableBundle config = mConfigFromDefaultApp[phoneId];
yinxuc5e27622017-11-29 15:08:50 -0800947 if (config != null) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700948 retConfig.putAll(config);
yinxud0104832019-08-16 14:20:08 -0700949 if (getCarrierPackageForPhoneId(phoneId) == null) {
950 retConfig.putBoolean(
951 CarrierConfigManager.KEY_CARRIER_CONFIG_APPLIED_BOOL, true);
952 }
yinxuc5e27622017-11-29 15:08:50 -0800953 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800954 config = mConfigFromCarrierApp[phoneId];
yinxuc5e27622017-11-29 15:08:50 -0800955 if (config != null) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -0700956 retConfig.putAll(config);
yinxuc5e27622017-11-29 15:08:50 -0800957 retConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CONFIG_APPLIED_BOOL, true);
958 }
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100959 config = mPersistentOverrideConfigs[phoneId];
960 if (config != null) {
961 retConfig.putAll(config);
962 retConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CONFIG_APPLIED_BOOL, true);
963 }
Hall Liu506724b2018-10-22 18:16:14 -0700964 config = mOverrideConfigs[phoneId];
965 if (config != null) {
966 retConfig.putAll(config);
Hall Liu506724b2018-10-22 18:16:14 -0700967 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -0800968 }
969 return retConfig;
970 }
971
972 @Override
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100973 public void overrideConfig(int subscriptionId, @Nullable PersistableBundle overrides,
974 boolean persistent) {
Hall Liu506724b2018-10-22 18:16:14 -0700975 mContext.enforceCallingOrSelfPermission(
976 android.Manifest.permission.MODIFY_PHONE_STATE, null);
Brad Ebingerf6281ad2019-04-25 11:02:04 -0700977 //TODO: Also check for SHELL UID to restrict this method to testing only (b/131326259)
Hall Liu506724b2018-10-22 18:16:14 -0700978 int phoneId = SubscriptionManager.getPhoneId(subscriptionId);
979 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -0800980 logd("Ignore invalid phoneId: " + phoneId + " for subId: " + subscriptionId);
Hall Liu506724b2018-10-22 18:16:14 -0700981 return;
982 }
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100983 overrideConfig(mOverrideConfigs, phoneId, overrides);
Hall Liu506724b2018-10-22 18:16:14 -0700984
Torbjorn Eklund723527a2019-02-13 11:16:25 +0100985 if (persistent) {
986 overrideConfig(mPersistentOverrideConfigs, phoneId, overrides);
987
988 if (overrides != null) {
989 final CarrierIdentifier carrierId = getCarrierIdentifierForPhoneId(phoneId);
990 saveConfigToXml(mPlatformCarrierConfigPackage, OVERRIDE_PACKAGE_ADDITION, phoneId,
991 carrierId, mPersistentOverrideConfigs[phoneId]);
992 } else {
993 final String iccid = getIccIdForPhoneId(phoneId);
994 final int cid = getSpecificCarrierIdForPhoneId(phoneId);
995 String fileName = getFilenameForConfig(mPlatformCarrierConfigPackage,
996 OVERRIDE_PACKAGE_ADDITION, iccid, cid);
997 File fileToDelete = new File(mContext.getFilesDir(), fileName);
998 fileToDelete.delete();
999 }
Hall Liu506724b2018-10-22 18:16:14 -07001000 }
Brad Ebingerc9d1fa12019-04-17 15:21:18 -07001001 notifySubscriptionInfoUpdater(phoneId);
Hall Liu506724b2018-10-22 18:16:14 -07001002 }
1003
Torbjorn Eklund723527a2019-02-13 11:16:25 +01001004 private void overrideConfig(@NonNull PersistableBundle[] currentOverrides, int phoneId,
1005 @Nullable PersistableBundle overrides) {
1006 if (overrides == null) {
1007 currentOverrides[phoneId] = new PersistableBundle();
1008 } else if (currentOverrides[phoneId] == null) {
1009 currentOverrides[phoneId] = overrides;
1010 } else {
1011 currentOverrides[phoneId].putAll(overrides);
1012 }
1013 }
1014
Hall Liu506724b2018-10-22 18:16:14 -07001015 @Override
Jonathan Basseri86030352015-06-08 12:27:56 -07001016 public void notifyConfigChangedForSubId(int subId) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001017 int phoneId = SubscriptionManager.getPhoneId(subId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001018 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001019 logd("Ignore invalid phoneId: " + phoneId + " for subId: " + subId);
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001020 return;
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001021 }
Jordan Liud7d57fe2019-04-16 12:29:43 -07001022
1023 // Requires the calling app to be either a carrier privileged app for this subId or
Junda Liufbd2bcb2016-06-15 11:15:42 -07001024 // system privileged app with MODIFY_PHONE_STATE permission.
Jordan Liud7d57fe2019-04-16 12:29:43 -07001025 TelephonyPermissions.enforceCallingOrSelfModifyPermissionOrCarrierPrivilege(mContext, subId,
1026 "Require carrier privileges or MODIFY_PHONE_STATE permission.");
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001027
1028 // This method should block until deleting has completed, so that an error which prevents us
1029 // from clearing the cache is passed back to the carrier app. With the files successfully
1030 // deleted, this can return and we will eventually bind to the carrier app.
Jordan Liud7d57fe2019-04-16 12:29:43 -07001031 String callingPackageName = mContext.getPackageManager().getNameForUid(
1032 Binder.getCallingUid());
Jonathan Basseri7697cae2015-07-06 15:49:23 -07001033 clearCachedConfigForPackage(callingPackageName);
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001034 updateConfigForPhoneId(phoneId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001035 }
1036
1037 @Override
1038 public void updateConfigForPhoneId(int phoneId, String simState) {
Junda Liu1f2b34d2015-06-18 15:26:56 -07001039 mContext.enforceCallingOrSelfPermission(
1040 android.Manifest.permission.MODIFY_PHONE_STATE, null);
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001041 logdWithLocalLog("Update config for phoneId: " + phoneId + " simState: " + simState);
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001042 if (!SubscriptionManager.isValidPhoneId(phoneId)) {
1043 return;
1044 }
1045 // requires Java 7 for switch on string.
1046 switch (simState) {
1047 case IccCardConstants.INTENT_VALUE_ICC_ABSENT:
1048 case IccCardConstants.INTENT_VALUE_ICC_CARD_IO_ERROR:
Junda Liu6f5fddf2016-05-24 16:14:41 -07001049 case IccCardConstants.INTENT_VALUE_ICC_CARD_RESTRICTED:
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001050 case IccCardConstants.INTENT_VALUE_ICC_UNKNOWN:
Malcolm Chendb66de12019-12-09 18:57:07 -08001051 case IccCardConstants.INTENT_VALUE_ICC_NOT_READY:
Junda Liu9f2d2712015-05-15 14:22:45 -07001052 mHandler.sendMessage(mHandler.obtainMessage(EVENT_CLEAR_CONFIG, phoneId, -1));
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001053 break;
1054 case IccCardConstants.INTENT_VALUE_ICC_LOADED:
1055 case IccCardConstants.INTENT_VALUE_ICC_LOCKED:
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001056 updateConfigForPhoneId(phoneId);
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001057 break;
1058 }
1059 }
1060
Junda Liu43d723a2015-05-12 17:23:45 -07001061 @Override
Jeff Sharkeya6fcfed2017-07-20 14:18:39 -06001062 public String getDefaultCarrierServicePackageName() {
Shuo Qianefdb7962019-12-19 15:54:27 -08001063 mContext.enforceCallingOrSelfPermission(
1064 android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
1065 "getDefaultCarrierServicePackageName");
Jeff Sharkeya6fcfed2017-07-20 14:18:39 -06001066 return mPlatformCarrierConfigPackage;
1067 }
1068
1069 @Override
Junda Liu43d723a2015-05-12 17:23:45 -07001070 public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001071 IndentingPrintWriter indentPW = new IndentingPrintWriter(pw, " ");
Junda Liu43d723a2015-05-12 17:23:45 -07001072 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
1073 != PackageManager.PERMISSION_GRANTED) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001074 indentPW.println("Permission Denial: can't dump carrierconfig from from pid="
Junda Liu43d723a2015-05-12 17:23:45 -07001075 + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid());
1076 return;
1077 }
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001078 indentPW.println("CarrierConfigLoader: " + this);
Junda Liu43d723a2015-05-12 17:23:45 -07001079 for (int i = 0; i < TelephonyManager.getDefault().getPhoneCount(); i++) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001080 indentPW.println("Phone Id = " + i);
shuoq26a3a4c2016-12-16 11:06:48 -08001081 // display default values in CarrierConfigManager
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001082 printConfig(CarrierConfigManager.getDefaultConfig(), indentPW,
shuoq26a3a4c2016-12-16 11:06:48 -08001083 "Default Values from CarrierConfigManager");
shuoq26a3a4c2016-12-16 11:06:48 -08001084 // display ConfigFromDefaultApp
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001085 printConfig(mConfigFromDefaultApp[i], indentPW, "mConfigFromDefaultApp");
shuoq26a3a4c2016-12-16 11:06:48 -08001086 // display ConfigFromCarrierApp
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001087 printConfig(mConfigFromCarrierApp[i], indentPW, "mConfigFromCarrierApp");
1088 printConfig(mPersistentOverrideConfigs[i], indentPW, "mPersistentOverrideConfigs");
1089 printConfig(mOverrideConfigs[i], indentPW, "mOverrideConfigs");
shuoq26a3a4c2016-12-16 11:06:48 -08001090 }
chen xudb04c292019-03-26 17:01:15 -07001091
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001092 indentPW.println("CarrierConfigLoadingLog=");
1093 mCarrierConfigLoadingLog.dump(fd, indentPW, args);
shuoq26a3a4c2016-12-16 11:06:48 -08001094 }
1095
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001096 private void printConfig(PersistableBundle configApp, IndentingPrintWriter indentPW,
1097 String name) {
1098 indentPW.increaseIndent();
shuoq26a3a4c2016-12-16 11:06:48 -08001099 if (configApp == null) {
shuoq26a3a4c2016-12-16 11:06:48 -08001100 indentPW.println(name + " : null ");
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001101 indentPW.decreaseIndent();
1102 indentPW.println("");
shuoq26a3a4c2016-12-16 11:06:48 -08001103 return;
1104 }
shuoq26a3a4c2016-12-16 11:06:48 -08001105 indentPW.println(name + " : ");
1106 List<String> sortedKeys = new ArrayList<String>(configApp.keySet());
1107 Collections.sort(sortedKeys);
1108 indentPW.increaseIndent();
1109 indentPW.increaseIndent();
1110 for (String key : sortedKeys) {
1111 if (configApp.get(key) != null && configApp.get(key) instanceof Object[]) {
1112 indentPW.println(key + " = " +
1113 Arrays.toString((Object[]) configApp.get(key)));
1114 } else if (configApp.get(key) != null && configApp.get(key) instanceof int[]) {
1115 indentPW.println(key + " = " + Arrays.toString((int[]) configApp.get(key)));
1116 } else {
1117 indentPW.println(key + " = " + configApp.get(key));
1118 }
Junda Liu43d723a2015-05-12 17:23:45 -07001119 }
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001120 indentPW.decreaseIndent();
1121 indentPW.decreaseIndent();
1122 indentPW.decreaseIndent();
1123 indentPW.println("");
Junda Liu43d723a2015-05-12 17:23:45 -07001124 }
1125
Jordan Liu178430d2020-02-10 14:32:15 -08001126 private void unbindIfBound(Context context, CarrierServiceConnection conn,
1127 int phoneId) {
1128 if (mServiceBound[phoneId]) {
1129 mServiceBound[phoneId] = false;
Jordan Liu46ed5db2020-01-28 08:55:20 -08001130 context.unbindService(conn);
1131 }
1132 }
1133
Zach Johnson36d7aab2015-05-22 15:43:00 -07001134 private class CarrierServiceConnection implements ServiceConnection {
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001135 int phoneId;
1136 int eventId;
1137 IBinder service;
1138
Zach Johnson36d7aab2015-05-22 15:43:00 -07001139 public CarrierServiceConnection(int phoneId, int eventId) {
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001140 this.phoneId = phoneId;
1141 this.eventId = eventId;
1142 }
1143
1144 @Override
1145 public void onServiceConnected(ComponentName name, IBinder service) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001146 logd("Connected to config app: " + name.flattenToShortString());
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001147 this.service = service;
1148 mHandler.sendMessage(mHandler.obtainMessage(eventId, phoneId, -1, this));
1149 }
1150
1151 @Override
1152 public void onServiceDisconnected(ComponentName name) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001153 logd("Disconnected from config app: " + name.flattenToShortString());
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001154 this.service = null;
Jordan Liu46ed5db2020-01-28 08:55:20 -08001155 }
1156
1157 @Override
1158 public void onBindingDied(ComponentName name) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001159 logd("Binding died from config app: " + name.flattenToShortString());
Jordan Liu46ed5db2020-01-28 08:55:20 -08001160 this.service = null;
Jordan Liu46ed5db2020-01-28 08:55:20 -08001161 }
1162
1163 @Override
1164 public void onNullBinding(ComponentName name) {
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001165 logd("Null binding from config app: " + name.flattenToShortString());
Jordan Liu46ed5db2020-01-28 08:55:20 -08001166 this.service = null;
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001167 }
1168 }
1169
1170 private class ConfigLoaderBroadcastReceiver extends BroadcastReceiver {
1171 @Override
1172 public void onReceive(Context context, Intent intent) {
1173 String action = intent.getAction();
Junda Liu8a8a53a2015-05-15 16:19:57 -07001174 boolean replace = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
1175 // If replace is true, only care ACTION_PACKAGE_REPLACED.
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001176 if (replace && !Intent.ACTION_PACKAGE_REPLACED.equals(action)) {
Junda Liu8a8a53a2015-05-15 16:19:57 -07001177 return;
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001178 }
Junda Liu8a8a53a2015-05-15 16:19:57 -07001179
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001180 switch (action) {
Nanxi Chen3d670502016-03-17 16:32:09 -07001181 case Intent.ACTION_BOOT_COMPLETED:
1182 mHandler.sendMessage(mHandler.obtainMessage(EVENT_SYSTEM_UNLOCKED, null));
1183 break;
1184
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001185 case Intent.ACTION_PACKAGE_ADDED:
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001186 case Intent.ACTION_PACKAGE_REMOVED:
Junda Liu8a8a53a2015-05-15 16:19:57 -07001187 case Intent.ACTION_PACKAGE_REPLACED:
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001188 int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);
1189 String packageName = mContext.getPackageManager().getNameForUid(uid);
Junda Liu8a8a53a2015-05-15 16:19:57 -07001190 if (packageName != null) {
1191 // We don't have a phoneId for arg1.
1192 mHandler.sendMessage(
1193 mHandler.obtainMessage(EVENT_PACKAGE_CHANGED, packageName));
1194 }
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001195 break;
Jonathan Basseri1f743c92015-05-15 00:19:46 -07001196 }
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001197 }
1198 }
1199
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001200 private void logd(String msg) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -07001201 Log.d(LOG_TAG, msg);
1202 }
1203
Hunter Knepshield9f091fc2020-01-28 17:41:43 -08001204 private void logdWithLocalLog(String msg) {
chen xudb04c292019-03-26 17:01:15 -07001205 Log.d(LOG_TAG, msg);
1206 mCarrierConfigLoadingLog.log(msg);
1207 }
1208
1209 private void loge(String msg) {
Jonathan Basseri6b50e9f2015-05-12 20:18:31 -07001210 Log.e(LOG_TAG, msg);
chen xudb04c292019-03-26 17:01:15 -07001211 mCarrierConfigLoadingLog.log(msg);
Jonathan Basseri6465afd2015-02-25 13:05:57 -08001212 }
1213}