blob: 3616b18c21136856306a9d5a0d014c75a065ffcc [file] [log] [blame]
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -08001/**
2 * Copyright (C) 2007 Google Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 * use this file except in compliance with the License. You may obtain a copy
6 * 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, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations
14 * under the License.
15 */
16
17package com.android.settings;
18
Daniel Nishi422e7c32017-02-09 16:07:22 -080019import static android.content.Intent.EXTRA_USER;
20import static android.content.Intent.EXTRA_USER_ID;
21import static android.text.format.DateUtils.FORMAT_ABBREV_MONTH;
22import static android.text.format.DateUtils.FORMAT_SHOW_DATE;
23
Raff Tsaiafd494d2019-10-16 15:25:21 +080024import static com.android.settings.applications.manageapplications.ManageApplications.EXTRA_PERSONAL_ONLY;
25import static com.android.settings.applications.manageapplications.ManageApplications.EXTRA_WORK_ONLY;
26
Alexandra Gherghina7d748c02014-06-27 12:33:42 +010027import android.annotation.Nullable;
tmfangaed8f362019-03-18 16:56:09 +080028import android.app.ActionBar;
29import android.app.Activity;
Amith Yamasaniae697552011-09-27 11:33:17 -070030import android.app.ActivityManager;
Sudheer Shankabc956302015-04-09 12:19:53 +010031import android.app.AppGlobals;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010032import android.app.IActivityManager;
Rubin Xu3231afe2016-08-24 10:15:07 +010033import android.app.KeyguardManager;
Sudheer Shankabc956302015-04-09 12:19:53 +010034import android.app.admin.DevicePolicyManager;
Daniel Nishi31027da2017-01-19 14:03:57 -080035import android.content.ActivityNotFoundException;
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -080036import android.content.ComponentName;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070037import android.content.ContentResolver;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080038import android.content.Context;
39import android.content.Intent;
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -080040import android.content.IntentFilter;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080041import android.content.pm.ApplicationInfo;
Sudheer Shankabc956302015-04-09 12:19:53 +010042import android.content.pm.IPackageManager;
Christopher Tatea08a2252015-07-01 16:52:43 -070043import android.content.pm.IntentFilterVerificationInfo;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080044import android.content.pm.PackageManager;
Jason Monk75199542016-05-06 15:09:32 -040045import android.content.pm.PackageManager.NameNotFoundException;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070046import android.content.pm.ResolveInfo;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070047import android.content.pm.UserInfo;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020048import android.content.res.Resources;
Jason Monkb5aa73f2015-03-31 12:59:33 -040049import android.content.res.TypedArray;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070050import android.database.Cursor;
Amith Yamasanif34a85d2012-09-17 18:31:45 -070051import android.graphics.Bitmap;
Felipe Lemebd884502017-09-15 18:16:21 -070052import android.graphics.Canvas;
53import android.graphics.drawable.BitmapDrawable;
54import android.graphics.drawable.Drawable;
Phil Weaver5a3e02d2018-03-08 17:38:46 -080055import android.graphics.drawable.VectorDrawable;
Kevin Chyn4882e872018-06-25 17:58:31 -070056import android.hardware.face.FaceManager;
Jeff Sharkeyab508072016-10-11 14:25:22 -060057import android.hardware.fingerprint.FingerprintManager;
Amith Yamasanic06d4c42011-02-25 14:35:20 -080058import android.net.ConnectivityManager;
59import android.net.LinkProperties;
Jaewoong Jungc260e6d2016-10-13 14:21:52 -070060import android.net.Network;
Jaewoong Jungc260e6d2016-10-13 14:21:52 -070061import android.net.wifi.WifiManager;
Amith Yamasania4379d62011-07-22 10:34:58 -070062import android.os.BatteryManager;
Ng Zhi Anb97bdc32019-02-01 12:39:31 -080063import android.os.Build;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020064import android.os.Bundle;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010065import android.os.IBinder;
Jason Monkb45e27b2015-05-20 13:35:43 -040066import android.os.INetworkManagementService;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010067import android.os.RemoteException;
Jason Monkb45e27b2015-05-20 13:35:43 -040068import android.os.ServiceManager;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070069import android.os.UserHandle;
70import android.os.UserManager;
Fabrice Di Megliodff3faa2015-02-27 11:14:11 -080071import android.os.storage.StorageManager;
Daniel Nishi9f60f422017-02-15 15:25:48 -080072import android.os.storage.VolumeInfo;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070073import android.preference.PreferenceFrameLayout;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070074import android.provider.ContactsContract.CommonDataKinds;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070075import android.provider.ContactsContract.Contacts;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070076import android.provider.ContactsContract.Data;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070077import android.provider.ContactsContract.Profile;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070078import android.provider.ContactsContract.RawContacts;
Udam Saini679f7ad2016-03-25 10:47:00 -070079import android.provider.Settings;
markchien1dd1d792019-01-11 16:18:20 +080080import android.telephony.SubscriptionManager;
Amith Yamasani60133dd2010-09-11 14:17:31 -070081import android.telephony.TelephonyManager;
Julia Reynoldsce25af42015-07-08 16:56:31 -040082import android.text.Spannable;
83import android.text.SpannableString;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020084import android.text.TextUtils;
Jason Monkb37e2882016-01-11 14:27:20 -050085import android.text.format.DateUtils;
Julia Reynoldsce25af42015-07-08 16:56:31 -040086import android.text.style.TtsSpan;
Christopher Tatea08a2252015-07-01 16:52:43 -070087import android.util.ArraySet;
Raff Tsaiafd494d2019-10-16 15:25:21 +080088import android.util.FeatureFlagUtils;
jackqdyuleifde637f2018-01-02 14:51:01 -080089import android.util.IconDrawableFactory;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010090import android.util.Log;
Zoltan Szatmary-Ban3af2e4c2014-12-19 17:17:23 +000091import android.view.LayoutInflater;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070092import android.view.View;
93import android.view.ViewGroup;
PMS2263a05602017-06-14 07:10:15 +000094import android.widget.EditText;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070095import android.widget.ListView;
96import android.widget.TabWidget;
Fan Zhangcc335d92016-09-29 14:37:14 -070097
Fan Zhang23f8d592018-08-28 15:11:40 -070098import androidx.annotation.StringRes;
Jason Chiuc78c54a2019-02-13 16:07:57 +080099import androidx.core.graphics.drawable.IconCompat;
Fan Zhang23f8d592018-08-28 15:11:40 -0700100import androidx.fragment.app.Fragment;
tmfangaed8f362019-03-18 16:56:09 +0800101import androidx.lifecycle.Lifecycle;
Fan Zhang23f8d592018-08-28 15:11:40 -0700102import androidx.preference.Preference;
103import androidx.preference.PreferenceGroup;
104
Ricky Wai616342b2016-04-13 10:40:22 +0100105import com.android.internal.app.UnlaunchableAppActivity;
Ricky Wai72500162016-06-07 16:54:25 +0100106import com.android.internal.util.ArrayUtils;
Rubin Xu3231afe2016-08-24 10:15:07 +0100107import com.android.internal.widget.LockPatternUtils;
Antony Sargent627f14b2019-03-04 16:00:59 -0800108import com.android.settings.core.FeatureFlags;
Raff Tsaiafd494d2019-10-16 15:25:21 +0800109import com.android.settings.dashboard.profileselector.ProfileFragmentBridge;
Antony Sargent627f14b2019-03-04 16:00:59 -0800110import com.android.settings.development.featureflags.FeatureFlagPersistent;
Jeff Sharkey219ec912017-12-19 14:57:39 -0700111import com.android.settings.password.ChooseLockSettingsHelper;
tmfangaed8f362019-03-18 16:56:09 +0800112import com.android.settingslib.widget.ActionBarShadowController;
Daisuke Miyakawaa2633d02010-09-15 20:09:12 -0700113
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800114import java.net.InetAddress;
115import java.util.Iterator;
Daisuke Miyakawaa2633d02010-09-15 20:09:12 -0700116import java.util.List;
Jean Chalard71ad1f42011-05-12 15:06:16 +0900117import java.util.Locale;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800118
Jason Monk27985e12016-01-08 14:13:05 -0500119public final class Utils extends com.android.settingslib.Utils {
120
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100121 private static final String TAG = "Settings";
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100122
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800123 /**
124 * Set the preference's title to the matching activity's label.
125 */
126 public static final int UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY = 1;
127
Fan Zhangc3fd2892019-01-29 16:00:19 -0800128 public static final String SETTINGS_PACKAGE_NAME = "com.android.settings";
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100129
Jason Monkbeb171d2015-05-21 15:24:37 -0400130 public static final String OS_PKG = "os";
131
Anders Hammar1b2dd9032010-04-08 10:03:50 +0200132 /**
Svet Ganov864765f2019-04-05 19:00:05 -0700133 * Whether to disable the new device identifier access restrictions.
134 */
135 public static final String PROPERTY_DEVICE_IDENTIFIER_ACCESS_RESTRICTIONS_DISABLED =
136 "device_identifier_access_restrictions_disabled";
137
138 /**
Joel Galenson2118f8a2019-05-31 07:54:20 -0700139 * Whether to show the Permissions Hub.
140 */
141 public static final String PROPERTY_PERMISSIONS_HUB_ENABLED = "permissions_hub_enabled";
142
143 /**
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800144 * Finds a matching activity for a preference's intent. If a matching
145 * activity is not found, it will remove the preference.
Ying Wanga7188322010-01-04 18:45:10 -0800146 *
Sunny Shao7e866b62019-08-09 11:42:04 +0800147 * @param context The context.
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800148 * @param parentPreferenceGroup The preference group that contains the
Sunny Shao7e866b62019-08-09 11:42:04 +0800149 * preference whose intent is being resolved.
150 * @param preferenceKey The key of the preference whose intent is being
151 * resolved.
152 * @param flags 0 or one or more of
153 * {@link #UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY}
154 * .
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800155 * @return Whether an activity was found. If false, the preference was
Sunny Shao7e866b62019-08-09 11:42:04 +0800156 * removed.
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800157 */
158 public static boolean updatePreferenceToSpecificActivityOrRemove(Context context,
159 PreferenceGroup parentPreferenceGroup, String preferenceKey, int flags) {
Ying Wanga7188322010-01-04 18:45:10 -0800160
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800161 Preference preference = parentPreferenceGroup.findPreference(preferenceKey);
162 if (preference == null) {
163 return false;
164 }
Ying Wanga7188322010-01-04 18:45:10 -0800165
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800166 Intent intent = preference.getIntent();
167 if (intent != null) {
168 // Find the activity that is in the system image
169 PackageManager pm = context.getPackageManager();
170 List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
171 int listSize = list.size();
172 for (int i = 0; i < listSize; i++) {
173 ResolveInfo resolveInfo = list.get(i);
174 if ((resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
175 != 0) {
Ying Wanga7188322010-01-04 18:45:10 -0800176
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800177 // Replace the intent with this specific activity
178 preference.setIntent(new Intent().setClassName(
179 resolveInfo.activityInfo.packageName,
180 resolveInfo.activityInfo.name));
181
182 if ((flags & UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY) != 0) {
183 // Set the preference title to the activity's label
184 preference.setTitle(resolveInfo.loadLabel(pm));
185 }
Ying Wanga7188322010-01-04 18:45:10 -0800186
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800187 return true;
188 }
189 }
190 }
191
192 // Did not find a matching activity, so remove the preference
193 parentPreferenceGroup.removePreference(preference);
Ying Wanga7188322010-01-04 18:45:10 -0800194
Shuhrat Dehkanov7dc567a2012-04-23 01:59:56 +0900195 return false;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800196 }
Ying Wanga7188322010-01-04 18:45:10 -0800197
Anders Hammar1b2dd9032010-04-08 10:03:50 +0200198 /**
Benjamin Franz194300d2016-01-13 12:16:25 +0000199 * Returns the UserManager for a given context
200 *
201 * @throws IllegalStateException if no UserManager could be retrieved.
202 */
203 public static UserManager getUserManager(Context context) {
204 UserManager um = UserManager.get(context);
205 if (um == null) {
206 throw new IllegalStateException("Unable to load UserManager");
207 }
208 return um;
209 }
210
211 /**
Ying Wanga7188322010-01-04 18:45:10 -0800212 * Returns true if Monkey is running.
213 */
214 public static boolean isMonkeyRunning() {
Amith Yamasaniae697552011-09-27 11:33:17 -0700215 return ActivityManager.isUserAMonkey();
Ying Wanga7188322010-01-04 18:45:10 -0800216 }
Amith Yamasani60133dd2010-09-11 14:17:31 -0700217
218 /**
219 * Returns whether the device is voice-capable (meaning, it is also a phone).
220 */
221 public static boolean isVoiceCapable(Context context) {
222 TelephonyManager telephony =
223 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
224 return telephony != null && telephony.isVoiceCapable();
225 }
Amith Yamasani0f85c482011-02-23 17:19:11 -0800226
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800227 /**
228 * Returns the WIFI IP Addresses, if any, taking into account IPv4 and IPv6 style addresses.
229 * @param context the application context
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900230 * @return the formatted and newline-separated IP addresses, or null if none.
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800231 */
232 public static String getWifiIpAddresses(Context context) {
Jaewoong Jungc260e6d2016-10-13 14:21:52 -0700233 WifiManager wifiManager = context.getSystemService(WifiManager.class);
234 Network currentNetwork = wifiManager.getCurrentNetwork();
235 if (currentNetwork != null) {
236 ConnectivityManager cm = (ConnectivityManager)
Sunny Shao7e866b62019-08-09 11:42:04 +0800237 context.getSystemService(Context.CONNECTIVITY_SERVICE);
Jaewoong Jungc260e6d2016-10-13 14:21:52 -0700238 LinkProperties prop = cm.getLinkProperties(currentNetwork);
239 return formatIpAddresses(prop);
240 }
241 return null;
Amith Yamasani6822b742011-10-17 16:41:00 -0700242 }
243
Amith Yamasani6822b742011-10-17 16:41:00 -0700244 private static String formatIpAddresses(LinkProperties prop) {
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800245 if (prop == null) return null;
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900246 Iterator<InetAddress> iter = prop.getAllAddresses().iterator();
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800247 // If there are no entries, return null
248 if (!iter.hasNext()) return null;
249 // Concatenate all available addresses, comma separated
250 String addresses = "";
251 while (iter.hasNext()) {
252 addresses += iter.next().getHostAddress();
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900253 if (iter.hasNext()) addresses += "\n";
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800254 }
255 return addresses;
256 }
Jean Chalard71ad1f42011-05-12 15:06:16 +0900257
258 public static Locale createLocaleFromString(String localeStr) {
259 // TODO: is there a better way to actually construct a locale that will match?
260 // The main problem is, on top of Java specs, locale.toString() and
261 // new Locale(locale.toString()).toString() do not return equal() strings in
262 // many cases, because the constructor takes the only string as the language
263 // code. So : new Locale("en", "US").toString() => "en_US"
264 // And : new Locale("en_US").toString() => "en_us"
Sunny Shao7e866b62019-08-09 11:42:04 +0800265 if (null == localeStr)
Jean Chalard71ad1f42011-05-12 15:06:16 +0900266 return Locale.getDefault();
267 String[] brokenDownLocale = localeStr.split("_", 3);
268 // split may not return a 0-length array.
269 if (1 == brokenDownLocale.length) {
270 return new Locale(brokenDownLocale[0]);
271 } else if (2 == brokenDownLocale.length) {
272 return new Locale(brokenDownLocale[0], brokenDownLocale[1]);
273 } else {
274 return new Locale(brokenDownLocale[0], brokenDownLocale[1], brokenDownLocale[2]);
275 }
276 }
Amith Yamasania4379d62011-07-22 10:34:58 -0700277
Jaewan Kima3fe77b2013-06-04 21:17:40 +0900278 public static boolean isBatteryPresent(Intent batteryChangedIntent) {
279 return batteryChangedIntent.getBooleanExtra(BatteryManager.EXTRA_PRESENT, true);
280 }
281
Amith Yamasania4379d62011-07-22 10:34:58 -0700282 public static String getBatteryPercentage(Intent batteryChangedIntent) {
Elliott Hughes7253df32014-09-02 17:10:14 -0700283 return formatPercentage(getBatteryLevel(batteryChangedIntent));
Dianne Hackborn525f2bd2014-04-29 11:24:06 -0700284 }
285
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700286 /**
287 * Prepare a custom preferences layout, moving padding to {@link ListView}
288 * when outside scrollbars are requested. Usually used to display
289 * {@link ListView} and {@link TabWidget} with correct padding.
290 */
Jeff Sharkey5d706792011-09-08 18:57:17 -0700291 public static void prepareCustomPreferencesList(
Jeff Sharkey97d07fa2012-11-30 12:36:53 -0800292 ViewGroup parent, View child, View list, boolean ignoreSidePadding) {
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700293 final boolean movePadding = list.getScrollBarStyle() == View.SCROLLBARS_OUTSIDE_OVERLAY;
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700294 if (movePadding) {
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700295 final Resources res = list.getResources();
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700296 final int paddingBottom = res.getDimensionPixelSize(
297 com.android.internal.R.dimen.preference_fragment_padding_bottom);
Jeff Sharkey5d706792011-09-08 18:57:17 -0700298
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700299 if (parent instanceof PreferenceFrameLayout) {
300 ((PreferenceFrameLayout.LayoutParams) child.getLayoutParams()).removeBorders = true;
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700301 }
Doris Lingc5a1b4f2019-02-20 16:33:24 -0800302 list.setPaddingRelative(0 /* start */, 0 /* top */, 0 /* end */, paddingBottom);
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700303 }
304 }
Jeff Sharkeya83a24f2011-09-16 01:52:39 -0700305
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700306 public static void forceCustomPadding(View view, boolean additive) {
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700307 final Resources res = view.getResources();
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700308
Doris Lingc5a1b4f2019-02-20 16:33:24 -0800309 final int paddingStart = additive ? view.getPaddingStart() : 0;
310 final int paddingEnd = additive ? view.getPaddingEnd() : 0;
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700311 final int paddingBottom = res.getDimensionPixelSize(
312 com.android.internal.R.dimen.preference_fragment_padding_bottom);
313
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700314 view.setPaddingRelative(paddingStart, 0, paddingEnd, paddingBottom);
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700315 }
316
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700317 public static String getMeProfileName(Context context, boolean full) {
318 if (full) {
319 return getProfileDisplayName(context);
320 } else {
321 return getShorterNameIfPossible(context);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700322 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700323 }
324
325 private static String getShorterNameIfPossible(Context context) {
326 final String given = getLocalProfileGivenName(context);
327 return !TextUtils.isEmpty(given) ? given : getProfileDisplayName(context);
328 }
329
330 private static String getLocalProfileGivenName(Context context) {
331 final ContentResolver cr = context.getContentResolver();
332
333 // Find the raw contact ID for the local ME profile raw contact.
334 final long localRowProfileId;
335 final Cursor localRawProfile = cr.query(
336 Profile.CONTENT_RAW_CONTACTS_URI,
Sunny Shao7e866b62019-08-09 11:42:04 +0800337 new String[] {RawContacts._ID},
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700338 RawContacts.ACCOUNT_TYPE + " IS NULL AND " +
339 RawContacts.ACCOUNT_NAME + " IS NULL",
340 null, null);
341 if (localRawProfile == null) return null;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700342
343 try {
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700344 if (!localRawProfile.moveToFirst()) {
345 return null;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700346 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700347 localRowProfileId = localRawProfile.getLong(0);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700348 } finally {
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700349 localRawProfile.close();
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700350 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700351
352 // Find the structured name for the raw contact.
353 final Cursor structuredName = cr.query(
354 Profile.CONTENT_URI.buildUpon().appendPath(Contacts.Data.CONTENT_DIRECTORY).build(),
Sunny Shao7e866b62019-08-09 11:42:04 +0800355 new String[] {CommonDataKinds.StructuredName.GIVEN_NAME,
356 CommonDataKinds.StructuredName.FAMILY_NAME},
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700357 Data.RAW_CONTACT_ID + "=" + localRowProfileId,
358 null, null);
359 if (structuredName == null) return null;
360
361 try {
362 if (!structuredName.moveToFirst()) {
363 return null;
364 }
365 String partialName = structuredName.getString(0);
366 if (TextUtils.isEmpty(partialName)) {
367 partialName = structuredName.getString(1);
368 }
369 return partialName;
370 } finally {
371 structuredName.close();
372 }
373 }
374
375 private static final String getProfileDisplayName(Context context) {
376 final ContentResolver cr = context.getContentResolver();
377 final Cursor profile = cr.query(Profile.CONTENT_URI,
Sunny Shao7e866b62019-08-09 11:42:04 +0800378 new String[] {Profile.DISPLAY_NAME}, null, null, null);
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700379 if (profile == null) return null;
380
381 try {
382 if (!profile.moveToFirst()) {
383 return null;
384 }
385 return profile.getString(0);
386 } finally {
387 profile.close();
388 }
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700389 }
Amith Yamasani9627a8e2012-09-23 12:54:14 -0700390
Amith Yamasani9627a8e2012-09-23 12:54:14 -0700391 public static boolean hasMultipleUsers(Context context) {
392 return ((UserManager) context.getSystemService(Context.USER_SERVICE))
393 .getUsers().size() > 1;
394 }
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700395
396 /**
Esteban Talavera9b86e9c2017-05-30 16:48:08 +0100397 * Returns the managed profile of the current user or {@code null} if none is found or a profile
398 * exists but it is disabled.
Alexandra Gherghina3939cd72014-06-04 10:02:55 +0100399 */
400 public static UserHandle getManagedProfile(UserManager userManager) {
401 List<UserHandle> userProfiles = userManager.getUserProfiles();
Aarthi Balachanderd0f83592018-07-10 17:04:53 -0700402 for (UserHandle profile : userProfiles) {
Alexandra Gherghina3939cd72014-06-04 10:02:55 +0100403 if (profile.getIdentifier() == userManager.getUserHandle()) {
404 continue;
405 }
406 final UserInfo userInfo = userManager.getUserInfo(profile.getIdentifier());
407 if (userInfo.isManagedProfile()) {
408 return profile;
409 }
410 }
411 return null;
412 }
413
414 /**
Esteban Talavera9b86e9c2017-05-30 16:48:08 +0100415 * Returns the managed profile of the current user or {@code null} if none is found. Unlike
416 * {@link #getManagedProfile} this method returns enabled and disabled managed profiles.
417 */
418 public static UserHandle getManagedProfileWithDisabled(UserManager userManager) {
419 // TODO: Call getManagedProfileId from here once Robolectric supports
420 // API level 24 and UserManager.getProfileIdsWithDisabled can be Mocked (to avoid having
421 // yet another implementation that loops over user profiles in this method). In the meantime
422 // we need to use UserManager.getProfiles that is available on API 23 (the one currently
423 // used for Settings Robolectric tests).
424 final int myUserId = UserHandle.myUserId();
425 List<UserInfo> profiles = userManager.getProfiles(myUserId);
426 final int count = profiles.size();
427 for (int i = 0; i < count; i++) {
428 final UserInfo profile = profiles.get(i);
429 if (profile.isManagedProfile()
430 && profile.getUserHandle().getIdentifier() != myUserId) {
431 return profile.getUserHandle();
432 }
433 }
434 return null;
435 }
436
437 /**
Clara Bayarri462cce12016-02-18 12:09:21 +0000438 * Retrieves the id for the given user's managed profile.
439 *
440 * @return the managed profile id or UserHandle.USER_NULL if there is none.
441 */
442 public static int getManagedProfileId(UserManager um, int parentUserId) {
Fyodor Kupolov4a4af5a2016-04-07 16:46:18 -0700443 int[] profileIds = um.getProfileIdsWithDisabled(parentUserId);
444 for (int profileId : profileIds) {
445 if (profileId != parentUserId) {
446 return profileId;
Clara Bayarri462cce12016-02-18 12:09:21 +0000447 }
448 }
449 return UserHandle.USER_NULL;
450 }
451
452 /**
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100453 * Returns the target user for a Settings activity.
Tony Mak8f41b9b2016-11-23 11:36:18 +0000454 * <p>
455 * User would be retrieved in this order:
456 * <ul>
457 * <li> If this activity is launched from other user, return that user id.
458 * <li> If this is launched from the Settings app in same user, return the user contained as an
Sunny Shao7e866b62019-08-09 11:42:04 +0800459 * extra in the arguments or intent extras.
Tony Mak8f41b9b2016-11-23 11:36:18 +0000460 * <li> Otherwise, return UserHandle.myUserId().
461 * </ul>
462 * <p>
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100463 * Note: This is secure in the sense that it only returns a target user different to the current
464 * one if the app launching this activity is the Settings app itself, running in the same user
465 * or in one that is in the same profile group, or if the user id is provided by the system.
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100466 */
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100467 public static UserHandle getSecureTargetUser(IBinder activityToken,
Tony Mak8f41b9b2016-11-23 11:36:18 +0000468 UserManager um, @Nullable Bundle arguments, @Nullable Bundle intentExtras) {
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100469 UserHandle currentUser = new UserHandle(UserHandle.myUserId());
Sudheer Shankaacb1a612016-11-10 15:30:14 -0800470 IActivityManager am = ActivityManager.getService();
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100471 try {
472 String launchedFromPackage = am.getLaunchedFromPackage(activityToken);
473 boolean launchedFromSettingsApp = SETTINGS_PACKAGE_NAME.equals(launchedFromPackage);
474
475 UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId(
476 am.getLaunchedFromUid(activityToken)));
477 if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) {
478 // Check it's secure
479 if (isProfileOf(um, launchedFromUser)) {
480 return launchedFromUser;
481 }
482 }
Tony Mak8f41b9b2016-11-23 11:36:18 +0000483 UserHandle extrasUser = getUserHandleFromBundle(intentExtras);
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100484 if (extrasUser != null && !extrasUser.equals(currentUser)) {
485 // Check it's secure
486 if (launchedFromSettingsApp && isProfileOf(um, extrasUser)) {
487 return extrasUser;
488 }
489 }
Tony Mak8f41b9b2016-11-23 11:36:18 +0000490 UserHandle argumentsUser = getUserHandleFromBundle(arguments);
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100491 if (argumentsUser != null && !argumentsUser.equals(currentUser)) {
492 // Check it's secure
493 if (launchedFromSettingsApp && isProfileOf(um, argumentsUser)) {
494 return argumentsUser;
495 }
496 }
497 } catch (RemoteException e) {
498 // Should not happen
499 Log.v(TAG, "Could not talk to activity manager.", e);
500 }
501 return currentUser;
Tony Mak8f41b9b2016-11-23 11:36:18 +0000502 }
503
504 /**
505 * Lookup both {@link Intent#EXTRA_USER} and {@link Intent#EXTRA_USER_ID} in the bundle
506 * and return the {@link UserHandle} object. Return {@code null} if nothing is found.
507 */
Sunny Shao7e866b62019-08-09 11:42:04 +0800508 private static @Nullable UserHandle getUserHandleFromBundle(Bundle bundle) {
Tony Mak8f41b9b2016-11-23 11:36:18 +0000509 if (bundle == null) {
510 return null;
511 }
512 final UserHandle user = bundle.getParcelable(EXTRA_USER);
513 if (user != null) {
514 return user;
515 }
516 final int userId = bundle.getInt(EXTRA_USER_ID, -1);
517 if (userId != -1) {
518 return UserHandle.of(userId);
519 }
520 return null;
521 }
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100522
Sunny Shao7e866b62019-08-09 11:42:04 +0800523 /**
524 * Returns true if the user provided is in the same profiles group as the current user.
525 */
526 private static boolean isProfileOf(UserManager um, UserHandle otherUser) {
527 if (um == null || otherUser == null) return false;
528 return (UserHandle.myUserId() == otherUser.getIdentifier())
529 || um.getUserProfiles().contains(otherUser);
530 }
Amith Yamasani51c6dac2014-07-02 00:06:37 +0530531
Alexandra Gherghina95b86a52014-07-24 19:13:25 +0100532 /**
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700533 * Return whether or not the user should have a SIM Cards option in Settings.
534 * TODO: Change back to returning true if count is greater than one after testing.
535 * TODO: See bug 16533525.
536 */
537 public static boolean showSimCardTile(Context context) {
Antony Sargent627f14b2019-03-04 16:00:59 -0800538 if (FeatureFlagPersistent.isEnabled(context, FeatureFlags.NETWORK_INTERNET_V2)) {
539 return false;
540 }
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700541 final TelephonyManager tm =
542 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
543
PauloftheWestdbd03822014-12-04 11:56:35 -0800544 return tm.getSimCount() > 1;
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700545 }
Dan Sandlerb58b5122014-09-02 18:31:49 +0200546
547 /**
Amith Yamasani45f86232014-11-19 17:12:46 -0800548 * Queries for the UserInfo of a user. Returns null if the user doesn't exist (was removed).
549 * @param userManager Instance of UserManager
Sunny Shao7e866b62019-08-09 11:42:04 +0800550 * @param checkUser The user to check the existence of.
Amith Yamasani45f86232014-11-19 17:12:46 -0800551 * @return UserInfo of the user or null for non-existent user.
552 */
553 public static UserInfo getExistingUser(UserManager userManager, UserHandle checkUser) {
554 final List<UserInfo> users = userManager.getUsers(true /* excludeDying */);
555 final int checkUserId = checkUser.getIdentifier();
556 for (UserInfo user : users) {
557 if (user.id == checkUserId) {
558 return user;
559 }
560 }
561 return null;
562 }
563
Zoltan Szatmary-Ban3af2e4c2014-12-19 17:17:23 +0000564 public static View inflateCategoryHeader(LayoutInflater inflater, ViewGroup parent) {
565 final TypedArray a = inflater.getContext().obtainStyledAttributes(null,
566 com.android.internal.R.styleable.Preference,
567 com.android.internal.R.attr.preferenceCategoryStyle, 0);
568 final int resId = a.getResourceId(com.android.internal.R.styleable.Preference_layout,
569 0);
570 a.recycle();
571 return inflater.inflate(resId, parent, false);
572 }
573
Christopher Tatea08a2252015-07-01 16:52:43 -0700574 public static ArraySet<String> getHandledDomains(PackageManager pm, String packageName) {
575 List<IntentFilterVerificationInfo> iviList = pm.getIntentFilterVerifications(packageName);
576 List<IntentFilter> filters = pm.getAllIntentFilters(packageName);
577
578 ArraySet<String> result = new ArraySet<>();
Fan Zhang4e540db2017-11-08 13:06:38 -0800579 if (iviList != null && iviList.size() > 0) {
Christopher Tatea08a2252015-07-01 16:52:43 -0700580 for (IntentFilterVerificationInfo ivi : iviList) {
581 for (String host : ivi.getDomains()) {
582 result.add(host);
583 }
584 }
585 }
586 if (filters != null && filters.size() > 0) {
587 for (IntentFilter filter : filters) {
Christopher Tateddaa1422015-07-16 16:00:49 -0700588 if (filter.hasCategory(Intent.CATEGORY_BROWSABLE)
589 && (filter.hasDataScheme(IntentFilter.SCHEME_HTTP) ||
Sunny Shao7e866b62019-08-09 11:42:04 +0800590 filter.hasDataScheme(IntentFilter.SCHEME_HTTPS))) {
Christopher Tatea08a2252015-07-01 16:52:43 -0700591 result.addAll(filter.getHostsList());
592 }
593 }
594 }
595 return result;
596 }
597
Sudheer Shankabc956302015-04-09 12:19:53 +0100598 /**
599 * Returns the application info of the currently installed MDM package.
600 */
601 public static ApplicationInfo getAdminApplicationInfo(Context context, int profileId) {
602 DevicePolicyManager dpm =
603 (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);
604 ComponentName mdmPackage = dpm.getProfileOwnerAsUser(profileId);
605 if (mdmPackage == null) {
606 return null;
607 }
608 String mdmPackageName = mdmPackage.getPackageName();
609 try {
610 IPackageManager ipm = AppGlobals.getPackageManager();
611 ApplicationInfo mdmApplicationInfo =
612 ipm.getApplicationInfo(mdmPackageName, 0, profileId);
613 return mdmApplicationInfo;
614 } catch (RemoteException e) {
615 Log.e(TAG, "Error while retrieving application info for package " + mdmPackageName
616 + ", userId " + profileId, e);
617 return null;
618 }
619 }
Jason Monkb45e27b2015-05-20 13:35:43 -0400620
621 public static boolean isBandwidthControlEnabled() {
622 final INetworkManagementService netManager = INetworkManagementService.Stub
623 .asInterface(ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE));
624 try {
625 return netManager.isBandwidthControlEnabled();
626 } catch (RemoteException e) {
627 return false;
628 }
629 }
Julia Reynoldsce25af42015-07-08 16:56:31 -0400630
631 /**
632 * Returns an accessible SpannableString.
Sunny Shao7e866b62019-08-09 11:42:04 +0800633 * @param displayText the text to display
Julia Reynoldsce25af42015-07-08 16:56:31 -0400634 * @param accessibileText the text text-to-speech engines should read
635 */
636 public static SpannableString createAccessibleSequence(CharSequence displayText,
637 String accessibileText) {
638 SpannableString str = new SpannableString(displayText);
639 str.setSpan(new TtsSpan.TextBuilder(accessibileText).build(), 0,
640 displayText.length(),
641 Spannable.SPAN_INCLUSIVE_INCLUSIVE);
642 return str;
643 }
Andres Morales7bdffd82015-08-04 16:55:00 -0700644
Clara Bayarrife432e82015-10-12 12:07:02 +0100645 /**
Jeff Sharkey219ec912017-12-19 14:57:39 -0700646 * Returns the user id present in the bundle with
647 * {@link Intent#EXTRA_USER_ID} if it belongs to the current user.
Clara Bayarrife432e82015-10-12 12:07:02 +0100648 *
Jeff Sharkey219ec912017-12-19 14:57:39 -0700649 * @throws SecurityException if the given userId does not belong to the
Sunny Shao7e866b62019-08-09 11:42:04 +0800650 * current user group.
Clara Bayarrife432e82015-10-12 12:07:02 +0100651 */
Benjamin Franz194300d2016-01-13 12:16:25 +0000652 public static int getUserIdFromBundle(Context context, Bundle bundle) {
Jeff Sharkey219ec912017-12-19 14:57:39 -0700653 return getUserIdFromBundle(context, bundle, false);
654 }
655
656 /**
657 * Returns the user id present in the bundle with
658 * {@link Intent#EXTRA_USER_ID} if it belongs to the current user.
659 *
660 * @param isInternal indicating if the caller is "internal" to the system,
Sunny Shao7e866b62019-08-09 11:42:04 +0800661 * meaning we're willing to trust extras like
662 * {@link ChooseLockSettingsHelper#EXTRA_ALLOW_ANY_USER}.
Jeff Sharkey219ec912017-12-19 14:57:39 -0700663 * @throws SecurityException if the given userId does not belong to the
Sunny Shao7e866b62019-08-09 11:42:04 +0800664 * current user group.
Jeff Sharkey219ec912017-12-19 14:57:39 -0700665 */
666 public static int getUserIdFromBundle(Context context, Bundle bundle, boolean isInternal) {
Clara Bayarrife432e82015-10-12 12:07:02 +0100667 if (bundle == null) {
Benjamin Franz194300d2016-01-13 12:16:25 +0000668 return getCredentialOwnerUserId(context);
Clara Bayarrife432e82015-10-12 12:07:02 +0100669 }
Jeff Sharkey219ec912017-12-19 14:57:39 -0700670 final boolean allowAnyUser = isInternal
671 && bundle.getBoolean(ChooseLockSettingsHelper.EXTRA_ALLOW_ANY_USER, false);
Clara Bayarri6934a042015-10-14 11:07:35 +0100672 int userId = bundle.getInt(Intent.EXTRA_USER_ID, UserHandle.myUserId());
Adrian Roos5a9a3cd2017-03-30 18:02:25 -0700673 if (userId == LockPatternUtils.USER_FRP) {
Jeff Sharkey219ec912017-12-19 14:57:39 -0700674 return allowAnyUser ? userId : enforceSystemUser(context, userId);
Adrian Roos5a9a3cd2017-03-30 18:02:25 -0700675 } else {
Jeff Sharkey219ec912017-12-19 14:57:39 -0700676 return allowAnyUser ? userId : enforceSameOwner(context, userId);
Adrian Roos5a9a3cd2017-03-30 18:02:25 -0700677 }
678 }
679
680 /**
681 * Returns the given user id if the current user is the system user.
682 *
683 * @throws SecurityException if the current user is not the system user.
684 */
685 public static int enforceSystemUser(Context context, int userId) {
686 if (UserHandle.myUserId() == UserHandle.USER_SYSTEM) {
687 return userId;
688 }
689 throw new SecurityException("Given user id " + userId + " must only be used from "
690 + "USER_SYSTEM, but current user is " + UserHandle.myUserId());
Clara Bayarrife432e82015-10-12 12:07:02 +0100691 }
692
693 /**
694 * Returns the given user id if it belongs to the current user.
695 *
696 * @throws SecurityException if the given userId does not belong to the current user group.
697 */
Benjamin Franz194300d2016-01-13 12:16:25 +0000698 public static int enforceSameOwner(Context context, int userId) {
Ricky Wai72500162016-06-07 16:54:25 +0100699 final UserManager um = getUserManager(context);
700 final int[] profileIds = um.getProfileIdsWithDisabled(UserHandle.myUserId());
701 if (ArrayUtils.contains(profileIds, userId)) {
702 return userId;
Clara Bayarrife432e82015-10-12 12:07:02 +0100703 }
Ricky Wai72500162016-06-07 16:54:25 +0100704 throw new SecurityException("Given user id " + userId + " does not belong to user "
705 + UserHandle.myUserId());
Clara Bayarrife432e82015-10-12 12:07:02 +0100706 }
707
Benjamin Franz194300d2016-01-13 12:16:25 +0000708 /**
709 * Returns the effective credential owner of the calling user.
710 */
711 public static int getCredentialOwnerUserId(Context context) {
712 return getCredentialOwnerUserId(context, UserHandle.myUserId());
713 }
714
715 /**
716 * Returns the user id of the credential owner of the given user id.
717 */
718 public static int getCredentialOwnerUserId(Context context, int userId) {
719 UserManager um = getUserManager(context);
720 return um.getCredentialOwnerProfile(userId);
Andres Morales7bdffd82015-08-04 16:55:00 -0700721 }
Jason Monkdb4ed192015-12-11 16:48:31 -0500722
Jason Monkb37e2882016-01-11 14:27:20 -0500723 private static final StringBuilder sBuilder = new StringBuilder(50);
724 private static final java.util.Formatter sFormatter = new java.util.Formatter(
725 sBuilder, Locale.getDefault());
726
727 public static String formatDateRange(Context context, long start, long end) {
728 final int flags = FORMAT_SHOW_DATE | FORMAT_ABBREV_MONTH;
729
730 synchronized (sBuilder) {
731 sBuilder.setLength(0);
732 return DateUtils.formatDateRange(context, sFormatter, start, end, flags, null)
733 .toString();
734 }
735 }
Jason Monk91e2f892016-02-23 15:31:09 -0500736
Udam Saini679f7ad2016-03-25 10:47:00 -0700737 public static boolean isDeviceProvisioned(Context context) {
738 return Settings.Global.getInt(context.getContentResolver(),
739 Settings.Global.DEVICE_PROVISIONED, 0) != 0;
740 }
Ricky Wai616342b2016-04-13 10:40:22 +0100741
Bernard Chau88d523b2016-04-14 15:08:28 +0100742 public static boolean startQuietModeDialogIfNecessary(Context context, UserManager um,
Ricky Wai616342b2016-04-13 10:40:22 +0100743 int userId) {
744 if (um.isQuietModeEnabled(UserHandle.of(userId))) {
745 final Intent intent = UnlaunchableAppActivity.createInQuietModeDialogIntent(userId);
746 context.startActivity(intent);
747 return true;
748 }
749 return false;
750 }
Sudheer Shankac3eb16e2016-04-21 12:51:43 -0700751
Rubin Xu3231afe2016-08-24 10:15:07 +0100752 public static boolean unlockWorkProfileIfNecessary(Context context, int userId) {
753 try {
Sudheer Shankaacb1a612016-11-10 15:30:14 -0800754 if (!ActivityManager.getService().isUserRunning(userId,
Rubin Xu3231afe2016-08-24 10:15:07 +0100755 ActivityManager.FLAG_AND_LOCKED)) {
756 return false;
757 }
758 } catch (RemoteException e) {
759 return false;
760 }
761 if (!(new LockPatternUtils(context)).isSecure(userId)) {
762 return false;
763 }
Robin Leecccf3242017-02-10 15:32:49 +0000764 return confirmWorkProfileCredentials(context, userId);
765 }
766
Robin Leecccf3242017-02-10 15:32:49 +0000767 private static boolean confirmWorkProfileCredentials(Context context, int userId) {
Rubin Xu3231afe2016-08-24 10:15:07 +0100768 final KeyguardManager km = (KeyguardManager) context.getSystemService(
769 Context.KEYGUARD_SERVICE);
770 final Intent unlockIntent = km.createConfirmDeviceCredentialIntent(null, null, userId);
771 if (unlockIntent != null) {
772 context.startActivity(unlockIntent);
773 return true;
774 } else {
775 return false;
776 }
Rubin Xu3231afe2016-08-24 10:15:07 +0100777 }
778
Sudheer Shankac3eb16e2016-04-21 12:51:43 -0700779 public static CharSequence getApplicationLabel(Context context, String packageName) {
780 try {
781 final ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(
782 packageName,
783 PackageManager.MATCH_DISABLED_COMPONENTS
Sunny Shao7e866b62019-08-09 11:42:04 +0800784 | PackageManager.MATCH_ANY_USER);
Sudheer Shankac3eb16e2016-04-21 12:51:43 -0700785 return appInfo.loadLabel(context.getPackageManager());
786 } catch (PackageManager.NameNotFoundException e) {
787 Log.w(TAG, "Unable to find info for package: " + packageName);
788 }
789 return null;
790 }
Jason Monk75199542016-05-06 15:09:32 -0400791
Jeff Sharkey4a8136b2016-07-27 12:53:34 -0600792 public static boolean isPackageDirectBootAware(Context context, String packageName) {
793 try {
794 final ApplicationInfo ai = context.getPackageManager().getApplicationInfo(
795 packageName, 0);
796 return ai.isDirectBootAware() || ai.isPartiallyDirectBootAware();
797 } catch (NameNotFoundException ignored) {
798 }
799 return false;
800 }
Andre Lago3e398c82016-07-25 14:12:28 +0100801
802 /**
803 * Returns a context created from the given context for the given user, or null if it fails
804 */
805 public static Context createPackageContextAsUser(Context context, int userId) {
806 try {
807 return context.createPackageContextAsUser(
808 context.getPackageName(), 0 /* flags */, UserHandle.of(userId));
809 } catch (PackageManager.NameNotFoundException e) {
810 Log.e(TAG, "Failed to create user context", e);
811 }
812 return null;
813 }
Jeff Sharkeyab508072016-10-11 14:25:22 -0600814
815 public static FingerprintManager getFingerprintManagerOrNull(Context context) {
816 if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
Fan Zhangcf97f0b2018-01-05 11:18:44 -0800817 return (FingerprintManager) context.getSystemService(Context.FINGERPRINT_SERVICE);
Jeff Sharkeyab508072016-10-11 14:25:22 -0600818 } else {
819 return null;
820 }
821 }
Daniel Nishi31027da2017-01-19 14:03:57 -0800822
Kevin Chyn82792cc2017-07-20 00:15:44 -0700823 public static boolean hasFingerprintHardware(Context context) {
824 FingerprintManager fingerprintManager = getFingerprintManagerOrNull(context);
825 return fingerprintManager != null && fingerprintManager.isHardwareDetected();
826 }
827
Kevin Chyn4882e872018-06-25 17:58:31 -0700828 public static FaceManager getFaceManagerOrNull(Context context) {
829 if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_FACE)) {
830 return (FaceManager) context.getSystemService(Context.FACE_SERVICE);
831 } else {
832 return null;
833 }
834 }
835
836 public static boolean hasFaceHardware(Context context) {
837 FaceManager faceManager = getFaceManagerOrNull(context);
838 return faceManager != null && faceManager.isHardwareDetected();
839 }
840
Daniel Nishi31027da2017-01-19 14:03:57 -0800841 /**
842 * Launches an intent which may optionally have a user id defined.
843 * @param fragment Fragment to use to launch the activity.
Sunny Shao7e866b62019-08-09 11:42:04 +0800844 * @param intent Intent to launch.
Daniel Nishi31027da2017-01-19 14:03:57 -0800845 */
846 public static void launchIntent(Fragment fragment, Intent intent) {
847 try {
848 final int userId = intent.getIntExtra(Intent.EXTRA_USER_ID, -1);
849
850 if (userId == -1) {
851 fragment.startActivity(intent);
852 } else {
853 fragment.getActivity().startActivityAsUser(intent, new UserHandle(userId));
854 }
855 } catch (ActivityNotFoundException e) {
856 Log.w(TAG, "No activity found for " + intent);
857 }
858 }
859
Christine Franksc6890ab2017-06-23 14:28:21 -0700860 public static boolean isDemoUser(Context context) {
861 return UserManager.isDeviceInDemoMode(context) && getUserManager(context).isDemoUser();
862 }
863
Justin Klaassen30257272017-08-08 21:58:05 -0700864 public static ComponentName getDeviceOwnerComponent(Context context) {
865 final DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService(
866 Context.DEVICE_POLICY_SERVICE);
867 return dpm.getDeviceOwnerComponentOnAnyUser();
Christine Franks14782222017-01-23 16:44:02 -0800868 }
Daniel Nishidfed8a22017-01-19 16:32:41 -0800869
870 /**
871 * Returns if a given user is a profile of another user.
Sunny Shao7e866b62019-08-09 11:42:04 +0800872 * @param user The user whose profiles wibe checked.
Daniel Nishidfed8a22017-01-19 16:32:41 -0800873 * @param profile The (potential) profile.
874 * @return if the profile is actually a profile
875 */
876 public static boolean isProfileOf(UserInfo user, UserInfo profile) {
877 return user.id == profile.id ||
878 (user.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID
879 && user.profileGroupId == profile.profileGroupId);
880 }
Daniel Nishi9f60f422017-02-15 15:25:48 -0800881
882 /**
883 * Tries to initalize a volume with the given bundle. If it is a valid, private, and readable
884 * {@link VolumeInfo}, it is returned. If it is not valid, null is returned.
885 */
886 @Nullable
887 public static VolumeInfo maybeInitializeVolume(StorageManager sm, Bundle bundle) {
888 final String volumeId = bundle.getString(VolumeInfo.EXTRA_VOLUME_ID,
889 VolumeInfo.ID_PRIVATE_INTERNAL);
890 VolumeInfo volume = sm.findVolumeById(volumeId);
891 return isVolumeValid(volume) ? volume : null;
892 }
893
jackqdyuleiddba9662017-03-08 19:35:02 -0800894 /**
jackqdyulei00015fb2017-08-22 11:25:30 -0700895 * Return {@code true} if the supplied package is device owner or profile owner of at
896 * least one user.
Sunny Shao7e866b62019-08-09 11:42:04 +0800897 * @param userManager used to get profile owner app for each user
jackqdyulei00015fb2017-08-22 11:25:30 -0700898 * @param devicePolicyManager used to check whether it is device owner app
Sunny Shao7e866b62019-08-09 11:42:04 +0800899 * @param packageName package to check about
jackqdyulei00015fb2017-08-22 11:25:30 -0700900 */
901 public static boolean isProfileOrDeviceOwner(UserManager userManager,
Fan Zhangaab36de2018-03-30 16:58:28 -0700902 DevicePolicyManager devicePolicyManager, String packageName) {
jackqdyulei00015fb2017-08-22 11:25:30 -0700903 List<UserInfo> userInfos = userManager.getUsers();
904 if (devicePolicyManager.isDeviceOwnerAppOnAnyUser(packageName)) {
905 return true;
906 }
907 for (int i = 0, size = userInfos.size(); i < size; i++) {
908 ComponentName cn = devicePolicyManager.getProfileOwnerAsUser(userInfos.get(i).id);
909 if (cn != null && cn.getPackageName().equals(packageName)) {
910 return true;
911 }
912 }
913 return false;
914 }
915
916 /**
jackqdyuleiddba9662017-03-08 19:35:02 -0800917 * Return the resource id to represent the install status for an app
918 */
919 @StringRes
920 public static int getInstallationStatus(ApplicationInfo info) {
921 if ((info.flags & ApplicationInfo.FLAG_INSTALLED) == 0) {
922 return R.string.not_installed;
923 }
924 return info.enabled ? R.string.installed : R.string.disabled;
925 }
926
Daniel Nishi9f60f422017-02-15 15:25:48 -0800927 private static boolean isVolumeValid(VolumeInfo volume) {
928 return (volume != null) && (volume.getType() == VolumeInfo.TYPE_PRIVATE)
929 && volume.isMountedReadable();
930 }
jackqdyuleif4c1cef2017-03-31 12:57:10 -0700931
PMS2263a05602017-06-14 07:10:15 +0000932 public static void setEditTextCursorPosition(EditText editText) {
933 editText.setSelection(editText.getText().length());
934 }
Felipe Lemebd884502017-09-15 18:16:21 -0700935
936 /**
937 * Sets the preference icon with a drawable that is scaled down to to avoid crashing Settings if
938 * it's too big.
939 */
940 public static void setSafeIcon(Preference pref, Drawable icon) {
941 Drawable safeIcon = icon;
Phil Weaver5a3e02d2018-03-08 17:38:46 -0800942 if ((icon != null) && !(icon instanceof VectorDrawable)) {
Felipe Lemebd884502017-09-15 18:16:21 -0700943 safeIcon = getSafeDrawable(icon, 500, 500);
944 }
945 pref.setIcon(safeIcon);
946 }
947
948 /**
949 * Gets a drawable with a limited size to avoid crashing Settings if it's too big.
950 *
Sunny Shao7e866b62019-08-09 11:42:04 +0800951 * @param original original drawable, typically an app icon.
952 * @param maxWidth maximum width, in pixels.
Felipe Lemebd884502017-09-15 18:16:21 -0700953 * @param maxHeight maximum height, in pixels.
954 */
955 public static Drawable getSafeDrawable(Drawable original, int maxWidth, int maxHeight) {
956 final int actualWidth = original.getMinimumWidth();
957 final int actualHeight = original.getMinimumHeight();
958
959 if (actualWidth <= maxWidth && actualHeight <= maxHeight) {
960 return original;
961 }
962
963 float scaleWidth = ((float) maxWidth) / actualWidth;
964 float scaleHeight = ((float) maxHeight) / actualHeight;
965 float scale = Math.min(scaleWidth, scaleHeight);
966 final int width = (int) (actualWidth * scale);
967 final int height = (int) (actualHeight * scale);
968
969 final Bitmap bitmap;
970 if (original instanceof BitmapDrawable) {
971 bitmap = Bitmap.createScaledBitmap(((BitmapDrawable) original).getBitmap(), width,
972 height, false);
973 } else {
Jason Chiuc78c54a2019-02-13 16:07:57 +0800974 bitmap = createBitmap(original, width, height);
Felipe Lemebd884502017-09-15 18:16:21 -0700975 }
976 return new BitmapDrawable(null, bitmap);
977 }
jackqdyuleifde637f2018-01-02 14:51:01 -0800978
979 /**
Jason Chiuc78c54a2019-02-13 16:07:57 +0800980 * Create an Icon pointing to a drawable.
Jason Chiu1217bbe2019-01-24 16:32:31 +0800981 */
Jason Chiuc78c54a2019-02-13 16:07:57 +0800982 public static IconCompat createIconWithDrawable(Drawable drawable) {
983 Bitmap bitmap;
Jason Chiu1217bbe2019-01-24 16:32:31 +0800984 if (drawable instanceof BitmapDrawable) {
Sunny Shao7e866b62019-08-09 11:42:04 +0800985 bitmap = ((BitmapDrawable)drawable).getBitmap();
Jason Chiuc78c54a2019-02-13 16:07:57 +0800986 } else {
987 final int width = drawable.getIntrinsicWidth();
988 final int height = drawable.getIntrinsicHeight();
989 bitmap = createBitmap(drawable,
990 width > 0 ? width : 1,
991 height > 0 ? height : 1);
Jason Chiu1217bbe2019-01-24 16:32:31 +0800992 }
Jason Chiuc78c54a2019-02-13 16:07:57 +0800993 return IconCompat.createWithBitmap(bitmap);
994 }
Jason Chiu1217bbe2019-01-24 16:32:31 +0800995
clownshen24827d32019-03-29 20:22:02 +0800996 /**
997 * Creates a drawable with specified width and height.
998 */
999 public static Bitmap createBitmap(Drawable drawable, int width, int height) {
Jason Chiuc78c54a2019-02-13 16:07:57 +08001000 final Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
Jason Chiu1217bbe2019-01-24 16:32:31 +08001001 final Canvas canvas = new Canvas(bitmap);
1002 drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
1003 drawable.draw(canvas);
1004 return bitmap;
1005 }
1006
1007 /**
jackqdyuleifde637f2018-01-02 14:51:01 -08001008 * Get the {@link Drawable} that represents the app icon
1009 */
1010 public static Drawable getBadgedIcon(IconDrawableFactory iconDrawableFactory,
1011 PackageManager packageManager, String packageName, int userId) {
1012 try {
Tony Mak4e292812018-03-19 15:37:21 +00001013 final ApplicationInfo appInfo = packageManager.getApplicationInfoAsUser(
1014 packageName, PackageManager.GET_META_DATA, userId);
jackqdyuleifde637f2018-01-02 14:51:01 -08001015 return iconDrawableFactory.getBadgedIcon(appInfo, userId);
1016 } catch (PackageManager.NameNotFoundException e) {
1017 return packageManager.getDefaultActivityIcon();
1018 }
1019 }
Raff Tsai2928cd42018-11-05 16:10:19 +08001020
1021 /** Returns true if the current package is installed & enabled. */
1022 public static boolean isPackageEnabled(Context context, String packageName) {
1023 try {
1024 return context.getPackageManager().getApplicationInfo(packageName, 0).enabled;
1025 } catch (Exception e) {
1026 Log.e(TAG, "Error while retrieving application info for package " + packageName, e);
1027 }
1028 return false;
1029 }
markchien1dd1d792019-01-11 16:18:20 +08001030
1031 /** Get {@link Resources} by subscription id if subscription id is valid. */
1032 public static Resources getResourcesForSubId(Context context, int subId) {
1033 if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
1034 return SubscriptionManager.getResourcesForSubId(context, subId);
1035 } else {
1036 return context.getResources();
1037 }
1038 }
Ng Zhi Anb97bdc32019-02-01 12:39:31 -08001039
1040 /**
1041 * Returns true if SYSTEM_ALERT_WINDOW permission is available.
1042 * Starting from Q, SYSTEM_ALERT_WINDOW is disabled on low ram phones.
1043 */
1044 public static boolean isSystemAlertWindowEnabled(Context context) {
1045 // SYSTEM_ALERT_WINDOW is disabled on on low ram devices starting from Q
1046 ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
1047 return !(am.isLowRamDevice() && (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q));
1048 }
tmfangaed8f362019-03-18 16:56:09 +08001049
1050 /**
1051 * Adds a shadow appear/disappear animation to action bar scroll.
1052 *
1053 * <p/>
1054 * This method must be called after {@link Fragment#onCreate(Bundle)}.
1055 */
1056 public static void setActionBarShadowAnimation(Activity activity, Lifecycle lifecycle,
1057 View scrollView) {
1058 if (activity == null) {
1059 Log.w(TAG, "No activity, cannot style actionbar.");
1060 return;
1061 }
1062 final ActionBar actionBar = activity.getActionBar();
1063 if (actionBar == null) {
1064 Log.w(TAG, "No actionbar, cannot style actionbar.");
1065 return;
1066 }
1067 actionBar.setElevation(0);
1068
1069 if (lifecycle != null && scrollView != null) {
1070 ActionBarShadowController.attachToView(activity, lifecycle, scrollView);
1071 }
1072 }
Raff Tsaiafd494d2019-10-16 15:25:21 +08001073
1074 /**
1075 * Return correct target fragment based on argument
1076 *
1077 * @param activity the activity target fragment will be launched.
1078 * @param fragmentName initial target fragment name.
1079 * @param args fragment launch arguments.
1080 */
1081 public static Fragment getTargetFragment(Activity activity, String fragmentName, Bundle args) {
1082 Fragment f = null;
1083 final boolean isWorkOnly = args == null ? false : args.getBoolean(EXTRA_WORK_ONLY);
1084 final boolean isPersonalOnly = args == null ? false : args.getBoolean(EXTRA_PERSONAL_ONLY);
1085 if (FeatureFlagUtils.isEnabled(activity, FeatureFlags.PERSONAL_WORK_PROFILE)
1086 && UserManager.get(activity).getUserProfiles().size() > 1
1087 && ProfileFragmentBridge.FRAGMENT_MAP.get(fragmentName) != null
1088 && !isWorkOnly && !isPersonalOnly) {
1089 f = Fragment.instantiate(activity, ProfileFragmentBridge.FRAGMENT_MAP.get(fragmentName),
1090 args);
1091 } else {
1092 f = Fragment.instantiate(activity, fragmentName, args);
1093 }
1094 return f;
1095 }
Jeff Sharkey4a8136b2016-07-27 12:53:34 -06001096}