blob: c4b1400f5c625c3293c593aed80c70f53626bf0d [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
Alexandra Gherghina7d748c02014-06-27 12:33:42 +010024import android.annotation.Nullable;
tmfangaed8f362019-03-18 16:56:09 +080025import android.app.ActionBar;
26import android.app.Activity;
Amith Yamasaniae697552011-09-27 11:33:17 -070027import android.app.ActivityManager;
Sudheer Shankabc956302015-04-09 12:19:53 +010028import android.app.AppGlobals;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010029import android.app.IActivityManager;
Rubin Xu3231afe2016-08-24 10:15:07 +010030import android.app.KeyguardManager;
Sudheer Shankabc956302015-04-09 12:19:53 +010031import android.app.admin.DevicePolicyManager;
Daniel Nishi31027da2017-01-19 14:03:57 -080032import android.content.ActivityNotFoundException;
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -080033import android.content.ComponentName;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070034import android.content.ContentResolver;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080035import android.content.Context;
36import android.content.Intent;
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -080037import android.content.IntentFilter;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080038import android.content.pm.ApplicationInfo;
Sudheer Shankabc956302015-04-09 12:19:53 +010039import android.content.pm.IPackageManager;
Christopher Tatea08a2252015-07-01 16:52:43 -070040import android.content.pm.IntentFilterVerificationInfo;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080041import android.content.pm.PackageManager;
Jason Monk75199542016-05-06 15:09:32 -040042import android.content.pm.PackageManager.NameNotFoundException;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070043import android.content.pm.ResolveInfo;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070044import android.content.pm.UserInfo;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020045import android.content.res.Resources;
Jason Monkb5aa73f2015-03-31 12:59:33 -040046import android.content.res.TypedArray;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070047import android.database.Cursor;
Amith Yamasanif34a85d2012-09-17 18:31:45 -070048import android.graphics.Bitmap;
Felipe Lemebd884502017-09-15 18:16:21 -070049import android.graphics.Canvas;
50import android.graphics.drawable.BitmapDrawable;
51import android.graphics.drawable.Drawable;
Phil Weaver5a3e02d2018-03-08 17:38:46 -080052import android.graphics.drawable.VectorDrawable;
Kevin Chyn4882e872018-06-25 17:58:31 -070053import android.hardware.face.FaceManager;
Jeff Sharkeyab508072016-10-11 14:25:22 -060054import android.hardware.fingerprint.FingerprintManager;
Amith Yamasanic06d4c42011-02-25 14:35:20 -080055import android.net.ConnectivityManager;
56import android.net.LinkProperties;
Jaewoong Jungc260e6d2016-10-13 14:21:52 -070057import android.net.Network;
Jaewoong Jungc260e6d2016-10-13 14:21:52 -070058import android.net.wifi.WifiManager;
Amith Yamasania4379d62011-07-22 10:34:58 -070059import android.os.BatteryManager;
Ng Zhi Anb97bdc32019-02-01 12:39:31 -080060import android.os.Build;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020061import android.os.Bundle;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010062import android.os.IBinder;
Jason Monkb45e27b2015-05-20 13:35:43 -040063import android.os.INetworkManagementService;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010064import android.os.RemoteException;
Jason Monkb45e27b2015-05-20 13:35:43 -040065import android.os.ServiceManager;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070066import android.os.UserHandle;
67import android.os.UserManager;
Fabrice Di Megliodff3faa2015-02-27 11:14:11 -080068import android.os.storage.StorageManager;
Daniel Nishi9f60f422017-02-15 15:25:48 -080069import android.os.storage.VolumeInfo;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070070import android.preference.PreferenceFrameLayout;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070071import android.provider.ContactsContract.CommonDataKinds;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070072import android.provider.ContactsContract.Contacts;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070073import android.provider.ContactsContract.Data;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070074import android.provider.ContactsContract.Profile;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070075import android.provider.ContactsContract.RawContacts;
Udam Saini679f7ad2016-03-25 10:47:00 -070076import android.provider.Settings;
markchien1dd1d792019-01-11 16:18:20 +080077import android.telephony.SubscriptionManager;
Amith Yamasani60133dd2010-09-11 14:17:31 -070078import android.telephony.TelephonyManager;
Julia Reynoldsce25af42015-07-08 16:56:31 -040079import android.text.Spannable;
80import android.text.SpannableString;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020081import android.text.TextUtils;
Jason Monkb37e2882016-01-11 14:27:20 -050082import android.text.format.DateUtils;
Julia Reynoldsce25af42015-07-08 16:56:31 -040083import android.text.style.TtsSpan;
Christopher Tatea08a2252015-07-01 16:52:43 -070084import android.util.ArraySet;
jackqdyuleifde637f2018-01-02 14:51:01 -080085import android.util.IconDrawableFactory;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010086import android.util.Log;
Zoltan Szatmary-Ban3af2e4c2014-12-19 17:17:23 +000087import android.view.LayoutInflater;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070088import android.view.View;
89import android.view.ViewGroup;
PMS2263a05602017-06-14 07:10:15 +000090import android.widget.EditText;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070091import android.widget.ListView;
92import android.widget.TabWidget;
Fan Zhangcc335d92016-09-29 14:37:14 -070093
Fan Zhang23f8d592018-08-28 15:11:40 -070094import androidx.annotation.StringRes;
Jason Chiuc78c54a2019-02-13 16:07:57 +080095import androidx.core.graphics.drawable.IconCompat;
Fan Zhang23f8d592018-08-28 15:11:40 -070096import androidx.fragment.app.Fragment;
tmfangaed8f362019-03-18 16:56:09 +080097import androidx.lifecycle.Lifecycle;
Fan Zhang23f8d592018-08-28 15:11:40 -070098import androidx.preference.Preference;
99import androidx.preference.PreferenceGroup;
100
Ricky Wai616342b2016-04-13 10:40:22 +0100101import com.android.internal.app.UnlaunchableAppActivity;
Ricky Wai72500162016-06-07 16:54:25 +0100102import com.android.internal.util.ArrayUtils;
Rubin Xu3231afe2016-08-24 10:15:07 +0100103import com.android.internal.widget.LockPatternUtils;
Antony Sargent627f14b2019-03-04 16:00:59 -0800104import com.android.settings.core.FeatureFlags;
105import com.android.settings.development.featureflags.FeatureFlagPersistent;
Jeff Sharkey219ec912017-12-19 14:57:39 -0700106import com.android.settings.password.ChooseLockSettingsHelper;
tmfangaed8f362019-03-18 16:56:09 +0800107import com.android.settingslib.widget.ActionBarShadowController;
Daisuke Miyakawaa2633d02010-09-15 20:09:12 -0700108
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800109import java.net.InetAddress;
110import java.util.Iterator;
Daisuke Miyakawaa2633d02010-09-15 20:09:12 -0700111import java.util.List;
Jean Chalard71ad1f42011-05-12 15:06:16 +0900112import java.util.Locale;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800113
Jason Monk27985e12016-01-08 14:13:05 -0500114public final class Utils extends com.android.settingslib.Utils {
115
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100116 private static final String TAG = "Settings";
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100117
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800118 /**
119 * Set the preference's title to the matching activity's label.
120 */
121 public static final int UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY = 1;
122
Fan Zhangc3fd2892019-01-29 16:00:19 -0800123 public static final String SETTINGS_PACKAGE_NAME = "com.android.settings";
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100124
Jason Monkbeb171d2015-05-21 15:24:37 -0400125 public static final String OS_PKG = "os";
126
Anders Hammar1b2dd9032010-04-08 10:03:50 +0200127 /**
Svet Ganov864765f2019-04-05 19:00:05 -0700128 * Whether to disable the new device identifier access restrictions.
129 */
130 public static final String PROPERTY_DEVICE_IDENTIFIER_ACCESS_RESTRICTIONS_DISABLED =
131 "device_identifier_access_restrictions_disabled";
132
133 /**
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800134 * Finds a matching activity for a preference's intent. If a matching
135 * activity is not found, it will remove the preference.
Ying Wanga7188322010-01-04 18:45:10 -0800136 *
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800137 * @param context The context.
138 * @param parentPreferenceGroup The preference group that contains the
139 * preference whose intent is being resolved.
140 * @param preferenceKey The key of the preference whose intent is being
141 * resolved.
142 * @param flags 0 or one or more of
143 * {@link #UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY}
144 * .
145 * @return Whether an activity was found. If false, the preference was
146 * removed.
147 */
148 public static boolean updatePreferenceToSpecificActivityOrRemove(Context context,
149 PreferenceGroup parentPreferenceGroup, String preferenceKey, int flags) {
Ying Wanga7188322010-01-04 18:45:10 -0800150
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800151 Preference preference = parentPreferenceGroup.findPreference(preferenceKey);
152 if (preference == null) {
153 return false;
154 }
Ying Wanga7188322010-01-04 18:45:10 -0800155
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800156 Intent intent = preference.getIntent();
157 if (intent != null) {
158 // Find the activity that is in the system image
159 PackageManager pm = context.getPackageManager();
160 List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
161 int listSize = list.size();
162 for (int i = 0; i < listSize; i++) {
163 ResolveInfo resolveInfo = list.get(i);
164 if ((resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
165 != 0) {
Ying Wanga7188322010-01-04 18:45:10 -0800166
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800167 // Replace the intent with this specific activity
168 preference.setIntent(new Intent().setClassName(
169 resolveInfo.activityInfo.packageName,
170 resolveInfo.activityInfo.name));
171
172 if ((flags & UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY) != 0) {
173 // Set the preference title to the activity's label
174 preference.setTitle(resolveInfo.loadLabel(pm));
175 }
Ying Wanga7188322010-01-04 18:45:10 -0800176
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800177 return true;
178 }
179 }
180 }
181
182 // Did not find a matching activity, so remove the preference
183 parentPreferenceGroup.removePreference(preference);
Ying Wanga7188322010-01-04 18:45:10 -0800184
Shuhrat Dehkanov7dc567a2012-04-23 01:59:56 +0900185 return false;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800186 }
Ying Wanga7188322010-01-04 18:45:10 -0800187
Anders Hammar1b2dd9032010-04-08 10:03:50 +0200188 /**
Benjamin Franz194300d2016-01-13 12:16:25 +0000189 * Returns the UserManager for a given context
190 *
191 * @throws IllegalStateException if no UserManager could be retrieved.
192 */
193 public static UserManager getUserManager(Context context) {
194 UserManager um = UserManager.get(context);
195 if (um == null) {
196 throw new IllegalStateException("Unable to load UserManager");
197 }
198 return um;
199 }
200
201 /**
Ying Wanga7188322010-01-04 18:45:10 -0800202 * Returns true if Monkey is running.
203 */
204 public static boolean isMonkeyRunning() {
Amith Yamasaniae697552011-09-27 11:33:17 -0700205 return ActivityManager.isUserAMonkey();
Ying Wanga7188322010-01-04 18:45:10 -0800206 }
Amith Yamasani60133dd2010-09-11 14:17:31 -0700207
208 /**
209 * Returns whether the device is voice-capable (meaning, it is also a phone).
210 */
211 public static boolean isVoiceCapable(Context context) {
212 TelephonyManager telephony =
213 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
214 return telephony != null && telephony.isVoiceCapable();
215 }
Amith Yamasani0f85c482011-02-23 17:19:11 -0800216
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800217 /**
218 * Returns the WIFI IP Addresses, if any, taking into account IPv4 and IPv6 style addresses.
219 * @param context the application context
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900220 * @return the formatted and newline-separated IP addresses, or null if none.
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800221 */
222 public static String getWifiIpAddresses(Context context) {
Jaewoong Jungc260e6d2016-10-13 14:21:52 -0700223 WifiManager wifiManager = context.getSystemService(WifiManager.class);
224 Network currentNetwork = wifiManager.getCurrentNetwork();
225 if (currentNetwork != null) {
226 ConnectivityManager cm = (ConnectivityManager)
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800227 context.getSystemService(Context.CONNECTIVITY_SERVICE);
Jaewoong Jungc260e6d2016-10-13 14:21:52 -0700228 LinkProperties prop = cm.getLinkProperties(currentNetwork);
229 return formatIpAddresses(prop);
230 }
231 return null;
Amith Yamasani6822b742011-10-17 16:41:00 -0700232 }
233
Amith Yamasani6822b742011-10-17 16:41:00 -0700234 private static String formatIpAddresses(LinkProperties prop) {
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800235 if (prop == null) return null;
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900236 Iterator<InetAddress> iter = prop.getAllAddresses().iterator();
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800237 // If there are no entries, return null
238 if (!iter.hasNext()) return null;
239 // Concatenate all available addresses, comma separated
240 String addresses = "";
241 while (iter.hasNext()) {
242 addresses += iter.next().getHostAddress();
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900243 if (iter.hasNext()) addresses += "\n";
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800244 }
245 return addresses;
246 }
Jean Chalard71ad1f42011-05-12 15:06:16 +0900247
248 public static Locale createLocaleFromString(String localeStr) {
249 // TODO: is there a better way to actually construct a locale that will match?
250 // The main problem is, on top of Java specs, locale.toString() and
251 // new Locale(locale.toString()).toString() do not return equal() strings in
252 // many cases, because the constructor takes the only string as the language
253 // code. So : new Locale("en", "US").toString() => "en_US"
254 // And : new Locale("en_US").toString() => "en_us"
255 if (null == localeStr)
256 return Locale.getDefault();
257 String[] brokenDownLocale = localeStr.split("_", 3);
258 // split may not return a 0-length array.
259 if (1 == brokenDownLocale.length) {
260 return new Locale(brokenDownLocale[0]);
261 } else if (2 == brokenDownLocale.length) {
262 return new Locale(brokenDownLocale[0], brokenDownLocale[1]);
263 } else {
264 return new Locale(brokenDownLocale[0], brokenDownLocale[1], brokenDownLocale[2]);
265 }
266 }
Amith Yamasania4379d62011-07-22 10:34:58 -0700267
Jaewan Kima3fe77b2013-06-04 21:17:40 +0900268 public static boolean isBatteryPresent(Intent batteryChangedIntent) {
269 return batteryChangedIntent.getBooleanExtra(BatteryManager.EXTRA_PRESENT, true);
270 }
271
Amith Yamasania4379d62011-07-22 10:34:58 -0700272 public static String getBatteryPercentage(Intent batteryChangedIntent) {
Elliott Hughes7253df32014-09-02 17:10:14 -0700273 return formatPercentage(getBatteryLevel(batteryChangedIntent));
Dianne Hackborn525f2bd2014-04-29 11:24:06 -0700274 }
275
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700276 /**
277 * Prepare a custom preferences layout, moving padding to {@link ListView}
278 * when outside scrollbars are requested. Usually used to display
279 * {@link ListView} and {@link TabWidget} with correct padding.
280 */
Jeff Sharkey5d706792011-09-08 18:57:17 -0700281 public static void prepareCustomPreferencesList(
Jeff Sharkey97d07fa2012-11-30 12:36:53 -0800282 ViewGroup parent, View child, View list, boolean ignoreSidePadding) {
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700283 final boolean movePadding = list.getScrollBarStyle() == View.SCROLLBARS_OUTSIDE_OVERLAY;
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700284 if (movePadding) {
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700285 final Resources res = list.getResources();
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700286 final int paddingBottom = res.getDimensionPixelSize(
287 com.android.internal.R.dimen.preference_fragment_padding_bottom);
Jeff Sharkey5d706792011-09-08 18:57:17 -0700288
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700289 if (parent instanceof PreferenceFrameLayout) {
290 ((PreferenceFrameLayout.LayoutParams) child.getLayoutParams()).removeBorders = true;
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700291 }
Doris Lingc5a1b4f2019-02-20 16:33:24 -0800292 list.setPaddingRelative(0 /* start */, 0 /* top */, 0 /* end */, paddingBottom);
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700293 }
294 }
Jeff Sharkeya83a24f2011-09-16 01:52:39 -0700295
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700296 public static void forceCustomPadding(View view, boolean additive) {
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700297 final Resources res = view.getResources();
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700298
Doris Lingc5a1b4f2019-02-20 16:33:24 -0800299 final int paddingStart = additive ? view.getPaddingStart() : 0;
300 final int paddingEnd = additive ? view.getPaddingEnd() : 0;
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700301 final int paddingBottom = res.getDimensionPixelSize(
302 com.android.internal.R.dimen.preference_fragment_padding_bottom);
303
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700304 view.setPaddingRelative(paddingStart, 0, paddingEnd, paddingBottom);
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700305 }
306
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700307 public static String getMeProfileName(Context context, boolean full) {
308 if (full) {
309 return getProfileDisplayName(context);
310 } else {
311 return getShorterNameIfPossible(context);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700312 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700313 }
314
315 private static String getShorterNameIfPossible(Context context) {
316 final String given = getLocalProfileGivenName(context);
317 return !TextUtils.isEmpty(given) ? given : getProfileDisplayName(context);
318 }
319
320 private static String getLocalProfileGivenName(Context context) {
321 final ContentResolver cr = context.getContentResolver();
322
323 // Find the raw contact ID for the local ME profile raw contact.
324 final long localRowProfileId;
325 final Cursor localRawProfile = cr.query(
326 Profile.CONTENT_RAW_CONTACTS_URI,
327 new String[] {RawContacts._ID},
328 RawContacts.ACCOUNT_TYPE + " IS NULL AND " +
329 RawContacts.ACCOUNT_NAME + " IS NULL",
330 null, null);
331 if (localRawProfile == null) return null;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700332
333 try {
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700334 if (!localRawProfile.moveToFirst()) {
335 return null;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700336 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700337 localRowProfileId = localRawProfile.getLong(0);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700338 } finally {
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700339 localRawProfile.close();
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700340 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700341
342 // Find the structured name for the raw contact.
343 final Cursor structuredName = cr.query(
344 Profile.CONTENT_URI.buildUpon().appendPath(Contacts.Data.CONTENT_DIRECTORY).build(),
345 new String[] {CommonDataKinds.StructuredName.GIVEN_NAME,
346 CommonDataKinds.StructuredName.FAMILY_NAME},
347 Data.RAW_CONTACT_ID + "=" + localRowProfileId,
348 null, null);
349 if (structuredName == null) return null;
350
351 try {
352 if (!structuredName.moveToFirst()) {
353 return null;
354 }
355 String partialName = structuredName.getString(0);
356 if (TextUtils.isEmpty(partialName)) {
357 partialName = structuredName.getString(1);
358 }
359 return partialName;
360 } finally {
361 structuredName.close();
362 }
363 }
364
365 private static final String getProfileDisplayName(Context context) {
366 final ContentResolver cr = context.getContentResolver();
367 final Cursor profile = cr.query(Profile.CONTENT_URI,
368 new String[] {Profile.DISPLAY_NAME}, null, null, null);
369 if (profile == null) return null;
370
371 try {
372 if (!profile.moveToFirst()) {
373 return null;
374 }
375 return profile.getString(0);
376 } finally {
377 profile.close();
378 }
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700379 }
Amith Yamasani9627a8e2012-09-23 12:54:14 -0700380
Amith Yamasani9627a8e2012-09-23 12:54:14 -0700381 public static boolean hasMultipleUsers(Context context) {
382 return ((UserManager) context.getSystemService(Context.USER_SERVICE))
383 .getUsers().size() > 1;
384 }
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700385
386 /**
Esteban Talavera9b86e9c2017-05-30 16:48:08 +0100387 * Returns the managed profile of the current user or {@code null} if none is found or a profile
388 * exists but it is disabled.
Alexandra Gherghina3939cd72014-06-04 10:02:55 +0100389 */
390 public static UserHandle getManagedProfile(UserManager userManager) {
391 List<UserHandle> userProfiles = userManager.getUserProfiles();
Aarthi Balachanderd0f83592018-07-10 17:04:53 -0700392 for (UserHandle profile : userProfiles) {
Alexandra Gherghina3939cd72014-06-04 10:02:55 +0100393 if (profile.getIdentifier() == userManager.getUserHandle()) {
394 continue;
395 }
396 final UserInfo userInfo = userManager.getUserInfo(profile.getIdentifier());
397 if (userInfo.isManagedProfile()) {
398 return profile;
399 }
400 }
401 return null;
402 }
403
404 /**
Esteban Talavera9b86e9c2017-05-30 16:48:08 +0100405 * Returns the managed profile of the current user or {@code null} if none is found. Unlike
406 * {@link #getManagedProfile} this method returns enabled and disabled managed profiles.
407 */
408 public static UserHandle getManagedProfileWithDisabled(UserManager userManager) {
409 // TODO: Call getManagedProfileId from here once Robolectric supports
410 // API level 24 and UserManager.getProfileIdsWithDisabled can be Mocked (to avoid having
411 // yet another implementation that loops over user profiles in this method). In the meantime
412 // we need to use UserManager.getProfiles that is available on API 23 (the one currently
413 // used for Settings Robolectric tests).
414 final int myUserId = UserHandle.myUserId();
415 List<UserInfo> profiles = userManager.getProfiles(myUserId);
416 final int count = profiles.size();
417 for (int i = 0; i < count; i++) {
418 final UserInfo profile = profiles.get(i);
419 if (profile.isManagedProfile()
420 && profile.getUserHandle().getIdentifier() != myUserId) {
421 return profile.getUserHandle();
422 }
423 }
424 return null;
425 }
426
427 /**
Clara Bayarri462cce12016-02-18 12:09:21 +0000428 * Retrieves the id for the given user's managed profile.
429 *
430 * @return the managed profile id or UserHandle.USER_NULL if there is none.
431 */
432 public static int getManagedProfileId(UserManager um, int parentUserId) {
Fyodor Kupolov4a4af5a2016-04-07 16:46:18 -0700433 int[] profileIds = um.getProfileIdsWithDisabled(parentUserId);
434 for (int profileId : profileIds) {
435 if (profileId != parentUserId) {
436 return profileId;
Clara Bayarri462cce12016-02-18 12:09:21 +0000437 }
438 }
439 return UserHandle.USER_NULL;
440 }
441
442 /**
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100443 * Returns the target user for a Settings activity.
Tony Mak8f41b9b2016-11-23 11:36:18 +0000444 * <p>
445 * User would be retrieved in this order:
446 * <ul>
447 * <li> If this activity is launched from other user, return that user id.
448 * <li> If this is launched from the Settings app in same user, return the user contained as an
449 * extra in the arguments or intent extras.
450 * <li> Otherwise, return UserHandle.myUserId().
451 * </ul>
452 * <p>
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100453 * Note: This is secure in the sense that it only returns a target user different to the current
454 * one if the app launching this activity is the Settings app itself, running in the same user
455 * 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 +0100456 */
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100457 public static UserHandle getSecureTargetUser(IBinder activityToken,
Tony Mak8f41b9b2016-11-23 11:36:18 +0000458 UserManager um, @Nullable Bundle arguments, @Nullable Bundle intentExtras) {
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100459 UserHandle currentUser = new UserHandle(UserHandle.myUserId());
Sudheer Shankaacb1a612016-11-10 15:30:14 -0800460 IActivityManager am = ActivityManager.getService();
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100461 try {
462 String launchedFromPackage = am.getLaunchedFromPackage(activityToken);
463 boolean launchedFromSettingsApp = SETTINGS_PACKAGE_NAME.equals(launchedFromPackage);
464
465 UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId(
466 am.getLaunchedFromUid(activityToken)));
467 if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) {
468 // Check it's secure
469 if (isProfileOf(um, launchedFromUser)) {
470 return launchedFromUser;
471 }
472 }
Tony Mak8f41b9b2016-11-23 11:36:18 +0000473 UserHandle extrasUser = getUserHandleFromBundle(intentExtras);
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100474 if (extrasUser != null && !extrasUser.equals(currentUser)) {
475 // Check it's secure
476 if (launchedFromSettingsApp && isProfileOf(um, extrasUser)) {
477 return extrasUser;
478 }
479 }
Tony Mak8f41b9b2016-11-23 11:36:18 +0000480 UserHandle argumentsUser = getUserHandleFromBundle(arguments);
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100481 if (argumentsUser != null && !argumentsUser.equals(currentUser)) {
482 // Check it's secure
483 if (launchedFromSettingsApp && isProfileOf(um, argumentsUser)) {
484 return argumentsUser;
485 }
486 }
487 } catch (RemoteException e) {
488 // Should not happen
489 Log.v(TAG, "Could not talk to activity manager.", e);
490 }
491 return currentUser;
Tony Mak8f41b9b2016-11-23 11:36:18 +0000492 }
493
494 /**
495 * Lookup both {@link Intent#EXTRA_USER} and {@link Intent#EXTRA_USER_ID} in the bundle
496 * and return the {@link UserHandle} object. Return {@code null} if nothing is found.
497 */
498 private static @Nullable UserHandle getUserHandleFromBundle(Bundle bundle) {
499 if (bundle == null) {
500 return null;
501 }
502 final UserHandle user = bundle.getParcelable(EXTRA_USER);
503 if (user != null) {
504 return user;
505 }
506 final int userId = bundle.getInt(EXTRA_USER_ID, -1);
507 if (userId != -1) {
508 return UserHandle.of(userId);
509 }
510 return null;
511 }
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100512
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100513 /**
514 * Returns true if the user provided is in the same profiles group as the current user.
515 */
516 private static boolean isProfileOf(UserManager um, UserHandle otherUser) {
517 if (um == null || otherUser == null) return false;
518 return (UserHandle.myUserId() == otherUser.getIdentifier())
519 || um.getUserProfiles().contains(otherUser);
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100520 }
Amith Yamasani51c6dac2014-07-02 00:06:37 +0530521
Alexandra Gherghina95b86a52014-07-24 19:13:25 +0100522 /**
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700523 * Return whether or not the user should have a SIM Cards option in Settings.
524 * TODO: Change back to returning true if count is greater than one after testing.
525 * TODO: See bug 16533525.
526 */
527 public static boolean showSimCardTile(Context context) {
Antony Sargent627f14b2019-03-04 16:00:59 -0800528 if (FeatureFlagPersistent.isEnabled(context, FeatureFlags.NETWORK_INTERNET_V2)) {
529 return false;
530 }
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700531 final TelephonyManager tm =
532 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
533
PauloftheWestdbd03822014-12-04 11:56:35 -0800534 return tm.getSimCount() > 1;
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700535 }
Dan Sandlerb58b5122014-09-02 18:31:49 +0200536
537 /**
Amith Yamasani45f86232014-11-19 17:12:46 -0800538 * Queries for the UserInfo of a user. Returns null if the user doesn't exist (was removed).
539 * @param userManager Instance of UserManager
540 * @param checkUser The user to check the existence of.
541 * @return UserInfo of the user or null for non-existent user.
542 */
543 public static UserInfo getExistingUser(UserManager userManager, UserHandle checkUser) {
544 final List<UserInfo> users = userManager.getUsers(true /* excludeDying */);
545 final int checkUserId = checkUser.getIdentifier();
546 for (UserInfo user : users) {
547 if (user.id == checkUserId) {
548 return user;
549 }
550 }
551 return null;
552 }
553
Zoltan Szatmary-Ban3af2e4c2014-12-19 17:17:23 +0000554 public static View inflateCategoryHeader(LayoutInflater inflater, ViewGroup parent) {
555 final TypedArray a = inflater.getContext().obtainStyledAttributes(null,
556 com.android.internal.R.styleable.Preference,
557 com.android.internal.R.attr.preferenceCategoryStyle, 0);
558 final int resId = a.getResourceId(com.android.internal.R.styleable.Preference_layout,
559 0);
560 a.recycle();
561 return inflater.inflate(resId, parent, false);
562 }
563
Christopher Tatea08a2252015-07-01 16:52:43 -0700564 public static ArraySet<String> getHandledDomains(PackageManager pm, String packageName) {
565 List<IntentFilterVerificationInfo> iviList = pm.getIntentFilterVerifications(packageName);
566 List<IntentFilter> filters = pm.getAllIntentFilters(packageName);
567
568 ArraySet<String> result = new ArraySet<>();
Fan Zhang4e540db2017-11-08 13:06:38 -0800569 if (iviList != null && iviList.size() > 0) {
Christopher Tatea08a2252015-07-01 16:52:43 -0700570 for (IntentFilterVerificationInfo ivi : iviList) {
571 for (String host : ivi.getDomains()) {
572 result.add(host);
573 }
574 }
575 }
576 if (filters != null && filters.size() > 0) {
577 for (IntentFilter filter : filters) {
Christopher Tateddaa1422015-07-16 16:00:49 -0700578 if (filter.hasCategory(Intent.CATEGORY_BROWSABLE)
579 && (filter.hasDataScheme(IntentFilter.SCHEME_HTTP) ||
580 filter.hasDataScheme(IntentFilter.SCHEME_HTTPS))) {
Christopher Tatea08a2252015-07-01 16:52:43 -0700581 result.addAll(filter.getHostsList());
582 }
583 }
584 }
585 return result;
586 }
587
Sudheer Shankabc956302015-04-09 12:19:53 +0100588 /**
589 * Returns the application info of the currently installed MDM package.
590 */
591 public static ApplicationInfo getAdminApplicationInfo(Context context, int profileId) {
592 DevicePolicyManager dpm =
593 (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);
594 ComponentName mdmPackage = dpm.getProfileOwnerAsUser(profileId);
595 if (mdmPackage == null) {
596 return null;
597 }
598 String mdmPackageName = mdmPackage.getPackageName();
599 try {
600 IPackageManager ipm = AppGlobals.getPackageManager();
601 ApplicationInfo mdmApplicationInfo =
602 ipm.getApplicationInfo(mdmPackageName, 0, profileId);
603 return mdmApplicationInfo;
604 } catch (RemoteException e) {
605 Log.e(TAG, "Error while retrieving application info for package " + mdmPackageName
606 + ", userId " + profileId, e);
607 return null;
608 }
609 }
Jason Monkb45e27b2015-05-20 13:35:43 -0400610
611 public static boolean isBandwidthControlEnabled() {
612 final INetworkManagementService netManager = INetworkManagementService.Stub
613 .asInterface(ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE));
614 try {
615 return netManager.isBandwidthControlEnabled();
616 } catch (RemoteException e) {
617 return false;
618 }
619 }
Julia Reynoldsce25af42015-07-08 16:56:31 -0400620
621 /**
622 * Returns an accessible SpannableString.
623 * @param displayText the text to display
624 * @param accessibileText the text text-to-speech engines should read
625 */
626 public static SpannableString createAccessibleSequence(CharSequence displayText,
627 String accessibileText) {
628 SpannableString str = new SpannableString(displayText);
629 str.setSpan(new TtsSpan.TextBuilder(accessibileText).build(), 0,
630 displayText.length(),
631 Spannable.SPAN_INCLUSIVE_INCLUSIVE);
632 return str;
633 }
Andres Morales7bdffd82015-08-04 16:55:00 -0700634
Clara Bayarrife432e82015-10-12 12:07:02 +0100635 /**
Jeff Sharkey219ec912017-12-19 14:57:39 -0700636 * Returns the user id present in the bundle with
637 * {@link Intent#EXTRA_USER_ID} if it belongs to the current user.
Clara Bayarrife432e82015-10-12 12:07:02 +0100638 *
Jeff Sharkey219ec912017-12-19 14:57:39 -0700639 * @throws SecurityException if the given userId does not belong to the
640 * current user group.
Clara Bayarrife432e82015-10-12 12:07:02 +0100641 */
Benjamin Franz194300d2016-01-13 12:16:25 +0000642 public static int getUserIdFromBundle(Context context, Bundle bundle) {
Jeff Sharkey219ec912017-12-19 14:57:39 -0700643 return getUserIdFromBundle(context, bundle, false);
644 }
645
646 /**
647 * Returns the user id present in the bundle with
648 * {@link Intent#EXTRA_USER_ID} if it belongs to the current user.
649 *
650 * @param isInternal indicating if the caller is "internal" to the system,
651 * meaning we're willing to trust extras like
652 * {@link ChooseLockSettingsHelper#EXTRA_ALLOW_ANY_USER}.
653 * @throws SecurityException if the given userId does not belong to the
654 * current user group.
655 */
656 public static int getUserIdFromBundle(Context context, Bundle bundle, boolean isInternal) {
Clara Bayarrife432e82015-10-12 12:07:02 +0100657 if (bundle == null) {
Benjamin Franz194300d2016-01-13 12:16:25 +0000658 return getCredentialOwnerUserId(context);
Clara Bayarrife432e82015-10-12 12:07:02 +0100659 }
Jeff Sharkey219ec912017-12-19 14:57:39 -0700660 final boolean allowAnyUser = isInternal
661 && bundle.getBoolean(ChooseLockSettingsHelper.EXTRA_ALLOW_ANY_USER, false);
Clara Bayarri6934a042015-10-14 11:07:35 +0100662 int userId = bundle.getInt(Intent.EXTRA_USER_ID, UserHandle.myUserId());
Adrian Roos5a9a3cd2017-03-30 18:02:25 -0700663 if (userId == LockPatternUtils.USER_FRP) {
Jeff Sharkey219ec912017-12-19 14:57:39 -0700664 return allowAnyUser ? userId : enforceSystemUser(context, userId);
Adrian Roos5a9a3cd2017-03-30 18:02:25 -0700665 } else {
Jeff Sharkey219ec912017-12-19 14:57:39 -0700666 return allowAnyUser ? userId : enforceSameOwner(context, userId);
Adrian Roos5a9a3cd2017-03-30 18:02:25 -0700667 }
668 }
669
670 /**
671 * Returns the given user id if the current user is the system user.
672 *
673 * @throws SecurityException if the current user is not the system user.
674 */
675 public static int enforceSystemUser(Context context, int userId) {
676 if (UserHandle.myUserId() == UserHandle.USER_SYSTEM) {
677 return userId;
678 }
679 throw new SecurityException("Given user id " + userId + " must only be used from "
680 + "USER_SYSTEM, but current user is " + UserHandle.myUserId());
Clara Bayarrife432e82015-10-12 12:07:02 +0100681 }
682
683 /**
684 * Returns the given user id if it belongs to the current user.
685 *
686 * @throws SecurityException if the given userId does not belong to the current user group.
687 */
Benjamin Franz194300d2016-01-13 12:16:25 +0000688 public static int enforceSameOwner(Context context, int userId) {
Ricky Wai72500162016-06-07 16:54:25 +0100689 final UserManager um = getUserManager(context);
690 final int[] profileIds = um.getProfileIdsWithDisabled(UserHandle.myUserId());
691 if (ArrayUtils.contains(profileIds, userId)) {
692 return userId;
Clara Bayarrife432e82015-10-12 12:07:02 +0100693 }
Ricky Wai72500162016-06-07 16:54:25 +0100694 throw new SecurityException("Given user id " + userId + " does not belong to user "
695 + UserHandle.myUserId());
Clara Bayarrife432e82015-10-12 12:07:02 +0100696 }
697
Benjamin Franz194300d2016-01-13 12:16:25 +0000698 /**
699 * Returns the effective credential owner of the calling user.
700 */
701 public static int getCredentialOwnerUserId(Context context) {
702 return getCredentialOwnerUserId(context, UserHandle.myUserId());
703 }
704
705 /**
706 * Returns the user id of the credential owner of the given user id.
707 */
708 public static int getCredentialOwnerUserId(Context context, int userId) {
709 UserManager um = getUserManager(context);
710 return um.getCredentialOwnerProfile(userId);
Andres Morales7bdffd82015-08-04 16:55:00 -0700711 }
Jason Monkdb4ed192015-12-11 16:48:31 -0500712
Jason Monkb37e2882016-01-11 14:27:20 -0500713 private static final StringBuilder sBuilder = new StringBuilder(50);
714 private static final java.util.Formatter sFormatter = new java.util.Formatter(
715 sBuilder, Locale.getDefault());
716
717 public static String formatDateRange(Context context, long start, long end) {
718 final int flags = FORMAT_SHOW_DATE | FORMAT_ABBREV_MONTH;
719
720 synchronized (sBuilder) {
721 sBuilder.setLength(0);
722 return DateUtils.formatDateRange(context, sFormatter, start, end, flags, null)
723 .toString();
724 }
725 }
Jason Monk91e2f892016-02-23 15:31:09 -0500726
Udam Saini679f7ad2016-03-25 10:47:00 -0700727 public static boolean isDeviceProvisioned(Context context) {
728 return Settings.Global.getInt(context.getContentResolver(),
729 Settings.Global.DEVICE_PROVISIONED, 0) != 0;
730 }
Ricky Wai616342b2016-04-13 10:40:22 +0100731
Bernard Chau88d523b2016-04-14 15:08:28 +0100732 public static boolean startQuietModeDialogIfNecessary(Context context, UserManager um,
Ricky Wai616342b2016-04-13 10:40:22 +0100733 int userId) {
734 if (um.isQuietModeEnabled(UserHandle.of(userId))) {
735 final Intent intent = UnlaunchableAppActivity.createInQuietModeDialogIntent(userId);
736 context.startActivity(intent);
737 return true;
738 }
739 return false;
740 }
Sudheer Shankac3eb16e2016-04-21 12:51:43 -0700741
Rubin Xu3231afe2016-08-24 10:15:07 +0100742 public static boolean unlockWorkProfileIfNecessary(Context context, int userId) {
743 try {
Sudheer Shankaacb1a612016-11-10 15:30:14 -0800744 if (!ActivityManager.getService().isUserRunning(userId,
Rubin Xu3231afe2016-08-24 10:15:07 +0100745 ActivityManager.FLAG_AND_LOCKED)) {
746 return false;
747 }
748 } catch (RemoteException e) {
749 return false;
750 }
751 if (!(new LockPatternUtils(context)).isSecure(userId)) {
752 return false;
753 }
Robin Leecccf3242017-02-10 15:32:49 +0000754 return confirmWorkProfileCredentials(context, userId);
755 }
756
Robin Leecccf3242017-02-10 15:32:49 +0000757 private static boolean confirmWorkProfileCredentials(Context context, int userId) {
Rubin Xu3231afe2016-08-24 10:15:07 +0100758 final KeyguardManager km = (KeyguardManager) context.getSystemService(
759 Context.KEYGUARD_SERVICE);
760 final Intent unlockIntent = km.createConfirmDeviceCredentialIntent(null, null, userId);
761 if (unlockIntent != null) {
762 context.startActivity(unlockIntent);
763 return true;
764 } else {
765 return false;
766 }
Rubin Xu3231afe2016-08-24 10:15:07 +0100767 }
768
Sudheer Shankac3eb16e2016-04-21 12:51:43 -0700769 public static CharSequence getApplicationLabel(Context context, String packageName) {
770 try {
771 final ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(
772 packageName,
773 PackageManager.MATCH_DISABLED_COMPONENTS
Amith Yamasani21556cd2016-11-01 15:49:21 -0700774 | PackageManager.MATCH_ANY_USER);
Sudheer Shankac3eb16e2016-04-21 12:51:43 -0700775 return appInfo.loadLabel(context.getPackageManager());
776 } catch (PackageManager.NameNotFoundException e) {
777 Log.w(TAG, "Unable to find info for package: " + packageName);
778 }
779 return null;
780 }
Jason Monk75199542016-05-06 15:09:32 -0400781
Jeff Sharkey4a8136b2016-07-27 12:53:34 -0600782 public static boolean isPackageDirectBootAware(Context context, String packageName) {
783 try {
784 final ApplicationInfo ai = context.getPackageManager().getApplicationInfo(
785 packageName, 0);
786 return ai.isDirectBootAware() || ai.isPartiallyDirectBootAware();
787 } catch (NameNotFoundException ignored) {
788 }
789 return false;
790 }
Andre Lago3e398c82016-07-25 14:12:28 +0100791
792 /**
793 * Returns a context created from the given context for the given user, or null if it fails
794 */
795 public static Context createPackageContextAsUser(Context context, int userId) {
796 try {
797 return context.createPackageContextAsUser(
798 context.getPackageName(), 0 /* flags */, UserHandle.of(userId));
799 } catch (PackageManager.NameNotFoundException e) {
800 Log.e(TAG, "Failed to create user context", e);
801 }
802 return null;
803 }
Jeff Sharkeyab508072016-10-11 14:25:22 -0600804
805 public static FingerprintManager getFingerprintManagerOrNull(Context context) {
806 if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
Fan Zhangcf97f0b2018-01-05 11:18:44 -0800807 return (FingerprintManager) context.getSystemService(Context.FINGERPRINT_SERVICE);
Jeff Sharkeyab508072016-10-11 14:25:22 -0600808 } else {
809 return null;
810 }
811 }
Daniel Nishi31027da2017-01-19 14:03:57 -0800812
Kevin Chyn82792cc2017-07-20 00:15:44 -0700813 public static boolean hasFingerprintHardware(Context context) {
814 FingerprintManager fingerprintManager = getFingerprintManagerOrNull(context);
815 return fingerprintManager != null && fingerprintManager.isHardwareDetected();
816 }
817
Kevin Chyn4882e872018-06-25 17:58:31 -0700818 public static FaceManager getFaceManagerOrNull(Context context) {
819 if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_FACE)) {
820 return (FaceManager) context.getSystemService(Context.FACE_SERVICE);
821 } else {
822 return null;
823 }
824 }
825
826 public static boolean hasFaceHardware(Context context) {
827 FaceManager faceManager = getFaceManagerOrNull(context);
828 return faceManager != null && faceManager.isHardwareDetected();
829 }
830
Daniel Nishi31027da2017-01-19 14:03:57 -0800831 /**
832 * Launches an intent which may optionally have a user id defined.
833 * @param fragment Fragment to use to launch the activity.
834 * @param intent Intent to launch.
835 */
836 public static void launchIntent(Fragment fragment, Intent intent) {
837 try {
838 final int userId = intent.getIntExtra(Intent.EXTRA_USER_ID, -1);
839
840 if (userId == -1) {
841 fragment.startActivity(intent);
842 } else {
843 fragment.getActivity().startActivityAsUser(intent, new UserHandle(userId));
844 }
845 } catch (ActivityNotFoundException e) {
846 Log.w(TAG, "No activity found for " + intent);
847 }
848 }
849
Christine Franksc6890ab2017-06-23 14:28:21 -0700850 public static boolean isDemoUser(Context context) {
851 return UserManager.isDeviceInDemoMode(context) && getUserManager(context).isDemoUser();
852 }
853
Justin Klaassen30257272017-08-08 21:58:05 -0700854 public static ComponentName getDeviceOwnerComponent(Context context) {
855 final DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService(
856 Context.DEVICE_POLICY_SERVICE);
857 return dpm.getDeviceOwnerComponentOnAnyUser();
Christine Franks14782222017-01-23 16:44:02 -0800858 }
Daniel Nishidfed8a22017-01-19 16:32:41 -0800859
860 /**
861 * Returns if a given user is a profile of another user.
Christine Franksa0dd9872017-07-11 17:32:57 -0700862 * @param user The user whose profiles wibe checked.
Daniel Nishidfed8a22017-01-19 16:32:41 -0800863 * @param profile The (potential) profile.
864 * @return if the profile is actually a profile
865 */
866 public static boolean isProfileOf(UserInfo user, UserInfo profile) {
867 return user.id == profile.id ||
868 (user.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID
869 && user.profileGroupId == profile.profileGroupId);
870 }
Daniel Nishi9f60f422017-02-15 15:25:48 -0800871
872 /**
873 * Tries to initalize a volume with the given bundle. If it is a valid, private, and readable
874 * {@link VolumeInfo}, it is returned. If it is not valid, null is returned.
875 */
876 @Nullable
877 public static VolumeInfo maybeInitializeVolume(StorageManager sm, Bundle bundle) {
878 final String volumeId = bundle.getString(VolumeInfo.EXTRA_VOLUME_ID,
879 VolumeInfo.ID_PRIVATE_INTERNAL);
880 VolumeInfo volume = sm.findVolumeById(volumeId);
881 return isVolumeValid(volume) ? volume : null;
882 }
883
jackqdyuleiddba9662017-03-08 19:35:02 -0800884 /**
jackqdyulei00015fb2017-08-22 11:25:30 -0700885 * Return {@code true} if the supplied package is device owner or profile owner of at
886 * least one user.
887 * @param userManager used to get profile owner app for each user
888 * @param devicePolicyManager used to check whether it is device owner app
889 * @param packageName package to check about
890 */
891 public static boolean isProfileOrDeviceOwner(UserManager userManager,
Fan Zhangaab36de2018-03-30 16:58:28 -0700892 DevicePolicyManager devicePolicyManager, String packageName) {
jackqdyulei00015fb2017-08-22 11:25:30 -0700893 List<UserInfo> userInfos = userManager.getUsers();
894 if (devicePolicyManager.isDeviceOwnerAppOnAnyUser(packageName)) {
895 return true;
896 }
897 for (int i = 0, size = userInfos.size(); i < size; i++) {
898 ComponentName cn = devicePolicyManager.getProfileOwnerAsUser(userInfos.get(i).id);
899 if (cn != null && cn.getPackageName().equals(packageName)) {
900 return true;
901 }
902 }
903 return false;
904 }
905
906 /**
jackqdyuleiddba9662017-03-08 19:35:02 -0800907 * Return the resource id to represent the install status for an app
908 */
909 @StringRes
910 public static int getInstallationStatus(ApplicationInfo info) {
911 if ((info.flags & ApplicationInfo.FLAG_INSTALLED) == 0) {
912 return R.string.not_installed;
913 }
914 return info.enabled ? R.string.installed : R.string.disabled;
915 }
916
Daniel Nishi9f60f422017-02-15 15:25:48 -0800917 private static boolean isVolumeValid(VolumeInfo volume) {
918 return (volume != null) && (volume.getType() == VolumeInfo.TYPE_PRIVATE)
919 && volume.isMountedReadable();
920 }
jackqdyuleif4c1cef2017-03-31 12:57:10 -0700921
PMS2263a05602017-06-14 07:10:15 +0000922 public static void setEditTextCursorPosition(EditText editText) {
923 editText.setSelection(editText.getText().length());
924 }
Felipe Lemebd884502017-09-15 18:16:21 -0700925
926 /**
927 * Sets the preference icon with a drawable that is scaled down to to avoid crashing Settings if
928 * it's too big.
929 */
930 public static void setSafeIcon(Preference pref, Drawable icon) {
931 Drawable safeIcon = icon;
Phil Weaver5a3e02d2018-03-08 17:38:46 -0800932 if ((icon != null) && !(icon instanceof VectorDrawable)) {
Felipe Lemebd884502017-09-15 18:16:21 -0700933 safeIcon = getSafeDrawable(icon, 500, 500);
934 }
935 pref.setIcon(safeIcon);
936 }
937
938 /**
939 * Gets a drawable with a limited size to avoid crashing Settings if it's too big.
940 *
941 * @param original original drawable, typically an app icon.
942 * @param maxWidth maximum width, in pixels.
943 * @param maxHeight maximum height, in pixels.
944 */
945 public static Drawable getSafeDrawable(Drawable original, int maxWidth, int maxHeight) {
946 final int actualWidth = original.getMinimumWidth();
947 final int actualHeight = original.getMinimumHeight();
948
949 if (actualWidth <= maxWidth && actualHeight <= maxHeight) {
950 return original;
951 }
952
953 float scaleWidth = ((float) maxWidth) / actualWidth;
954 float scaleHeight = ((float) maxHeight) / actualHeight;
955 float scale = Math.min(scaleWidth, scaleHeight);
956 final int width = (int) (actualWidth * scale);
957 final int height = (int) (actualHeight * scale);
958
959 final Bitmap bitmap;
960 if (original instanceof BitmapDrawable) {
961 bitmap = Bitmap.createScaledBitmap(((BitmapDrawable) original).getBitmap(), width,
962 height, false);
963 } else {
Jason Chiuc78c54a2019-02-13 16:07:57 +0800964 bitmap = createBitmap(original, width, height);
Felipe Lemebd884502017-09-15 18:16:21 -0700965 }
966 return new BitmapDrawable(null, bitmap);
967 }
jackqdyuleifde637f2018-01-02 14:51:01 -0800968
969 /**
Jason Chiuc78c54a2019-02-13 16:07:57 +0800970 * Create an Icon pointing to a drawable.
Jason Chiu1217bbe2019-01-24 16:32:31 +0800971 */
Jason Chiuc78c54a2019-02-13 16:07:57 +0800972 public static IconCompat createIconWithDrawable(Drawable drawable) {
973 Bitmap bitmap;
Jason Chiu1217bbe2019-01-24 16:32:31 +0800974 if (drawable instanceof BitmapDrawable) {
Jason Chiuc78c54a2019-02-13 16:07:57 +0800975 bitmap = ((BitmapDrawable)drawable).getBitmap();
976 } else {
977 final int width = drawable.getIntrinsicWidth();
978 final int height = drawable.getIntrinsicHeight();
979 bitmap = createBitmap(drawable,
980 width > 0 ? width : 1,
981 height > 0 ? height : 1);
Jason Chiu1217bbe2019-01-24 16:32:31 +0800982 }
Jason Chiuc78c54a2019-02-13 16:07:57 +0800983 return IconCompat.createWithBitmap(bitmap);
984 }
Jason Chiu1217bbe2019-01-24 16:32:31 +0800985
clownshen24827d32019-03-29 20:22:02 +0800986 /**
987 * Creates a drawable with specified width and height.
988 */
989 public static Bitmap createBitmap(Drawable drawable, int width, int height) {
Jason Chiuc78c54a2019-02-13 16:07:57 +0800990 final Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
Jason Chiu1217bbe2019-01-24 16:32:31 +0800991 final Canvas canvas = new Canvas(bitmap);
992 drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
993 drawable.draw(canvas);
994 return bitmap;
995 }
996
997 /**
jackqdyuleifde637f2018-01-02 14:51:01 -0800998 * Get the {@link Drawable} that represents the app icon
999 */
1000 public static Drawable getBadgedIcon(IconDrawableFactory iconDrawableFactory,
1001 PackageManager packageManager, String packageName, int userId) {
1002 try {
Tony Mak4e292812018-03-19 15:37:21 +00001003 final ApplicationInfo appInfo = packageManager.getApplicationInfoAsUser(
1004 packageName, PackageManager.GET_META_DATA, userId);
jackqdyuleifde637f2018-01-02 14:51:01 -08001005 return iconDrawableFactory.getBadgedIcon(appInfo, userId);
1006 } catch (PackageManager.NameNotFoundException e) {
1007 return packageManager.getDefaultActivityIcon();
1008 }
1009 }
Raff Tsai2928cd42018-11-05 16:10:19 +08001010
1011 /** Returns true if the current package is installed & enabled. */
1012 public static boolean isPackageEnabled(Context context, String packageName) {
1013 try {
1014 return context.getPackageManager().getApplicationInfo(packageName, 0).enabled;
1015 } catch (Exception e) {
1016 Log.e(TAG, "Error while retrieving application info for package " + packageName, e);
1017 }
1018 return false;
1019 }
markchien1dd1d792019-01-11 16:18:20 +08001020
1021 /** Get {@link Resources} by subscription id if subscription id is valid. */
1022 public static Resources getResourcesForSubId(Context context, int subId) {
1023 if (subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
1024 return SubscriptionManager.getResourcesForSubId(context, subId);
1025 } else {
1026 return context.getResources();
1027 }
1028 }
Ng Zhi Anb97bdc32019-02-01 12:39:31 -08001029
1030 /**
1031 * Returns true if SYSTEM_ALERT_WINDOW permission is available.
1032 * Starting from Q, SYSTEM_ALERT_WINDOW is disabled on low ram phones.
1033 */
1034 public static boolean isSystemAlertWindowEnabled(Context context) {
1035 // SYSTEM_ALERT_WINDOW is disabled on on low ram devices starting from Q
1036 ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
1037 return !(am.isLowRamDevice() && (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q));
1038 }
tmfangaed8f362019-03-18 16:56:09 +08001039
1040 /**
1041 * Adds a shadow appear/disappear animation to action bar scroll.
1042 *
1043 * <p/>
1044 * This method must be called after {@link Fragment#onCreate(Bundle)}.
1045 */
1046 public static void setActionBarShadowAnimation(Activity activity, Lifecycle lifecycle,
1047 View scrollView) {
1048 if (activity == null) {
1049 Log.w(TAG, "No activity, cannot style actionbar.");
1050 return;
1051 }
1052 final ActionBar actionBar = activity.getActionBar();
1053 if (actionBar == null) {
1054 Log.w(TAG, "No actionbar, cannot style actionbar.");
1055 return;
1056 }
1057 actionBar.setElevation(0);
1058
1059 if (lifecycle != null && scrollView != null) {
1060 ActionBarShadowController.attachToView(activity, lifecycle, scrollView);
1061 }
1062 }
Jeff Sharkey4a8136b2016-07-27 12:53:34 -06001063}