blob: d7064e694d8e91f91c7c770ec20870a087b4e561 [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;
Amith Yamasaniae697552011-09-27 11:33:17 -070025import android.app.ActivityManager;
Amith Yamasani9627a8e2012-09-23 12:54:14 -070026import android.app.AlertDialog;
Sudheer Shankabc956302015-04-09 12:19:53 +010027import android.app.AppGlobals;
Amith Yamasani9627a8e2012-09-23 12:54:14 -070028import android.app.Dialog;
Fabrice Di Meglio769630c2014-04-24 14:48:48 -070029import android.app.Fragment;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010030import android.app.IActivityManager;
Rubin Xu3231afe2016-08-24 10:15:07 +010031import android.app.KeyguardManager;
Sudheer Shankabc956302015-04-09 12:19:53 +010032import android.app.admin.DevicePolicyManager;
Daniel Nishi31027da2017-01-19 14:03:57 -080033import android.content.ActivityNotFoundException;
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -080034import android.content.ComponentName;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070035import android.content.ContentResolver;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080036import android.content.Context;
Amith Yamasani9627a8e2012-09-23 12:54:14 -070037import android.content.DialogInterface;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080038import android.content.Intent;
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -080039import android.content.IntentFilter;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080040import android.content.pm.ApplicationInfo;
Sudheer Shankabc956302015-04-09 12:19:53 +010041import android.content.pm.IPackageManager;
Christopher Tatea08a2252015-07-01 16:52:43 -070042import android.content.pm.IntentFilterVerificationInfo;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080043import android.content.pm.PackageManager;
Jason Monk75199542016-05-06 15:09:32 -040044import android.content.pm.PackageManager.NameNotFoundException;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070045import android.content.pm.ResolveInfo;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070046import android.content.pm.UserInfo;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020047import android.content.res.Resources;
Jason Monkb5aa73f2015-03-31 12:59:33 -040048import android.content.res.TypedArray;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070049import android.database.Cursor;
Amith Yamasanif34a85d2012-09-17 18:31:45 -070050import android.graphics.Bitmap;
51import android.graphics.BitmapFactory;
Felipe Lemebd884502017-09-15 18:16:21 -070052import android.graphics.Canvas;
53import android.graphics.drawable.BitmapDrawable;
54import android.graphics.drawable.Drawable;
Jeff Sharkeyab508072016-10-11 14:25:22 -060055import android.hardware.fingerprint.FingerprintManager;
Roozbeh Pournader15872242017-06-20 16:46:49 -070056import android.icu.text.MeasureFormat;
Roozbeh Pournader4de9df22017-08-26 14:05:15 -070057import android.icu.text.RelativeDateTimeFormatter;
58import android.icu.text.RelativeDateTimeFormatter.RelativeUnit;
Roozbeh Pournader15872242017-06-20 16:46:49 -070059import android.icu.util.Measure;
60import android.icu.util.MeasureUnit;
Roozbeh Pournader4de9df22017-08-26 14:05:15 -070061import android.icu.util.ULocale;
Amith Yamasanic06d4c42011-02-25 14:35:20 -080062import android.net.ConnectivityManager;
63import android.net.LinkProperties;
Jaewoong Jungc260e6d2016-10-13 14:21:52 -070064import android.net.Network;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070065import android.net.Uri;
Jaewoong Jungc260e6d2016-10-13 14:21:52 -070066import android.net.wifi.WifiManager;
Amith Yamasania4379d62011-07-22 10:34:58 -070067import android.os.BatteryManager;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020068import android.os.Bundle;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010069import android.os.IBinder;
Jason Monkb45e27b2015-05-20 13:35:43 -040070import android.os.INetworkManagementService;
Jason Monkbe941212016-05-27 12:58:53 -040071import android.os.Looper;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010072import android.os.RemoteException;
Jason Monkb45e27b2015-05-20 13:35:43 -040073import android.os.ServiceManager;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070074import android.os.UserHandle;
75import android.os.UserManager;
Fabrice Di Megliodff3faa2015-02-27 11:14:11 -080076import android.os.storage.StorageManager;
Daniel Nishi9f60f422017-02-15 15:25:48 -080077import android.os.storage.VolumeInfo;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070078import android.preference.PreferenceFrameLayout;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070079import android.provider.ContactsContract.CommonDataKinds;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070080import android.provider.ContactsContract.Contacts;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070081import android.provider.ContactsContract.Data;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070082import android.provider.ContactsContract.Profile;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070083import android.provider.ContactsContract.RawContacts;
Udam Saini679f7ad2016-03-25 10:47:00 -070084import android.provider.Settings;
jackqdyuleiddba9662017-03-08 19:35:02 -080085import android.support.annotation.StringRes;
Jason Monk39b46742015-09-10 15:52:51 -040086import android.support.v7.preference.Preference;
87import android.support.v7.preference.PreferenceGroup;
Jason Monk91e2f892016-02-23 15:31:09 -050088import android.support.v7.preference.PreferenceManager;
89import android.support.v7.preference.PreferenceScreen;
Amith Yamasani60133dd2010-09-11 14:17:31 -070090import android.telephony.TelephonyManager;
Julia Reynoldsce25af42015-07-08 16:56:31 -040091import android.text.Spannable;
92import android.text.SpannableString;
jackqdyuleif4c1cef2017-03-31 12:57:10 -070093import android.text.SpannableStringBuilder;
94import android.text.Spanned;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020095import android.text.TextUtils;
Jason Monkb37e2882016-01-11 14:27:20 -050096import android.text.format.DateUtils;
Julia Reynoldsce25af42015-07-08 16:56:31 -040097import android.text.style.TtsSpan;
Christopher Tatea08a2252015-07-01 16:52:43 -070098import android.util.ArraySet;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010099import android.util.Log;
Zoltan Szatmary-Bane5814ff2014-12-19 16:27:45 +0000100import android.util.SparseArray;
Jason Monkdb4ed192015-12-11 16:48:31 -0500101import android.util.TypedValue;
Zoltan Szatmary-Ban3af2e4c2014-12-19 17:17:23 +0000102import android.view.LayoutInflater;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700103import android.view.View;
104import android.view.ViewGroup;
PMS2263a05602017-06-14 07:10:15 +0000105import android.widget.EditText;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700106import android.widget.ListView;
107import android.widget.TabWidget;
Fan Zhangcc335d92016-09-29 14:37:14 -0700108
Ricky Wai616342b2016-04-13 10:40:22 +0100109import com.android.internal.app.UnlaunchableAppActivity;
Ricky Wai72500162016-06-07 16:54:25 +0100110import com.android.internal.util.ArrayUtils;
Alexandra Gherghinabc6e78f2014-09-03 10:22:09 +0100111import com.android.internal.util.UserIcons;
Rubin Xu3231afe2016-08-24 10:15:07 +0100112import com.android.internal.widget.LockPatternUtils;
Doris Lingdee1a222017-08-31 16:17:30 -0700113import com.android.settings.wrapper.DevicePolicyManagerWrapper;
Tony Mantlerd9af0b82017-10-20 15:03:28 -0700114import com.android.settings.wrapper.FingerprintManagerWrapper;
Daisuke Miyakawaa2633d02010-09-15 20:09:12 -0700115
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700116import java.io.IOException;
117import java.io.InputStream;
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800118import java.net.InetAddress;
Alexandra Gherghina80e1f1b2014-07-31 14:56:33 +0100119import java.util.ArrayList;
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800120import java.util.Iterator;
Daisuke Miyakawaa2633d02010-09-15 20:09:12 -0700121import java.util.List;
Jean Chalard71ad1f42011-05-12 15:06:16 +0900122import java.util.Locale;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800123
Jason Monk27985e12016-01-08 14:13:05 -0500124public final class Utils extends com.android.settingslib.Utils {
125
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100126 private static final String TAG = "Settings";
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100127
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800128 /**
129 * Set the preference's title to the matching activity's label.
130 */
131 public static final int UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY = 1;
132
133 /**
Shuhrat Dehkanov96577682012-10-03 12:24:07 +0900134 * The opacity level of a disabled icon.
135 */
136 public static final float DISABLED_ALPHA = 0.4f;
137
138 /**
Dianne Hackborn68f005f2014-06-18 18:29:12 -0700139 * Color spectrum to use to indicate badness. 0 is completely transparent (no data),
140 * 1 is most bad (red), the last value is least bad (green).
141 */
142 public static final int[] BADNESS_COLORS = new int[] {
143 0x00000000, 0xffc43828, 0xffe54918, 0xfff47b00,
144 0xfffabf2c, 0xff679e37, 0xff0a7f42
145 };
146
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100147 private static final String SETTINGS_PACKAGE_NAME = "com.android.settings";
148
Elliott Hughes7253df32014-09-02 17:10:14 -0700149 private static final int SECONDS_PER_MINUTE = 60;
150 private static final int SECONDS_PER_HOUR = 60 * 60;
151 private static final int SECONDS_PER_DAY = 24 * 60 * 60;
152
Jason Monkbeb171d2015-05-21 15:24:37 -0400153 public static final String OS_PKG = "os";
154
Zoltan Szatmary-Bane5814ff2014-12-19 16:27:45 +0000155 private static SparseArray<Bitmap> sDarkDefaultUserBitmapCache = new SparseArray<Bitmap>();
156
Anders Hammar1b2dd9032010-04-08 10:03:50 +0200157 /**
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800158 * Finds a matching activity for a preference's intent. If a matching
159 * activity is not found, it will remove the preference.
Ying Wanga7188322010-01-04 18:45:10 -0800160 *
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800161 * @param context The context.
162 * @param parentPreferenceGroup The preference group that contains the
163 * preference whose intent is being resolved.
164 * @param preferenceKey The key of the preference whose intent is being
165 * resolved.
166 * @param flags 0 or one or more of
167 * {@link #UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY}
168 * .
169 * @return Whether an activity was found. If false, the preference was
170 * removed.
171 */
172 public static boolean updatePreferenceToSpecificActivityOrRemove(Context context,
173 PreferenceGroup parentPreferenceGroup, String preferenceKey, int flags) {
Ying Wanga7188322010-01-04 18:45:10 -0800174
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800175 Preference preference = parentPreferenceGroup.findPreference(preferenceKey);
176 if (preference == null) {
177 return false;
178 }
Ying Wanga7188322010-01-04 18:45:10 -0800179
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800180 Intent intent = preference.getIntent();
181 if (intent != null) {
182 // Find the activity that is in the system image
183 PackageManager pm = context.getPackageManager();
184 List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
185 int listSize = list.size();
186 for (int i = 0; i < listSize; i++) {
187 ResolveInfo resolveInfo = list.get(i);
188 if ((resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
189 != 0) {
Ying Wanga7188322010-01-04 18:45:10 -0800190
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800191 // Replace the intent with this specific activity
192 preference.setIntent(new Intent().setClassName(
193 resolveInfo.activityInfo.packageName,
194 resolveInfo.activityInfo.name));
195
196 if ((flags & UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY) != 0) {
197 // Set the preference title to the activity's label
198 preference.setTitle(resolveInfo.loadLabel(pm));
199 }
Ying Wanga7188322010-01-04 18:45:10 -0800200
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800201 return true;
202 }
203 }
204 }
205
206 // Did not find a matching activity, so remove the preference
207 parentPreferenceGroup.removePreference(preference);
Ying Wanga7188322010-01-04 18:45:10 -0800208
Shuhrat Dehkanov7dc567a2012-04-23 01:59:56 +0900209 return false;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800210 }
Ying Wanga7188322010-01-04 18:45:10 -0800211
Anders Hammar1b2dd9032010-04-08 10:03:50 +0200212 /**
Benjamin Franz194300d2016-01-13 12:16:25 +0000213 * Returns the UserManager for a given context
214 *
215 * @throws IllegalStateException if no UserManager could be retrieved.
216 */
217 public static UserManager getUserManager(Context context) {
218 UserManager um = UserManager.get(context);
219 if (um == null) {
220 throw new IllegalStateException("Unable to load UserManager");
221 }
222 return um;
223 }
224
225 /**
Ying Wanga7188322010-01-04 18:45:10 -0800226 * Returns true if Monkey is running.
227 */
228 public static boolean isMonkeyRunning() {
Amith Yamasaniae697552011-09-27 11:33:17 -0700229 return ActivityManager.isUserAMonkey();
Ying Wanga7188322010-01-04 18:45:10 -0800230 }
Amith Yamasani60133dd2010-09-11 14:17:31 -0700231
232 /**
233 * Returns whether the device is voice-capable (meaning, it is also a phone).
234 */
235 public static boolean isVoiceCapable(Context context) {
236 TelephonyManager telephony =
237 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
238 return telephony != null && telephony.isVoiceCapable();
239 }
Amith Yamasani0f85c482011-02-23 17:19:11 -0800240
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800241 /**
242 * Returns the WIFI IP Addresses, if any, taking into account IPv4 and IPv6 style addresses.
243 * @param context the application context
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900244 * @return the formatted and newline-separated IP addresses, or null if none.
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800245 */
246 public static String getWifiIpAddresses(Context context) {
Jaewoong Jungc260e6d2016-10-13 14:21:52 -0700247 WifiManager wifiManager = context.getSystemService(WifiManager.class);
248 Network currentNetwork = wifiManager.getCurrentNetwork();
249 if (currentNetwork != null) {
250 ConnectivityManager cm = (ConnectivityManager)
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800251 context.getSystemService(Context.CONNECTIVITY_SERVICE);
Jaewoong Jungc260e6d2016-10-13 14:21:52 -0700252 LinkProperties prop = cm.getLinkProperties(currentNetwork);
253 return formatIpAddresses(prop);
254 }
255 return null;
Amith Yamasani6822b742011-10-17 16:41:00 -0700256 }
257
258 /**
259 * Returns the default link's IP addresses, if any, taking into account IPv4 and IPv6 style
260 * addresses.
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900261 * @return the formatted and newline-separated IP addresses, or null if none.
Amith Yamasani6822b742011-10-17 16:41:00 -0700262 */
Lorenzo Colitti6eb6a902013-11-08 03:53:29 +0900263 public static String getDefaultIpAddresses(ConnectivityManager cm) {
Amith Yamasani6822b742011-10-17 16:41:00 -0700264 LinkProperties prop = cm.getActiveLinkProperties();
265 return formatIpAddresses(prop);
266 }
267
268 private static String formatIpAddresses(LinkProperties prop) {
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800269 if (prop == null) return null;
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900270 Iterator<InetAddress> iter = prop.getAllAddresses().iterator();
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800271 // If there are no entries, return null
272 if (!iter.hasNext()) return null;
273 // Concatenate all available addresses, comma separated
274 String addresses = "";
275 while (iter.hasNext()) {
276 addresses += iter.next().getHostAddress();
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900277 if (iter.hasNext()) addresses += "\n";
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800278 }
279 return addresses;
280 }
Jean Chalard71ad1f42011-05-12 15:06:16 +0900281
282 public static Locale createLocaleFromString(String localeStr) {
283 // TODO: is there a better way to actually construct a locale that will match?
284 // The main problem is, on top of Java specs, locale.toString() and
285 // new Locale(locale.toString()).toString() do not return equal() strings in
286 // many cases, because the constructor takes the only string as the language
287 // code. So : new Locale("en", "US").toString() => "en_US"
288 // And : new Locale("en_US").toString() => "en_us"
289 if (null == localeStr)
290 return Locale.getDefault();
291 String[] brokenDownLocale = localeStr.split("_", 3);
292 // split may not return a 0-length array.
293 if (1 == brokenDownLocale.length) {
294 return new Locale(brokenDownLocale[0]);
295 } else if (2 == brokenDownLocale.length) {
296 return new Locale(brokenDownLocale[0], brokenDownLocale[1]);
297 } else {
298 return new Locale(brokenDownLocale[0], brokenDownLocale[1], brokenDownLocale[2]);
299 }
300 }
Amith Yamasania4379d62011-07-22 10:34:58 -0700301
Jaewan Kima3fe77b2013-06-04 21:17:40 +0900302 public static boolean isBatteryPresent(Intent batteryChangedIntent) {
303 return batteryChangedIntent.getBooleanExtra(BatteryManager.EXTRA_PRESENT, true);
304 }
305
Amith Yamasania4379d62011-07-22 10:34:58 -0700306 public static String getBatteryPercentage(Intent batteryChangedIntent) {
Elliott Hughes7253df32014-09-02 17:10:14 -0700307 return formatPercentage(getBatteryLevel(batteryChangedIntent));
Dianne Hackborn525f2bd2014-04-29 11:24:06 -0700308 }
309
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700310 /**
311 * Prepare a custom preferences layout, moving padding to {@link ListView}
312 * when outside scrollbars are requested. Usually used to display
313 * {@link ListView} and {@link TabWidget} with correct padding.
314 */
Jeff Sharkey5d706792011-09-08 18:57:17 -0700315 public static void prepareCustomPreferencesList(
Jeff Sharkey97d07fa2012-11-30 12:36:53 -0800316 ViewGroup parent, View child, View list, boolean ignoreSidePadding) {
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700317 final boolean movePadding = list.getScrollBarStyle() == View.SCROLLBARS_OUTSIDE_OVERLAY;
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700318 if (movePadding) {
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700319 final Resources res = list.getResources();
Amith Yamasani56f51a82013-08-05 10:07:23 -0700320 final int paddingSide = res.getDimensionPixelSize(R.dimen.settings_side_margin);
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700321 final int paddingBottom = res.getDimensionPixelSize(
322 com.android.internal.R.dimen.preference_fragment_padding_bottom);
Jeff Sharkey5d706792011-09-08 18:57:17 -0700323
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700324 if (parent instanceof PreferenceFrameLayout) {
325 ((PreferenceFrameLayout.LayoutParams) child.getLayoutParams()).removeBorders = true;
326
327 final int effectivePaddingSide = ignoreSidePadding ? 0 : paddingSide;
328 list.setPaddingRelative(effectivePaddingSide, 0, effectivePaddingSide, paddingBottom);
329 } else {
330 list.setPaddingRelative(paddingSide, 0, paddingSide, paddingBottom);
331 }
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700332 }
333 }
Jeff Sharkeya83a24f2011-09-16 01:52:39 -0700334
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700335 public static void forceCustomPadding(View view, boolean additive) {
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700336 final Resources res = view.getResources();
337 final int paddingSide = res.getDimensionPixelSize(R.dimen.settings_side_margin);
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700338
339 final int paddingStart = paddingSide + (additive ? view.getPaddingStart() : 0);
340 final int paddingEnd = paddingSide + (additive ? view.getPaddingEnd() : 0);
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700341 final int paddingBottom = res.getDimensionPixelSize(
342 com.android.internal.R.dimen.preference_fragment_padding_bottom);
343
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700344 view.setPaddingRelative(paddingStart, 0, paddingEnd, paddingBottom);
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700345 }
346
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700347 /* Used by UserSettings as well. Call this on a non-ui thread. */
Sudheer Shanka71caf692016-04-14 16:50:14 -0700348 public static void copyMeProfilePhoto(Context context, UserInfo user) {
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700349 Uri contactUri = Profile.CONTENT_URI;
350
Sudheer Shanka71caf692016-04-14 16:50:14 -0700351 int userId = user != null ? user.id : UserHandle.myUserId();
352
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700353 InputStream avatarDataStream = Contacts.openContactPhotoInputStream(
354 context.getContentResolver(),
355 contactUri, true);
356 // If there's no profile photo, assign a default avatar
357 if (avatarDataStream == null) {
Sudheer Shanka71caf692016-04-14 16:50:14 -0700358 assignDefaultPhoto(context, userId);
Sudheer Shanka39975a62016-04-15 17:20:54 -0700359 return;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700360 }
Sudheer Shanka39975a62016-04-15 17:20:54 -0700361
362 UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);
363 Bitmap icon = BitmapFactory.decodeStream(avatarDataStream);
364 um.setUserIcon(userId, icon);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700365 try {
Amith Yamasanif34a85d2012-09-17 18:31:45 -0700366 avatarDataStream.close();
367 } catch (IOException ioe) { }
Sudheer Shanka71caf692016-04-14 16:50:14 -0700368 }
369
jackqdyulei8164c642016-12-27 10:15:27 -0800370 /**
371 * Assign the default photo to user with {@paramref userId}
372 * @param context used to get the {@link UserManager}
373 * @param userId used to get the icon bitmap
374 * @return true if assign photo successfully, false if failed
375 */
376 public static boolean assignDefaultPhoto(Context context, int userId) {
377 if (context == null) {
378 return false;
379 }
Sudheer Shanka71caf692016-04-14 16:50:14 -0700380 UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);
381 Bitmap bitmap = getDefaultUserIconAsBitmap(userId);
382 um.setUserIcon(userId, bitmap);
jackqdyulei8164c642016-12-27 10:15:27 -0800383
384 return true;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700385 }
386
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700387 public static String getMeProfileName(Context context, boolean full) {
388 if (full) {
389 return getProfileDisplayName(context);
390 } else {
391 return getShorterNameIfPossible(context);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700392 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700393 }
394
395 private static String getShorterNameIfPossible(Context context) {
396 final String given = getLocalProfileGivenName(context);
397 return !TextUtils.isEmpty(given) ? given : getProfileDisplayName(context);
398 }
399
400 private static String getLocalProfileGivenName(Context context) {
401 final ContentResolver cr = context.getContentResolver();
402
403 // Find the raw contact ID for the local ME profile raw contact.
404 final long localRowProfileId;
405 final Cursor localRawProfile = cr.query(
406 Profile.CONTENT_RAW_CONTACTS_URI,
407 new String[] {RawContacts._ID},
408 RawContacts.ACCOUNT_TYPE + " IS NULL AND " +
409 RawContacts.ACCOUNT_NAME + " IS NULL",
410 null, null);
411 if (localRawProfile == null) return null;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700412
413 try {
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700414 if (!localRawProfile.moveToFirst()) {
415 return null;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700416 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700417 localRowProfileId = localRawProfile.getLong(0);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700418 } finally {
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700419 localRawProfile.close();
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700420 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700421
422 // Find the structured name for the raw contact.
423 final Cursor structuredName = cr.query(
424 Profile.CONTENT_URI.buildUpon().appendPath(Contacts.Data.CONTENT_DIRECTORY).build(),
425 new String[] {CommonDataKinds.StructuredName.GIVEN_NAME,
426 CommonDataKinds.StructuredName.FAMILY_NAME},
427 Data.RAW_CONTACT_ID + "=" + localRowProfileId,
428 null, null);
429 if (structuredName == null) return null;
430
431 try {
432 if (!structuredName.moveToFirst()) {
433 return null;
434 }
435 String partialName = structuredName.getString(0);
436 if (TextUtils.isEmpty(partialName)) {
437 partialName = structuredName.getString(1);
438 }
439 return partialName;
440 } finally {
441 structuredName.close();
442 }
443 }
444
445 private static final String getProfileDisplayName(Context context) {
446 final ContentResolver cr = context.getContentResolver();
447 final Cursor profile = cr.query(Profile.CONTENT_URI,
448 new String[] {Profile.DISPLAY_NAME}, null, null, null);
449 if (profile == null) return null;
450
451 try {
452 if (!profile.moveToFirst()) {
453 return null;
454 }
455 return profile.getString(0);
456 } finally {
457 profile.close();
458 }
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700459 }
Amith Yamasani9627a8e2012-09-23 12:54:14 -0700460
461 /** Not global warming, it's global change warning. */
462 public static Dialog buildGlobalChangeWarningDialog(final Context context, int titleResId,
463 final Runnable positiveAction) {
464 final AlertDialog.Builder builder = new AlertDialog.Builder(context);
465 builder.setTitle(titleResId);
466 builder.setMessage(R.string.global_change_warning);
467 builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
468 @Override
469 public void onClick(DialogInterface dialog, int which) {
470 positiveAction.run();
471 }
472 });
473 builder.setNegativeButton(android.R.string.cancel, null);
474
475 return builder.create();
476 }
477
478 public static boolean hasMultipleUsers(Context context) {
479 return ((UserManager) context.getSystemService(Context.USER_SERVICE))
480 .getUsers().size() > 1;
481 }
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700482
483 /**
484 * Start a new instance of the activity, showing only the given fragment.
485 * When launched in this mode, the given preference fragment will be instantiated and fill the
486 * entire activity.
487 *
488 * @param context The context.
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000489 * @param fragmentName The name of the fragment to display.
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700490 * @param args Optional arguments to supply to the fragment.
Fabrice Di Meglioa9e77992014-06-09 12:52:24 -0700491 * @param resultTo Option fragment that should receive the result of the activity launch.
492 * @param resultRequestCode If resultTo is non-null, this is the request code in which
493 * to report the result.
494 * @param titleResId resource id for the String to display for the title of this set
495 * of preferences.
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700496 * @param title String to display for the title of this set of preferences.
Fan Zhangc6ca3142017-02-14 15:02:35 -0800497 * @param metricsCategory The current metricsCategory for logging source when fragment starts
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700498 */
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000499 public static void startWithFragment(Context context, String fragmentName, Bundle args,
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100500 Fragment resultTo, int resultRequestCode, int titleResId,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800501 CharSequence title, int metricsCategory) {
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700502 startWithFragment(context, fragmentName, args, resultTo, resultRequestCode,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800503 null /* titleResPackageName */, titleResId, title, false /* not a shortcut */,
504 metricsCategory);
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100505 }
506
Ajay Nadathurd473e382017-11-07 13:38:50 -0800507
508 /**
509 * Start a new instance of the activity, showing only the given fragment.
510 * When launched in this mode, the given preference fragment will be instantiated and fill the
511 * entire activity.
512 *
513 * @param context The context.
514 * @param fragmentName The name of the fragment to display.
515 * @param titleResId resource id for the String to display for the title of this set
516 * of preferences.
517 * @param metricsCategory The current metricsCategory for logging source when fragment starts
518 * @param intentFlags flag that should be added to the intent.
519 */
520 public static void startWithFragment(Context context, String fragmentName, int titleResId,
521 int metricsCategory, int intentFlags) {
522 startWithFragment(context, fragmentName, null, null, 0,
523 null /* titleResPackageName */, titleResId, null, false /* not a shortcut */,
524 metricsCategory, intentFlags);
525 }
526
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100527 /**
528 * Start a new instance of the activity, showing only the given fragment.
529 * When launched in this mode, the given preference fragment will be instantiated and fill the
530 * entire activity.
531 *
532 * @param context The context.
533 * @param fragmentName The name of the fragment to display.
534 * @param args Optional arguments to supply to the fragment.
535 * @param resultTo Option fragment that should receive the result of the activity launch.
536 * @param resultRequestCode If resultTo is non-null, this is the request code in which
537 * to report the result.
538 * @param titleResPackageName Optional package name for the resource id of the title.
539 * @param titleResId resource id for the String to display for the title of this set
540 * of preferences.
541 * @param title String to display for the title of this set of preferences.
Fan Zhangc6ca3142017-02-14 15:02:35 -0800542 * @param metricsCategory The current metricsCategory for logging source when fragment starts
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100543 */
544 public static void startWithFragment(Context context, String fragmentName, Bundle args,
545 Fragment resultTo, int resultRequestCode, String titleResPackageName, int titleResId,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800546 CharSequence title, int metricsCategory) {
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100547 startWithFragment(context, fragmentName, args, resultTo, resultRequestCode,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800548 titleResPackageName, titleResId, title, false /* not a shortcut */,
549 metricsCategory);
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700550 }
551
552 public static void startWithFragment(Context context, String fragmentName, Bundle args,
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100553 Fragment resultTo, int resultRequestCode, int titleResId,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800554 CharSequence title, boolean isShortcut, int metricsCategory) {
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100555 Intent intent = onBuildStartFragmentIntent(context, fragmentName, args,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800556 null /* titleResPackageName */, titleResId, title, isShortcut, metricsCategory);
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100557 if (resultTo == null) {
558 context.startActivity(intent);
559 } else {
Doris Ling36e953f2016-08-12 15:25:00 -0700560 resultTo.getActivity().startActivityForResult(intent, resultRequestCode);
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100561 }
562 }
563
564 public static void startWithFragment(Context context, String fragmentName, Bundle args,
565 Fragment resultTo, int resultRequestCode, String titleResPackageName, int titleResId,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800566 CharSequence title, boolean isShortcut, int metricsCategory) {
Ajay Nadathurd473e382017-11-07 13:38:50 -0800567 startWithFragment(context, fragmentName, args, resultTo, resultRequestCode,
568 titleResPackageName, titleResId, title, isShortcut, metricsCategory, 0);
569 }
570
571
572 public static void startWithFragment(Context context, String fragmentName, Bundle args,
573 Fragment resultTo, int resultRequestCode, String titleResPackageName, int titleResId,
574 CharSequence title, boolean isShortcut, int metricsCategory, int flags) {
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100575 Intent intent = onBuildStartFragmentIntent(context, fragmentName, args, titleResPackageName,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800576 titleResId, title, isShortcut, metricsCategory);
Ajay Nadathurd473e382017-11-07 13:38:50 -0800577 intent.addFlags(flags);
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700578 if (resultTo == null) {
579 context.startActivity(intent);
580 } else {
581 resultTo.startActivityForResult(intent, resultRequestCode);
582 }
583 }
584
Zoltan Szatmary-Ban7a2ccf22014-09-18 10:26:11 +0100585 public static void startWithFragmentAsUser(Context context, String fragmentName, Bundle args,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800586 int titleResId, CharSequence title, boolean isShortcut, int metricsCategory,
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100587 UserHandle userHandle) {
Victor Chang16da2aa2016-03-11 19:44:56 +0000588 // workaround to avoid crash in b/17523189
589 if (userHandle.getIdentifier() == UserHandle.myUserId()) {
Fan Zhangc6ca3142017-02-14 15:02:35 -0800590 startWithFragment(context, fragmentName, args, null, 0, titleResId, title, isShortcut,
591 metricsCategory);
Victor Chang16da2aa2016-03-11 19:44:56 +0000592 } else {
593 Intent intent = onBuildStartFragmentIntent(context, fragmentName, args,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800594 null /* titleResPackageName */, titleResId, title, isShortcut, metricsCategory);
Victor Chang16da2aa2016-03-11 19:44:56 +0000595 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
596 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
597 context.startActivityAsUser(intent, userHandle);
598 }
Zoltan Szatmary-Ban7a2ccf22014-09-18 10:26:11 +0100599 }
600
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700601 /**
602 * Build an Intent to launch a new activity showing the selected fragment.
603 * The implementation constructs an Intent that re-launches the current activity with the
604 * appropriate arguments to display the fragment.
605 *
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700606 *
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700607 * @param context The Context.
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000608 * @param fragmentName The name of the fragment to display.
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700609 * @param args Optional arguments to supply to the fragment.
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100610 * @param titleResPackageName Optional package name for the resource id of the title.
Fabrice Di Meglioa9e77992014-06-09 12:52:24 -0700611 * @param titleResId Optional title resource id to show for this item.
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700612 * @param title Optional title to show for this item.
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700613 * @param isShortcut tell if this is a Launcher Shortcut or not
Fan Zhangc6ca3142017-02-14 15:02:35 -0800614 * @param sourceMetricsCategory The context (source) from which an action is performed
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700615 * @return Returns an Intent that can be launched to display the given
616 * fragment.
617 */
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000618 public static Intent onBuildStartFragmentIntent(Context context, String fragmentName,
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100619 Bundle args, String titleResPackageName, int titleResId, CharSequence title,
Fan Zhangc6ca3142017-02-14 15:02:35 -0800620 boolean isShortcut, int sourceMetricsCategory) {
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700621 Intent intent = new Intent(Intent.ACTION_MAIN);
622 intent.setClass(context, SubSettings.class);
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000623 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT, fragmentName);
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700624 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS, args);
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100625 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RES_PACKAGE_NAME,
626 titleResPackageName);
Fabrice Di Meglioa9e77992014-06-09 12:52:24 -0700627 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RESID, titleResId);
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700628 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE, title);
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700629 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_AS_SHORTCUT, isShortcut);
Fan Zhangc6ca3142017-02-14 15:02:35 -0800630 intent.putExtra(SettingsActivity.EXTRA_SOURCE_METRICS_CATEGORY, sourceMetricsCategory);
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700631 return intent;
632 }
Alexandra Gherghina3939cd72014-06-04 10:02:55 +0100633
634 /**
Esteban Talavera9b86e9c2017-05-30 16:48:08 +0100635 * Returns the managed profile of the current user or {@code null} if none is found or a profile
636 * exists but it is disabled.
Alexandra Gherghina3939cd72014-06-04 10:02:55 +0100637 */
638 public static UserHandle getManagedProfile(UserManager userManager) {
639 List<UserHandle> userProfiles = userManager.getUserProfiles();
640 final int count = userProfiles.size();
641 for (int i = 0; i < count; i++) {
642 final UserHandle profile = userProfiles.get(i);
643 if (profile.getIdentifier() == userManager.getUserHandle()) {
644 continue;
645 }
646 final UserInfo userInfo = userManager.getUserInfo(profile.getIdentifier());
647 if (userInfo.isManagedProfile()) {
648 return profile;
649 }
650 }
651 return null;
652 }
653
654 /**
Esteban Talavera9b86e9c2017-05-30 16:48:08 +0100655 * Returns the managed profile of the current user or {@code null} if none is found. Unlike
656 * {@link #getManagedProfile} this method returns enabled and disabled managed profiles.
657 */
658 public static UserHandle getManagedProfileWithDisabled(UserManager userManager) {
659 // TODO: Call getManagedProfileId from here once Robolectric supports
660 // API level 24 and UserManager.getProfileIdsWithDisabled can be Mocked (to avoid having
661 // yet another implementation that loops over user profiles in this method). In the meantime
662 // we need to use UserManager.getProfiles that is available on API 23 (the one currently
663 // used for Settings Robolectric tests).
664 final int myUserId = UserHandle.myUserId();
665 List<UserInfo> profiles = userManager.getProfiles(myUserId);
666 final int count = profiles.size();
667 for (int i = 0; i < count; i++) {
668 final UserInfo profile = profiles.get(i);
669 if (profile.isManagedProfile()
670 && profile.getUserHandle().getIdentifier() != myUserId) {
671 return profile.getUserHandle();
672 }
673 }
674 return null;
675 }
676
677 /**
Clara Bayarri462cce12016-02-18 12:09:21 +0000678 * Retrieves the id for the given user's managed profile.
679 *
680 * @return the managed profile id or UserHandle.USER_NULL if there is none.
681 */
682 public static int getManagedProfileId(UserManager um, int parentUserId) {
Fyodor Kupolov4a4af5a2016-04-07 16:46:18 -0700683 int[] profileIds = um.getProfileIdsWithDisabled(parentUserId);
684 for (int profileId : profileIds) {
685 if (profileId != parentUserId) {
686 return profileId;
Clara Bayarri462cce12016-02-18 12:09:21 +0000687 }
688 }
689 return UserHandle.USER_NULL;
690 }
691
692 /**
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100693 * Returns the target user for a Settings activity.
Tony Mak8f41b9b2016-11-23 11:36:18 +0000694 * <p>
695 * User would be retrieved in this order:
696 * <ul>
697 * <li> If this activity is launched from other user, return that user id.
698 * <li> If this is launched from the Settings app in same user, return the user contained as an
699 * extra in the arguments or intent extras.
700 * <li> Otherwise, return UserHandle.myUserId().
701 * </ul>
702 * <p>
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100703 * Note: This is secure in the sense that it only returns a target user different to the current
704 * one if the app launching this activity is the Settings app itself, running in the same user
705 * 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 +0100706 */
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100707 public static UserHandle getSecureTargetUser(IBinder activityToken,
Tony Mak8f41b9b2016-11-23 11:36:18 +0000708 UserManager um, @Nullable Bundle arguments, @Nullable Bundle intentExtras) {
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100709 UserHandle currentUser = new UserHandle(UserHandle.myUserId());
Sudheer Shankaacb1a612016-11-10 15:30:14 -0800710 IActivityManager am = ActivityManager.getService();
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100711 try {
712 String launchedFromPackage = am.getLaunchedFromPackage(activityToken);
713 boolean launchedFromSettingsApp = SETTINGS_PACKAGE_NAME.equals(launchedFromPackage);
714
715 UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId(
716 am.getLaunchedFromUid(activityToken)));
717 if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) {
718 // Check it's secure
719 if (isProfileOf(um, launchedFromUser)) {
720 return launchedFromUser;
721 }
722 }
Tony Mak8f41b9b2016-11-23 11:36:18 +0000723 UserHandle extrasUser = getUserHandleFromBundle(intentExtras);
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100724 if (extrasUser != null && !extrasUser.equals(currentUser)) {
725 // Check it's secure
726 if (launchedFromSettingsApp && isProfileOf(um, extrasUser)) {
727 return extrasUser;
728 }
729 }
Tony Mak8f41b9b2016-11-23 11:36:18 +0000730 UserHandle argumentsUser = getUserHandleFromBundle(arguments);
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100731 if (argumentsUser != null && !argumentsUser.equals(currentUser)) {
732 // Check it's secure
733 if (launchedFromSettingsApp && isProfileOf(um, argumentsUser)) {
734 return argumentsUser;
735 }
736 }
737 } catch (RemoteException e) {
738 // Should not happen
739 Log.v(TAG, "Could not talk to activity manager.", e);
740 }
741 return currentUser;
Tony Mak8f41b9b2016-11-23 11:36:18 +0000742 }
743
744 /**
745 * Lookup both {@link Intent#EXTRA_USER} and {@link Intent#EXTRA_USER_ID} in the bundle
746 * and return the {@link UserHandle} object. Return {@code null} if nothing is found.
747 */
748 private static @Nullable UserHandle getUserHandleFromBundle(Bundle bundle) {
749 if (bundle == null) {
750 return null;
751 }
752 final UserHandle user = bundle.getParcelable(EXTRA_USER);
753 if (user != null) {
754 return user;
755 }
756 final int userId = bundle.getInt(EXTRA_USER_ID, -1);
757 if (userId != -1) {
758 return UserHandle.of(userId);
759 }
760 return null;
761 }
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100762
763 /**
764 * Returns the target user for a Settings activity.
765 *
766 * The target user can be either the current user, the user that launched this activity or
767 * the user contained as an extra in the arguments or intent extras.
768 *
769 * You should use {@link #getSecureTargetUser(IBinder, UserManager, Bundle, Bundle)} if
770 * possible.
771 *
772 * @see #getInsecureTargetUser(IBinder, Bundle, Bundle)
773 */
774 public static UserHandle getInsecureTargetUser(IBinder activityToken, @Nullable Bundle arguments,
775 @Nullable Bundle intentExtras) {
776 UserHandle currentUser = new UserHandle(UserHandle.myUserId());
Sudheer Shankaacb1a612016-11-10 15:30:14 -0800777 IActivityManager am = ActivityManager.getService();
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100778 try {
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100779 UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId(
780 am.getLaunchedFromUid(activityToken)));
781 if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) {
782 return launchedFromUser;
783 }
784 UserHandle extrasUser = intentExtras != null
785 ? (UserHandle) intentExtras.getParcelable(EXTRA_USER) : null;
786 if (extrasUser != null && !extrasUser.equals(currentUser)) {
787 return extrasUser;
788 }
789 UserHandle argumentsUser = arguments != null
790 ? (UserHandle) arguments.getParcelable(EXTRA_USER) : null;
791 if (argumentsUser != null && !argumentsUser.equals(currentUser)) {
792 return argumentsUser;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100793 }
794 } catch (RemoteException e) {
795 // Should not happen
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100796 Log.v(TAG, "Could not talk to activity manager.", e);
797 return null;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100798 }
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100799 return currentUser;
800 }
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100801
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100802 /**
803 * Returns true if the user provided is in the same profiles group as the current user.
804 */
805 private static boolean isProfileOf(UserManager um, UserHandle otherUser) {
806 if (um == null || otherUser == null) return false;
807 return (UserHandle.myUserId() == otherUser.getIdentifier())
808 || um.getUserProfiles().contains(otherUser);
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100809 }
Amith Yamasani51c6dac2014-07-02 00:06:37 +0530810
Alexandra Gherghina95b86a52014-07-24 19:13:25 +0100811 /**
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700812 * Return whether or not the user should have a SIM Cards option in Settings.
813 * TODO: Change back to returning true if count is greater than one after testing.
814 * TODO: See bug 16533525.
815 */
816 public static boolean showSimCardTile(Context context) {
817 final TelephonyManager tm =
818 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
819
PauloftheWestdbd03822014-12-04 11:56:35 -0800820 return tm.getSimCount() > 1;
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700821 }
Dan Sandlerb58b5122014-09-02 18:31:49 +0200822
823 /**
Elliott Hughes7253df32014-09-02 17:10:14 -0700824 * Returns elapsed time for the given millis, in the following format:
825 * 2d 5h 40m 29s
826 * @param context the application context
827 * @param millis the elapsed time in milli seconds
828 * @param withSeconds include seconds?
829 * @return the formatted elapsed time
830 */
jackqdyuleif4c1cef2017-03-31 12:57:10 -0700831 public static CharSequence formatElapsedTime(Context context, double millis,
832 boolean withSeconds) {
833 SpannableStringBuilder sb = new SpannableStringBuilder();
Elliott Hughes7253df32014-09-02 17:10:14 -0700834 int seconds = (int) Math.floor(millis / 1000);
835 if (!withSeconds) {
836 // Round up.
837 seconds += 30;
838 }
839
840 int days = 0, hours = 0, minutes = 0;
841 if (seconds >= SECONDS_PER_DAY) {
842 days = seconds / SECONDS_PER_DAY;
843 seconds -= days * SECONDS_PER_DAY;
844 }
845 if (seconds >= SECONDS_PER_HOUR) {
846 hours = seconds / SECONDS_PER_HOUR;
847 seconds -= hours * SECONDS_PER_HOUR;
848 }
849 if (seconds >= SECONDS_PER_MINUTE) {
850 minutes = seconds / SECONDS_PER_MINUTE;
851 seconds -= minutes * SECONDS_PER_MINUTE;
852 }
jackqdyuleif4c1cef2017-03-31 12:57:10 -0700853
Roozbeh Pournader15872242017-06-20 16:46:49 -0700854 final ArrayList<Measure> measureList = new ArrayList(4);
855 if (days > 0) {
856 measureList.add(new Measure(days, MeasureUnit.DAY));
857 }
858 if (hours > 0) {
859 measureList.add(new Measure(hours, MeasureUnit.HOUR));
860 }
861 if (minutes > 0) {
862 measureList.add(new Measure(minutes, MeasureUnit.MINUTE));
863 }
864 if (withSeconds && seconds > 0) {
865 measureList.add(new Measure(seconds, MeasureUnit.SECOND));
866 }
867 if (measureList.size() == 0) {
868 // Everything addable was zero, so nothing was added. We add a zero.
869 measureList.add(new Measure(0, withSeconds ? MeasureUnit.SECOND : MeasureUnit.MINUTE));
870 }
871 final Measure[] measureArray = measureList.toArray(new Measure[measureList.size()]);
872
873 final Locale locale = context.getResources().getConfiguration().locale;
874 final MeasureFormat measureFormat = MeasureFormat.getInstance(
875 locale, MeasureFormat.FormatWidth.NARROW);
876 sb.append(measureFormat.formatMeasures(measureArray));
877
878 if (measureArray.length == 1 && MeasureUnit.MINUTE.equals(measureArray[0].getUnit())) {
879 // Add ttsSpan if it only have minute value, because it will be read as "meters"
880 final TtsSpan ttsSpan = new TtsSpan.MeasureBuilder().setNumber(minutes)
881 .setUnit("minute").build();
882 sb.setSpan(ttsSpan, 0, sb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
Elliott Hughes7253df32014-09-02 17:10:14 -0700883 }
jackqdyuleif4c1cef2017-03-31 12:57:10 -0700884
885 return sb;
Elliott Hughes7253df32014-09-02 17:10:14 -0700886 }
PauloftheWest0a0daca2014-11-06 15:02:58 -0800887
888 /**
Roozbeh Pournader4de9df22017-08-26 14:05:15 -0700889 * Returns relative time for the given millis in the past, in a short format such as "2 days
890 * ago", "5 hr. ago", "40 min. ago", or "29 sec. ago".
891 *
892 * <p>The unit is chosen to have good information value while only using one unit. So 27 hours
893 * and 50 minutes would be formatted as "28 hr. ago", while 50 hours would be formatted as
894 * "2 days ago".
895 *
896 * @param context the application context
897 * @param millis the elapsed time in milli seconds
898 * @param withSeconds include seconds?
899 * @return the formatted elapsed time
900 */
901 public static CharSequence formatRelativeTime(Context context, double millis,
902 boolean withSeconds) {
903 final int seconds = (int) Math.floor(millis / 1000);
904 final RelativeUnit unit;
905 final int value;
906 if (withSeconds && seconds < 2 * SECONDS_PER_MINUTE) {
907 unit = RelativeUnit.SECONDS;
908 value = seconds;
909 } else if (seconds < 2 * SECONDS_PER_HOUR) {
910 unit = RelativeUnit.MINUTES;
911 value = (seconds + SECONDS_PER_MINUTE / 2) / SECONDS_PER_MINUTE;
912 } else if (seconds < 2 * SECONDS_PER_DAY) {
913 unit = RelativeUnit.HOURS;
914 value = (seconds + SECONDS_PER_HOUR / 2) / SECONDS_PER_HOUR;
915 } else {
916 unit = RelativeUnit.DAYS;
917 value = (seconds + SECONDS_PER_DAY / 2) / SECONDS_PER_DAY;
918 }
919
920 final Locale locale = context.getResources().getConfiguration().locale;
921 final RelativeDateTimeFormatter formatter = RelativeDateTimeFormatter.getInstance(
922 ULocale.forLocale(locale),
923 null /* default NumberFormat */,
924 RelativeDateTimeFormatter.Style.SHORT,
925 android.icu.text.DisplayContext.CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE);
926
927 return formatter.format(value, RelativeDateTimeFormatter.Direction.LAST, unit);
928 }
929
930 /**
Amith Yamasani45f86232014-11-19 17:12:46 -0800931 * Queries for the UserInfo of a user. Returns null if the user doesn't exist (was removed).
932 * @param userManager Instance of UserManager
933 * @param checkUser The user to check the existence of.
934 * @return UserInfo of the user or null for non-existent user.
935 */
936 public static UserInfo getExistingUser(UserManager userManager, UserHandle checkUser) {
937 final List<UserInfo> users = userManager.getUsers(true /* excludeDying */);
938 final int checkUserId = checkUser.getIdentifier();
939 for (UserInfo user : users) {
940 if (user.id == checkUserId) {
941 return user;
942 }
943 }
944 return null;
945 }
946
Zoltan Szatmary-Ban3af2e4c2014-12-19 17:17:23 +0000947 public static View inflateCategoryHeader(LayoutInflater inflater, ViewGroup parent) {
948 final TypedArray a = inflater.getContext().obtainStyledAttributes(null,
949 com.android.internal.R.styleable.Preference,
950 com.android.internal.R.attr.preferenceCategoryStyle, 0);
951 final int resId = a.getResourceId(com.android.internal.R.styleable.Preference_layout,
952 0);
953 a.recycle();
954 return inflater.inflate(resId, parent, false);
955 }
956
Fabrice Di Megliodff3faa2015-02-27 11:14:11 -0800957 /**
958 * Return if we are running low on storage space or not.
959 *
960 * @param context The context
961 * @return true if we are running low on storage space
962 */
963 public static boolean isLowStorage(Context context) {
964 final StorageManager sm = StorageManager.from(context);
965 return (sm.getStorageBytesUntilLow(context.getFilesDir()) < 0);
966 }
967
Zoltan Szatmary-Bane5814ff2014-12-19 16:27:45 +0000968 /**
969 * Returns a default user icon (as a {@link Bitmap}) for the given user.
970 *
971 * Note that for guest users, you should pass in {@code UserHandle.USER_NULL}.
972 * @param userId the user id or {@code UserHandle.USER_NULL} for a non-user specific icon
973 */
974 public static Bitmap getDefaultUserIconAsBitmap(int userId) {
975 Bitmap bitmap = null;
976 // Try finding the corresponding bitmap in the dark bitmap cache
977 bitmap = sDarkDefaultUserBitmapCache.get(userId);
978 if (bitmap == null) {
979 bitmap = UserIcons.convertToBitmap(UserIcons.getDefaultUserIcon(userId, false));
980 // Save it to cache
981 sDarkDefaultUserBitmapCache.put(userId, bitmap);
982 }
983 return bitmap;
984 }
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -0800985
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -0800986 public static boolean hasPreferredActivities(PackageManager pm, String packageName) {
987 // Get list of preferred activities
988 List<ComponentName> prefActList = new ArrayList<>();
989 // Intent list cannot be null. so pass empty list
990 List<IntentFilter> intentList = new ArrayList<>();
991 pm.getPreferredActivities(intentList, prefActList, packageName);
992 Log.d(TAG, "Have " + prefActList.size() + " number of activities in preferred list");
993 return prefActList.size() > 0;
994 }
995
Christopher Tatea08a2252015-07-01 16:52:43 -0700996 public static ArraySet<String> getHandledDomains(PackageManager pm, String packageName) {
997 List<IntentFilterVerificationInfo> iviList = pm.getIntentFilterVerifications(packageName);
998 List<IntentFilter> filters = pm.getAllIntentFilters(packageName);
999
1000 ArraySet<String> result = new ArraySet<>();
1001 if (iviList.size() > 0) {
1002 for (IntentFilterVerificationInfo ivi : iviList) {
1003 for (String host : ivi.getDomains()) {
1004 result.add(host);
1005 }
1006 }
1007 }
1008 if (filters != null && filters.size() > 0) {
1009 for (IntentFilter filter : filters) {
Christopher Tateddaa1422015-07-16 16:00:49 -07001010 if (filter.hasCategory(Intent.CATEGORY_BROWSABLE)
1011 && (filter.hasDataScheme(IntentFilter.SCHEME_HTTP) ||
1012 filter.hasDataScheme(IntentFilter.SCHEME_HTTPS))) {
Christopher Tatea08a2252015-07-01 16:52:43 -07001013 result.addAll(filter.getHostsList());
1014 }
1015 }
1016 }
1017 return result;
1018 }
1019
Sudheer Shankabc956302015-04-09 12:19:53 +01001020 /**
1021 * Returns the application info of the currently installed MDM package.
1022 */
1023 public static ApplicationInfo getAdminApplicationInfo(Context context, int profileId) {
1024 DevicePolicyManager dpm =
1025 (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);
1026 ComponentName mdmPackage = dpm.getProfileOwnerAsUser(profileId);
1027 if (mdmPackage == null) {
1028 return null;
1029 }
1030 String mdmPackageName = mdmPackage.getPackageName();
1031 try {
1032 IPackageManager ipm = AppGlobals.getPackageManager();
1033 ApplicationInfo mdmApplicationInfo =
1034 ipm.getApplicationInfo(mdmPackageName, 0, profileId);
1035 return mdmApplicationInfo;
1036 } catch (RemoteException e) {
1037 Log.e(TAG, "Error while retrieving application info for package " + mdmPackageName
1038 + ", userId " + profileId, e);
1039 return null;
1040 }
1041 }
Jason Monkb45e27b2015-05-20 13:35:43 -04001042
1043 public static boolean isBandwidthControlEnabled() {
1044 final INetworkManagementService netManager = INetworkManagementService.Stub
1045 .asInterface(ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE));
1046 try {
1047 return netManager.isBandwidthControlEnabled();
1048 } catch (RemoteException e) {
1049 return false;
1050 }
1051 }
Julia Reynoldsce25af42015-07-08 16:56:31 -04001052
1053 /**
1054 * Returns an accessible SpannableString.
1055 * @param displayText the text to display
1056 * @param accessibileText the text text-to-speech engines should read
1057 */
1058 public static SpannableString createAccessibleSequence(CharSequence displayText,
1059 String accessibileText) {
1060 SpannableString str = new SpannableString(displayText);
1061 str.setSpan(new TtsSpan.TextBuilder(accessibileText).build(), 0,
1062 displayText.length(),
1063 Spannable.SPAN_INCLUSIVE_INCLUSIVE);
1064 return str;
1065 }
Andres Morales7bdffd82015-08-04 16:55:00 -07001066
Clara Bayarrife432e82015-10-12 12:07:02 +01001067 /**
Benjamin Franz194300d2016-01-13 12:16:25 +00001068 * Returns the user id present in the bundle with {@link Intent#EXTRA_USER_ID} if it
Clara Bayarrife432e82015-10-12 12:07:02 +01001069 * belongs to the current user.
1070 *
1071 * @throws SecurityException if the given userId does not belong to the current user group.
1072 */
Benjamin Franz194300d2016-01-13 12:16:25 +00001073 public static int getUserIdFromBundle(Context context, Bundle bundle) {
Clara Bayarrife432e82015-10-12 12:07:02 +01001074 if (bundle == null) {
Benjamin Franz194300d2016-01-13 12:16:25 +00001075 return getCredentialOwnerUserId(context);
Clara Bayarrife432e82015-10-12 12:07:02 +01001076 }
Clara Bayarri6934a042015-10-14 11:07:35 +01001077 int userId = bundle.getInt(Intent.EXTRA_USER_ID, UserHandle.myUserId());
Adrian Roos5a9a3cd2017-03-30 18:02:25 -07001078 if (userId == LockPatternUtils.USER_FRP) {
1079 return enforceSystemUser(context, userId);
1080 } else {
1081 return enforceSameOwner(context, userId);
1082 }
1083 }
1084
1085 /**
1086 * Returns the given user id if the current user is the system user.
1087 *
1088 * @throws SecurityException if the current user is not the system user.
1089 */
1090 public static int enforceSystemUser(Context context, int userId) {
1091 if (UserHandle.myUserId() == UserHandle.USER_SYSTEM) {
1092 return userId;
1093 }
1094 throw new SecurityException("Given user id " + userId + " must only be used from "
1095 + "USER_SYSTEM, but current user is " + UserHandle.myUserId());
Clara Bayarrife432e82015-10-12 12:07:02 +01001096 }
1097
1098 /**
1099 * Returns the given user id if it belongs to the current user.
1100 *
1101 * @throws SecurityException if the given userId does not belong to the current user group.
1102 */
Benjamin Franz194300d2016-01-13 12:16:25 +00001103 public static int enforceSameOwner(Context context, int userId) {
Ricky Wai72500162016-06-07 16:54:25 +01001104 final UserManager um = getUserManager(context);
1105 final int[] profileIds = um.getProfileIdsWithDisabled(UserHandle.myUserId());
1106 if (ArrayUtils.contains(profileIds, userId)) {
1107 return userId;
Clara Bayarrife432e82015-10-12 12:07:02 +01001108 }
Ricky Wai72500162016-06-07 16:54:25 +01001109 throw new SecurityException("Given user id " + userId + " does not belong to user "
1110 + UserHandle.myUserId());
Clara Bayarrife432e82015-10-12 12:07:02 +01001111 }
1112
Benjamin Franz194300d2016-01-13 12:16:25 +00001113 /**
1114 * Returns the effective credential owner of the calling user.
1115 */
1116 public static int getCredentialOwnerUserId(Context context) {
1117 return getCredentialOwnerUserId(context, UserHandle.myUserId());
1118 }
1119
1120 /**
1121 * Returns the user id of the credential owner of the given user id.
1122 */
1123 public static int getCredentialOwnerUserId(Context context, int userId) {
1124 UserManager um = getUserManager(context);
1125 return um.getCredentialOwnerProfile(userId);
Andres Morales7bdffd82015-08-04 16:55:00 -07001126 }
Jason Monkdb4ed192015-12-11 16:48:31 -05001127
1128 public static int resolveResource(Context context, int attr) {
1129 TypedValue value = new TypedValue();
1130 context.getTheme().resolveAttribute(attr, value, true);
1131 return value.resourceId;
1132 }
Jason Monkb37e2882016-01-11 14:27:20 -05001133
1134 private static final StringBuilder sBuilder = new StringBuilder(50);
1135 private static final java.util.Formatter sFormatter = new java.util.Formatter(
1136 sBuilder, Locale.getDefault());
1137
1138 public static String formatDateRange(Context context, long start, long end) {
1139 final int flags = FORMAT_SHOW_DATE | FORMAT_ABBREV_MONTH;
1140
1141 synchronized (sBuilder) {
1142 sBuilder.setLength(0);
1143 return DateUtils.formatDateRange(context, sFormatter, start, end, flags, null)
1144 .toString();
1145 }
1146 }
Jason Monk91e2f892016-02-23 15:31:09 -05001147
1148 public static List<String> getNonIndexable(int xml, Context context) {
Jason Monkbe941212016-05-27 12:58:53 -04001149 if (Looper.myLooper() == null) {
1150 // Hack to make sure Preferences can initialize. Prefs expect a looper, but
1151 // don't actually use it for the basic stuff here.
1152 Looper.prepare();
1153 }
Jason Monk9ee80cd2016-03-03 11:21:42 -05001154 final List<String> ret = new ArrayList<>();
Jason Monkbe941212016-05-27 12:58:53 -04001155 PreferenceManager manager = new PreferenceManager(context);
1156 PreferenceScreen screen = manager.inflateFromResource(context, xml, null);
1157 checkPrefs(screen, ret);
Jason Monk91e2f892016-02-23 15:31:09 -05001158
1159 return ret;
1160 }
1161
1162 private static void checkPrefs(PreferenceGroup group, List<String> ret) {
1163 if (group == null) return;
1164 for (int i = 0; i < group.getPreferenceCount(); i++) {
1165 Preference pref = group.getPreference(i);
1166 if (pref instanceof SelfAvailablePreference
1167 && !((SelfAvailablePreference) pref).isAvailable(group.getContext())) {
1168 ret.add(pref.getKey());
1169 if (pref instanceof PreferenceGroup) {
1170 addAll((PreferenceGroup) pref, ret);
1171 }
1172 } else if (pref instanceof PreferenceGroup) {
1173 checkPrefs((PreferenceGroup) pref, ret);
1174 }
1175 }
1176 }
1177
1178 private static void addAll(PreferenceGroup group, List<String> ret) {
1179 if (group == null) return;
1180 for (int i = 0; i < group.getPreferenceCount(); i++) {
1181 Preference pref = group.getPreference(i);
1182 ret.add(pref.getKey());
1183 if (pref instanceof PreferenceGroup) {
1184 addAll((PreferenceGroup) pref, ret);
1185 }
1186 }
1187 }
Udam Saini679f7ad2016-03-25 10:47:00 -07001188
1189 public static boolean isDeviceProvisioned(Context context) {
1190 return Settings.Global.getInt(context.getContentResolver(),
1191 Settings.Global.DEVICE_PROVISIONED, 0) != 0;
1192 }
Ricky Wai616342b2016-04-13 10:40:22 +01001193
Bernard Chau88d523b2016-04-14 15:08:28 +01001194 public static boolean startQuietModeDialogIfNecessary(Context context, UserManager um,
Ricky Wai616342b2016-04-13 10:40:22 +01001195 int userId) {
1196 if (um.isQuietModeEnabled(UserHandle.of(userId))) {
1197 final Intent intent = UnlaunchableAppActivity.createInQuietModeDialogIntent(userId);
1198 context.startActivity(intent);
1199 return true;
1200 }
1201 return false;
1202 }
Sudheer Shankac3eb16e2016-04-21 12:51:43 -07001203
Rubin Xu3231afe2016-08-24 10:15:07 +01001204 public static boolean unlockWorkProfileIfNecessary(Context context, int userId) {
1205 try {
Sudheer Shankaacb1a612016-11-10 15:30:14 -08001206 if (!ActivityManager.getService().isUserRunning(userId,
Rubin Xu3231afe2016-08-24 10:15:07 +01001207 ActivityManager.FLAG_AND_LOCKED)) {
1208 return false;
1209 }
1210 } catch (RemoteException e) {
1211 return false;
1212 }
1213 if (!(new LockPatternUtils(context)).isSecure(userId)) {
1214 return false;
1215 }
Robin Leecccf3242017-02-10 15:32:49 +00001216 return confirmWorkProfileCredentials(context, userId);
1217 }
1218
1219 public static boolean confirmWorkProfileCredentialsIfNecessary(Context context, int userId) {
1220 KeyguardManager km = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
1221 if (!km.isDeviceLocked(userId)) {
1222 return false;
1223 }
1224 return confirmWorkProfileCredentials(context, userId);
1225 }
1226
1227 private static boolean confirmWorkProfileCredentials(Context context, int userId) {
Rubin Xu3231afe2016-08-24 10:15:07 +01001228 final KeyguardManager km = (KeyguardManager) context.getSystemService(
1229 Context.KEYGUARD_SERVICE);
1230 final Intent unlockIntent = km.createConfirmDeviceCredentialIntent(null, null, userId);
1231 if (unlockIntent != null) {
1232 context.startActivity(unlockIntent);
1233 return true;
1234 } else {
1235 return false;
1236 }
Rubin Xu3231afe2016-08-24 10:15:07 +01001237 }
1238
Sudheer Shankac3eb16e2016-04-21 12:51:43 -07001239 public static CharSequence getApplicationLabel(Context context, String packageName) {
1240 try {
1241 final ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(
1242 packageName,
1243 PackageManager.MATCH_DISABLED_COMPONENTS
Amith Yamasani21556cd2016-11-01 15:49:21 -07001244 | PackageManager.MATCH_ANY_USER);
Sudheer Shankac3eb16e2016-04-21 12:51:43 -07001245 return appInfo.loadLabel(context.getPackageManager());
1246 } catch (PackageManager.NameNotFoundException e) {
1247 Log.w(TAG, "Unable to find info for package: " + packageName);
1248 }
1249 return null;
1250 }
Jason Monk75199542016-05-06 15:09:32 -04001251
Jeff Sharkey4a8136b2016-07-27 12:53:34 -06001252 public static boolean isPackageDirectBootAware(Context context, String packageName) {
1253 try {
1254 final ApplicationInfo ai = context.getPackageManager().getApplicationInfo(
1255 packageName, 0);
1256 return ai.isDirectBootAware() || ai.isPartiallyDirectBootAware();
1257 } catch (NameNotFoundException ignored) {
1258 }
1259 return false;
1260 }
Andre Lago3e398c82016-07-25 14:12:28 +01001261
1262 /**
1263 * Returns a context created from the given context for the given user, or null if it fails
1264 */
1265 public static Context createPackageContextAsUser(Context context, int userId) {
1266 try {
1267 return context.createPackageContextAsUser(
1268 context.getPackageName(), 0 /* flags */, UserHandle.of(userId));
1269 } catch (PackageManager.NameNotFoundException e) {
1270 Log.e(TAG, "Failed to create user context", e);
1271 }
1272 return null;
1273 }
Jeff Sharkeyab508072016-10-11 14:25:22 -06001274
1275 public static FingerprintManager getFingerprintManagerOrNull(Context context) {
1276 if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
1277 return context.getSystemService(FingerprintManager.class);
1278 } else {
1279 return null;
1280 }
1281 }
Daniel Nishi31027da2017-01-19 14:03:57 -08001282
Doris Lingdee1a222017-08-31 16:17:30 -07001283 public static FingerprintManagerWrapper getFingerprintManagerWrapperOrNull(Context context) {
Maurice Lame1976ac2017-05-08 21:43:02 -07001284 FingerprintManager fingerprintManager = getFingerprintManagerOrNull(context);
1285 if (fingerprintManager != null) {
1286 return new FingerprintManagerWrapper(fingerprintManager);
1287 } else {
1288 return null;
1289 }
1290 }
1291
Kevin Chyn82792cc2017-07-20 00:15:44 -07001292 public static boolean hasFingerprintHardware(Context context) {
1293 FingerprintManager fingerprintManager = getFingerprintManagerOrNull(context);
1294 return fingerprintManager != null && fingerprintManager.isHardwareDetected();
1295 }
1296
Daniel Nishi31027da2017-01-19 14:03:57 -08001297 /**
1298 * Launches an intent which may optionally have a user id defined.
1299 * @param fragment Fragment to use to launch the activity.
1300 * @param intent Intent to launch.
1301 */
1302 public static void launchIntent(Fragment fragment, Intent intent) {
1303 try {
1304 final int userId = intent.getIntExtra(Intent.EXTRA_USER_ID, -1);
1305
1306 if (userId == -1) {
1307 fragment.startActivity(intent);
1308 } else {
1309 fragment.getActivity().startActivityAsUser(intent, new UserHandle(userId));
1310 }
1311 } catch (ActivityNotFoundException e) {
1312 Log.w(TAG, "No activity found for " + intent);
1313 }
1314 }
1315
Christine Franksc6890ab2017-06-23 14:28:21 -07001316 public static boolean isDemoUser(Context context) {
1317 return UserManager.isDeviceInDemoMode(context) && getUserManager(context).isDemoUser();
1318 }
1319
Justin Klaassen30257272017-08-08 21:58:05 -07001320 public static ComponentName getDeviceOwnerComponent(Context context) {
1321 final DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService(
1322 Context.DEVICE_POLICY_SERVICE);
1323 return dpm.getDeviceOwnerComponentOnAnyUser();
Christine Franks14782222017-01-23 16:44:02 -08001324 }
Daniel Nishidfed8a22017-01-19 16:32:41 -08001325
1326 /**
1327 * Returns if a given user is a profile of another user.
Christine Franksa0dd9872017-07-11 17:32:57 -07001328 * @param user The user whose profiles wibe checked.
Daniel Nishidfed8a22017-01-19 16:32:41 -08001329 * @param profile The (potential) profile.
1330 * @return if the profile is actually a profile
1331 */
1332 public static boolean isProfileOf(UserInfo user, UserInfo profile) {
1333 return user.id == profile.id ||
1334 (user.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID
1335 && user.profileGroupId == profile.profileGroupId);
1336 }
Daniel Nishi9f60f422017-02-15 15:25:48 -08001337
1338 /**
1339 * Tries to initalize a volume with the given bundle. If it is a valid, private, and readable
1340 * {@link VolumeInfo}, it is returned. If it is not valid, null is returned.
1341 */
1342 @Nullable
1343 public static VolumeInfo maybeInitializeVolume(StorageManager sm, Bundle bundle) {
1344 final String volumeId = bundle.getString(VolumeInfo.EXTRA_VOLUME_ID,
1345 VolumeInfo.ID_PRIVATE_INTERNAL);
1346 VolumeInfo volume = sm.findVolumeById(volumeId);
1347 return isVolumeValid(volume) ? volume : null;
1348 }
1349
jackqdyuleiddba9662017-03-08 19:35:02 -08001350 /**
jackqdyulei00015fb2017-08-22 11:25:30 -07001351 * Return {@code true} if the supplied package is device owner or profile owner of at
1352 * least one user.
1353 * @param userManager used to get profile owner app for each user
1354 * @param devicePolicyManager used to check whether it is device owner app
1355 * @param packageName package to check about
1356 */
1357 public static boolean isProfileOrDeviceOwner(UserManager userManager,
1358 DevicePolicyManagerWrapper devicePolicyManager, String packageName) {
1359 List<UserInfo> userInfos = userManager.getUsers();
1360 if (devicePolicyManager.isDeviceOwnerAppOnAnyUser(packageName)) {
1361 return true;
1362 }
1363 for (int i = 0, size = userInfos.size(); i < size; i++) {
1364 ComponentName cn = devicePolicyManager.getProfileOwnerAsUser(userInfos.get(i).id);
1365 if (cn != null && cn.getPackageName().equals(packageName)) {
1366 return true;
1367 }
1368 }
1369 return false;
1370 }
1371
1372 /**
jackqdyuleiddba9662017-03-08 19:35:02 -08001373 * Return the resource id to represent the install status for an app
1374 */
1375 @StringRes
1376 public static int getInstallationStatus(ApplicationInfo info) {
1377 if ((info.flags & ApplicationInfo.FLAG_INSTALLED) == 0) {
1378 return R.string.not_installed;
1379 }
1380 return info.enabled ? R.string.installed : R.string.disabled;
1381 }
1382
Daniel Nishi9f60f422017-02-15 15:25:48 -08001383 private static boolean isVolumeValid(VolumeInfo volume) {
1384 return (volume != null) && (volume.getType() == VolumeInfo.TYPE_PRIVATE)
1385 && volume.isMountedReadable();
1386 }
jackqdyuleif4c1cef2017-03-31 12:57:10 -07001387
PMS2263a05602017-06-14 07:10:15 +00001388 public static void setEditTextCursorPosition(EditText editText) {
1389 editText.setSelection(editText.getText().length());
1390 }
Felipe Lemebd884502017-09-15 18:16:21 -07001391
1392 /**
1393 * Sets the preference icon with a drawable that is scaled down to to avoid crashing Settings if
1394 * it's too big.
1395 */
1396 public static void setSafeIcon(Preference pref, Drawable icon) {
1397 Drawable safeIcon = icon;
1398 if (icon != null) {
1399 safeIcon = getSafeDrawable(icon, 500, 500);
1400 }
1401 pref.setIcon(safeIcon);
1402 }
1403
1404 /**
1405 * Gets a drawable with a limited size to avoid crashing Settings if it's too big.
1406 *
1407 * @param original original drawable, typically an app icon.
1408 * @param maxWidth maximum width, in pixels.
1409 * @param maxHeight maximum height, in pixels.
1410 */
1411 public static Drawable getSafeDrawable(Drawable original, int maxWidth, int maxHeight) {
1412 final int actualWidth = original.getMinimumWidth();
1413 final int actualHeight = original.getMinimumHeight();
1414
1415 if (actualWidth <= maxWidth && actualHeight <= maxHeight) {
1416 return original;
1417 }
1418
1419 float scaleWidth = ((float) maxWidth) / actualWidth;
1420 float scaleHeight = ((float) maxHeight) / actualHeight;
1421 float scale = Math.min(scaleWidth, scaleHeight);
1422 final int width = (int) (actualWidth * scale);
1423 final int height = (int) (actualHeight * scale);
1424
1425 final Bitmap bitmap;
1426 if (original instanceof BitmapDrawable) {
1427 bitmap = Bitmap.createScaledBitmap(((BitmapDrawable) original).getBitmap(), width,
1428 height, false);
1429 } else {
1430 bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
1431 final Canvas canvas = new Canvas(bitmap);
1432 original.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
1433 original.draw(canvas);
1434 }
1435 return new BitmapDrawable(null, bitmap);
1436 }
Jeff Sharkey4a8136b2016-07-27 12:53:34 -06001437}