blob: 434b52969854246da9dc81b5af818ed182a62e92 [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
Benjamin Franz194300d2016-01-13 12:16:25 +000019import android.annotation.NonNull;
Alexandra Gherghina7d748c02014-06-27 12:33:42 +010020import android.annotation.Nullable;
Amith Yamasaniae697552011-09-27 11:33:17 -070021import android.app.ActivityManager;
Alexandra Gherghina7d748c02014-06-27 12:33:42 +010022import android.app.ActivityManagerNative;
Amith Yamasani9627a8e2012-09-23 12:54:14 -070023import android.app.AlertDialog;
Sudheer Shankabc956302015-04-09 12:19:53 +010024import android.app.AppGlobals;
Amith Yamasani9627a8e2012-09-23 12:54:14 -070025import android.app.Dialog;
Fabrice Di Meglio769630c2014-04-24 14:48:48 -070026import android.app.Fragment;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010027import android.app.IActivityManager;
Sudheer Shankabc956302015-04-09 12:19:53 +010028import android.app.admin.DevicePolicyManager;
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -080029import android.content.ComponentName;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070030import android.content.ContentResolver;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080031import android.content.Context;
Amith Yamasani9627a8e2012-09-23 12:54:14 -070032import android.content.DialogInterface;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080033import android.content.Intent;
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -080034import android.content.IntentFilter;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080035import android.content.pm.ApplicationInfo;
Sudheer Shankabc956302015-04-09 12:19:53 +010036import android.content.pm.IPackageManager;
Christopher Tatea08a2252015-07-01 16:52:43 -070037import android.content.pm.IntentFilterVerificationInfo;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -080038import android.content.pm.PackageManager;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070039import android.content.pm.ResolveInfo;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070040import android.content.pm.UserInfo;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020041import android.content.res.Resources;
Jason Monkb5aa73f2015-03-31 12:59:33 -040042import android.content.res.TypedArray;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070043import android.database.Cursor;
Amith Yamasanif34a85d2012-09-17 18:31:45 -070044import android.graphics.Bitmap;
45import android.graphics.BitmapFactory;
Amith Yamasanic06d4c42011-02-25 14:35:20 -080046import android.net.ConnectivityManager;
47import android.net.LinkProperties;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070048import android.net.Uri;
Amith Yamasania4379d62011-07-22 10:34:58 -070049import android.os.BatteryManager;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020050import android.os.Bundle;
Jason Monk9ee80cd2016-03-03 11:21:42 -050051import android.os.Handler;
52import android.os.HandlerThread;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010053import android.os.IBinder;
Jason Monkb45e27b2015-05-20 13:35:43 -040054import android.os.INetworkManagementService;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010055import android.os.RemoteException;
Jason Monkb45e27b2015-05-20 13:35:43 -040056import android.os.ServiceManager;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070057import android.os.UserHandle;
58import android.os.UserManager;
Fabrice Di Megliodff3faa2015-02-27 11:14:11 -080059import android.os.storage.StorageManager;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070060import android.preference.PreferenceFrameLayout;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070061import android.provider.ContactsContract.CommonDataKinds;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070062import android.provider.ContactsContract.Contacts;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070063import android.provider.ContactsContract.Data;
Amith Yamasaniae47ef42012-09-16 17:53:35 -070064import android.provider.ContactsContract.Profile;
Amith Yamasani8d40fac2012-10-23 15:36:16 -070065import android.provider.ContactsContract.RawContacts;
Udam Saini679f7ad2016-03-25 10:47:00 -070066import android.provider.Settings;
Andres Moralesce249fe2014-07-07 16:58:16 -070067import android.service.persistentdata.PersistentDataBlockManager;
Jason Monk39b46742015-09-10 15:52:51 -040068import android.support.v7.preference.Preference;
69import android.support.v7.preference.PreferenceGroup;
Jason Monk91e2f892016-02-23 15:31:09 -050070import android.support.v7.preference.PreferenceManager;
71import android.support.v7.preference.PreferenceScreen;
Amith Yamasani60133dd2010-09-11 14:17:31 -070072import android.telephony.TelephonyManager;
Julia Reynoldsce25af42015-07-08 16:56:31 -040073import android.text.Spannable;
74import android.text.SpannableString;
Anders Hammar1b2dd9032010-04-08 10:03:50 +020075import android.text.TextUtils;
Jason Monkb37e2882016-01-11 14:27:20 -050076import android.text.format.DateUtils;
Julia Reynoldsce25af42015-07-08 16:56:31 -040077import android.text.style.TtsSpan;
Christopher Tatea08a2252015-07-01 16:52:43 -070078import android.util.ArraySet;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +010079import android.util.Log;
Zoltan Szatmary-Bane5814ff2014-12-19 16:27:45 +000080import android.util.SparseArray;
Jason Monkdb4ed192015-12-11 16:48:31 -050081import android.util.TypedValue;
Zoltan Szatmary-Ban3af2e4c2014-12-19 17:17:23 +000082import android.view.LayoutInflater;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070083import android.view.View;
84import android.view.ViewGroup;
Jason Monkb5aa73f2015-03-31 12:59:33 -040085import android.view.animation.Animation;
86import android.view.animation.Animation.AnimationListener;
87import android.view.animation.AnimationUtils;
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -070088import android.widget.ListView;
89import android.widget.TabWidget;
Ricky Wai616342b2016-04-13 10:40:22 +010090
91import com.android.internal.app.UnlaunchableAppActivity;
Alexandra Gherghinabc6e78f2014-09-03 10:22:09 +010092import com.android.internal.util.UserIcons;
Daisuke Miyakawaa2633d02010-09-15 20:09:12 -070093
Amith Yamasaniae47ef42012-09-16 17:53:35 -070094import java.io.IOException;
95import java.io.InputStream;
Amith Yamasanic06d4c42011-02-25 14:35:20 -080096import java.net.InetAddress;
Alexandra Gherghina80e1f1b2014-07-31 14:56:33 +010097import java.util.ArrayList;
Amith Yamasanic06d4c42011-02-25 14:35:20 -080098import java.util.Iterator;
Daisuke Miyakawaa2633d02010-09-15 20:09:12 -070099import java.util.List;
Jean Chalard71ad1f42011-05-12 15:06:16 +0900100import java.util.Locale;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800101
Tony Mantler67cd6ab2015-06-08 14:41:02 -0700102import static android.content.Intent.EXTRA_USER;
Jason Monkb37e2882016-01-11 14:27:20 -0500103import static android.text.format.DateUtils.FORMAT_ABBREV_MONTH;
104import static android.text.format.DateUtils.FORMAT_SHOW_DATE;
Tony Mantler67cd6ab2015-06-08 14:41:02 -0700105
Jason Monk27985e12016-01-08 14:13:05 -0500106public final class Utils extends com.android.settingslib.Utils {
107
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100108 private static final String TAG = "Settings";
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100109
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800110 /**
111 * Set the preference's title to the matching activity's label.
112 */
113 public static final int UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY = 1;
114
115 /**
Shuhrat Dehkanov96577682012-10-03 12:24:07 +0900116 * The opacity level of a disabled icon.
117 */
118 public static final float DISABLED_ALPHA = 0.4f;
119
120 /**
Dianne Hackborn68f005f2014-06-18 18:29:12 -0700121 * Color spectrum to use to indicate badness. 0 is completely transparent (no data),
122 * 1 is most bad (red), the last value is least bad (green).
123 */
124 public static final int[] BADNESS_COLORS = new int[] {
125 0x00000000, 0xffc43828, 0xffe54918, 0xfff47b00,
126 0xfffabf2c, 0xff679e37, 0xff0a7f42
127 };
128
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100129 private static final String SETTINGS_PACKAGE_NAME = "com.android.settings";
130
Elliott Hughes7253df32014-09-02 17:10:14 -0700131 private static final int SECONDS_PER_MINUTE = 60;
132 private static final int SECONDS_PER_HOUR = 60 * 60;
133 private static final int SECONDS_PER_DAY = 24 * 60 * 60;
134
Jason Monkbeb171d2015-05-21 15:24:37 -0400135 public static final String OS_PKG = "os";
136
Zoltan Szatmary-Bane5814ff2014-12-19 16:27:45 +0000137 private static SparseArray<Bitmap> sDarkDefaultUserBitmapCache = new SparseArray<Bitmap>();
138
Anders Hammar1b2dd9032010-04-08 10:03:50 +0200139 /**
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800140 * Finds a matching activity for a preference's intent. If a matching
141 * activity is not found, it will remove the preference.
Ying Wanga7188322010-01-04 18:45:10 -0800142 *
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800143 * @param context The context.
144 * @param parentPreferenceGroup The preference group that contains the
145 * preference whose intent is being resolved.
146 * @param preferenceKey The key of the preference whose intent is being
147 * resolved.
148 * @param flags 0 or one or more of
149 * {@link #UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY}
150 * .
151 * @return Whether an activity was found. If false, the preference was
152 * removed.
153 */
154 public static boolean updatePreferenceToSpecificActivityOrRemove(Context context,
155 PreferenceGroup parentPreferenceGroup, String preferenceKey, int flags) {
Ying Wanga7188322010-01-04 18:45:10 -0800156
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800157 Preference preference = parentPreferenceGroup.findPreference(preferenceKey);
158 if (preference == null) {
159 return false;
160 }
Ying Wanga7188322010-01-04 18:45:10 -0800161
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800162 Intent intent = preference.getIntent();
163 if (intent != null) {
164 // Find the activity that is in the system image
165 PackageManager pm = context.getPackageManager();
166 List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
167 int listSize = list.size();
168 for (int i = 0; i < listSize; i++) {
169 ResolveInfo resolveInfo = list.get(i);
170 if ((resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
171 != 0) {
Ying Wanga7188322010-01-04 18:45:10 -0800172
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800173 // Replace the intent with this specific activity
174 preference.setIntent(new Intent().setClassName(
175 resolveInfo.activityInfo.packageName,
176 resolveInfo.activityInfo.name));
177
178 if ((flags & UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY) != 0) {
179 // Set the preference title to the activity's label
180 preference.setTitle(resolveInfo.loadLabel(pm));
181 }
Ying Wanga7188322010-01-04 18:45:10 -0800182
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800183 return true;
184 }
185 }
186 }
187
188 // Did not find a matching activity, so remove the preference
189 parentPreferenceGroup.removePreference(preference);
Ying Wanga7188322010-01-04 18:45:10 -0800190
Shuhrat Dehkanov7dc567a2012-04-23 01:59:56 +0900191 return false;
The Android Open Source Projectafc4ab22009-03-03 19:32:34 -0800192 }
Ying Wanga7188322010-01-04 18:45:10 -0800193
Anders Hammar1b2dd9032010-04-08 10:03:50 +0200194 /**
Benjamin Franz194300d2016-01-13 12:16:25 +0000195 * Returns the UserManager for a given context
196 *
197 * @throws IllegalStateException if no UserManager could be retrieved.
198 */
199 public static UserManager getUserManager(Context context) {
200 UserManager um = UserManager.get(context);
201 if (um == null) {
202 throw new IllegalStateException("Unable to load UserManager");
203 }
204 return um;
205 }
206
207 /**
Ying Wanga7188322010-01-04 18:45:10 -0800208 * Returns true if Monkey is running.
209 */
210 public static boolean isMonkeyRunning() {
Amith Yamasaniae697552011-09-27 11:33:17 -0700211 return ActivityManager.isUserAMonkey();
Ying Wanga7188322010-01-04 18:45:10 -0800212 }
Amith Yamasani60133dd2010-09-11 14:17:31 -0700213
214 /**
215 * Returns whether the device is voice-capable (meaning, it is also a phone).
216 */
217 public static boolean isVoiceCapable(Context context) {
218 TelephonyManager telephony =
219 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
220 return telephony != null && telephony.isVoiceCapable();
221 }
Amith Yamasani0f85c482011-02-23 17:19:11 -0800222
Robert Greenwalt8af88fb2011-08-31 11:17:47 -0700223 public static boolean isWifiOnly(Context context) {
224 ConnectivityManager cm = (ConnectivityManager)context.getSystemService(
225 Context.CONNECTIVITY_SERVICE);
226 return (cm.isNetworkSupported(ConnectivityManager.TYPE_MOBILE) == false);
Amith Yamasani0f85c482011-02-23 17:19:11 -0800227 }
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800228
229 /**
230 * Returns the WIFI IP Addresses, if any, taking into account IPv4 and IPv6 style addresses.
231 * @param context the application context
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900232 * @return the formatted and newline-separated IP addresses, or null if none.
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800233 */
234 public static String getWifiIpAddresses(Context context) {
235 ConnectivityManager cm = (ConnectivityManager)
236 context.getSystemService(Context.CONNECTIVITY_SERVICE);
237 LinkProperties prop = cm.getLinkProperties(ConnectivityManager.TYPE_WIFI);
Amith Yamasani6822b742011-10-17 16:41:00 -0700238 return formatIpAddresses(prop);
239 }
240
241 /**
242 * Returns the default link's IP addresses, if any, taking into account IPv4 and IPv6 style
243 * addresses.
244 * @param context the application context
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900245 * @return the formatted and newline-separated IP addresses, or null if none.
Amith Yamasani6822b742011-10-17 16:41:00 -0700246 */
Lorenzo Colitti6eb6a902013-11-08 03:53:29 +0900247 public static String getDefaultIpAddresses(ConnectivityManager cm) {
Amith Yamasani6822b742011-10-17 16:41:00 -0700248 LinkProperties prop = cm.getActiveLinkProperties();
249 return formatIpAddresses(prop);
250 }
251
252 private static String formatIpAddresses(LinkProperties prop) {
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800253 if (prop == null) return null;
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900254 Iterator<InetAddress> iter = prop.getAllAddresses().iterator();
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800255 // If there are no entries, return null
256 if (!iter.hasNext()) return null;
257 // Concatenate all available addresses, comma separated
258 String addresses = "";
259 while (iter.hasNext()) {
260 addresses += iter.next().getHostAddress();
Lorenzo Colitti769f0692013-08-01 17:30:07 +0900261 if (iter.hasNext()) addresses += "\n";
Amith Yamasanic06d4c42011-02-25 14:35:20 -0800262 }
263 return addresses;
264 }
Jean Chalard71ad1f42011-05-12 15:06:16 +0900265
266 public static Locale createLocaleFromString(String localeStr) {
267 // TODO: is there a better way to actually construct a locale that will match?
268 // The main problem is, on top of Java specs, locale.toString() and
269 // new Locale(locale.toString()).toString() do not return equal() strings in
270 // many cases, because the constructor takes the only string as the language
271 // code. So : new Locale("en", "US").toString() => "en_US"
272 // And : new Locale("en_US").toString() => "en_us"
273 if (null == localeStr)
274 return Locale.getDefault();
275 String[] brokenDownLocale = localeStr.split("_", 3);
276 // split may not return a 0-length array.
277 if (1 == brokenDownLocale.length) {
278 return new Locale(brokenDownLocale[0]);
279 } else if (2 == brokenDownLocale.length) {
280 return new Locale(brokenDownLocale[0], brokenDownLocale[1]);
281 } else {
282 return new Locale(brokenDownLocale[0], brokenDownLocale[1], brokenDownLocale[2]);
283 }
284 }
Amith Yamasania4379d62011-07-22 10:34:58 -0700285
Jaewan Kima3fe77b2013-06-04 21:17:40 +0900286 public static boolean isBatteryPresent(Intent batteryChangedIntent) {
287 return batteryChangedIntent.getBooleanExtra(BatteryManager.EXTRA_PRESENT, true);
288 }
289
Amith Yamasania4379d62011-07-22 10:34:58 -0700290 public static String getBatteryPercentage(Intent batteryChangedIntent) {
Elliott Hughes7253df32014-09-02 17:10:14 -0700291 return formatPercentage(getBatteryLevel(batteryChangedIntent));
Dianne Hackborn525f2bd2014-04-29 11:24:06 -0700292 }
293
Jeff Sharkey97d07fa2012-11-30 12:36:53 -0800294 public static void forcePrepareCustomPreferencesList(
295 ViewGroup parent, View child, ListView list, boolean ignoreSidePadding) {
296 list.setScrollBarStyle(View.SCROLLBARS_OUTSIDE_OVERLAY);
297 list.setClipToPadding(false);
298 prepareCustomPreferencesList(parent, child, list, ignoreSidePadding);
299 }
300
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700301 /**
302 * Prepare a custom preferences layout, moving padding to {@link ListView}
303 * when outside scrollbars are requested. Usually used to display
304 * {@link ListView} and {@link TabWidget} with correct padding.
305 */
Jeff Sharkey5d706792011-09-08 18:57:17 -0700306 public static void prepareCustomPreferencesList(
Jeff Sharkey97d07fa2012-11-30 12:36:53 -0800307 ViewGroup parent, View child, View list, boolean ignoreSidePadding) {
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700308 final boolean movePadding = list.getScrollBarStyle() == View.SCROLLBARS_OUTSIDE_OVERLAY;
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700309 if (movePadding) {
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700310 final Resources res = list.getResources();
Amith Yamasani56f51a82013-08-05 10:07:23 -0700311 final int paddingSide = res.getDimensionPixelSize(R.dimen.settings_side_margin);
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700312 final int paddingBottom = res.getDimensionPixelSize(
313 com.android.internal.R.dimen.preference_fragment_padding_bottom);
Jeff Sharkey5d706792011-09-08 18:57:17 -0700314
Fabrice Di Meglio97a18c82014-07-18 19:12:36 -0700315 if (parent instanceof PreferenceFrameLayout) {
316 ((PreferenceFrameLayout.LayoutParams) child.getLayoutParams()).removeBorders = true;
317
318 final int effectivePaddingSide = ignoreSidePadding ? 0 : paddingSide;
319 list.setPaddingRelative(effectivePaddingSide, 0, effectivePaddingSide, paddingBottom);
320 } else {
321 list.setPaddingRelative(paddingSide, 0, paddingSide, paddingBottom);
322 }
Jeff Sharkeyb654cbb2011-08-18 11:59:19 -0700323 }
324 }
Jeff Sharkeya83a24f2011-09-16 01:52:39 -0700325
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700326 public static void forceCustomPadding(View view, boolean additive) {
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700327 final Resources res = view.getResources();
328 final int paddingSide = res.getDimensionPixelSize(R.dimen.settings_side_margin);
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700329
330 final int paddingStart = paddingSide + (additive ? view.getPaddingStart() : 0);
331 final int paddingEnd = paddingSide + (additive ? view.getPaddingEnd() : 0);
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700332 final int paddingBottom = res.getDimensionPixelSize(
333 com.android.internal.R.dimen.preference_fragment_padding_bottom);
334
Fabrice Di Meglio0f4a7792014-07-28 18:25:14 -0700335 view.setPaddingRelative(paddingStart, 0, paddingEnd, paddingBottom);
Fabrice Di Meglio38ba9a22014-07-18 19:58:50 -0700336 }
337
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700338 /* Used by UserSettings as well. Call this on a non-ui thread. */
339 public static boolean copyMeProfilePhoto(Context context, UserInfo user) {
340 Uri contactUri = Profile.CONTENT_URI;
341
342 InputStream avatarDataStream = Contacts.openContactPhotoInputStream(
343 context.getContentResolver(),
344 contactUri, true);
345 // If there's no profile photo, assign a default avatar
346 if (avatarDataStream == null) {
347 return false;
348 }
349 int userId = user != null ? user.id : UserHandle.myUserId();
350 UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);
Amith Yamasanif34a85d2012-09-17 18:31:45 -0700351 Bitmap icon = BitmapFactory.decodeStream(avatarDataStream);
352 um.setUserIcon(userId, icon);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700353 try {
Amith Yamasanif34a85d2012-09-17 18:31:45 -0700354 avatarDataStream.close();
355 } catch (IOException ioe) { }
356 return true;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700357 }
358
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700359 public static String getMeProfileName(Context context, boolean full) {
360 if (full) {
361 return getProfileDisplayName(context);
362 } else {
363 return getShorterNameIfPossible(context);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700364 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700365 }
366
367 private static String getShorterNameIfPossible(Context context) {
368 final String given = getLocalProfileGivenName(context);
369 return !TextUtils.isEmpty(given) ? given : getProfileDisplayName(context);
370 }
371
372 private static String getLocalProfileGivenName(Context context) {
373 final ContentResolver cr = context.getContentResolver();
374
375 // Find the raw contact ID for the local ME profile raw contact.
376 final long localRowProfileId;
377 final Cursor localRawProfile = cr.query(
378 Profile.CONTENT_RAW_CONTACTS_URI,
379 new String[] {RawContacts._ID},
380 RawContacts.ACCOUNT_TYPE + " IS NULL AND " +
381 RawContacts.ACCOUNT_NAME + " IS NULL",
382 null, null);
383 if (localRawProfile == null) return null;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700384
385 try {
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700386 if (!localRawProfile.moveToFirst()) {
387 return null;
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700388 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700389 localRowProfileId = localRawProfile.getLong(0);
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700390 } finally {
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700391 localRawProfile.close();
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700392 }
Amith Yamasani8d40fac2012-10-23 15:36:16 -0700393
394 // Find the structured name for the raw contact.
395 final Cursor structuredName = cr.query(
396 Profile.CONTENT_URI.buildUpon().appendPath(Contacts.Data.CONTENT_DIRECTORY).build(),
397 new String[] {CommonDataKinds.StructuredName.GIVEN_NAME,
398 CommonDataKinds.StructuredName.FAMILY_NAME},
399 Data.RAW_CONTACT_ID + "=" + localRowProfileId,
400 null, null);
401 if (structuredName == null) return null;
402
403 try {
404 if (!structuredName.moveToFirst()) {
405 return null;
406 }
407 String partialName = structuredName.getString(0);
408 if (TextUtils.isEmpty(partialName)) {
409 partialName = structuredName.getString(1);
410 }
411 return partialName;
412 } finally {
413 structuredName.close();
414 }
415 }
416
417 private static final String getProfileDisplayName(Context context) {
418 final ContentResolver cr = context.getContentResolver();
419 final Cursor profile = cr.query(Profile.CONTENT_URI,
420 new String[] {Profile.DISPLAY_NAME}, null, null, null);
421 if (profile == null) return null;
422
423 try {
424 if (!profile.moveToFirst()) {
425 return null;
426 }
427 return profile.getString(0);
428 } finally {
429 profile.close();
430 }
Amith Yamasaniae47ef42012-09-16 17:53:35 -0700431 }
Amith Yamasani9627a8e2012-09-23 12:54:14 -0700432
433 /** Not global warming, it's global change warning. */
434 public static Dialog buildGlobalChangeWarningDialog(final Context context, int titleResId,
435 final Runnable positiveAction) {
436 final AlertDialog.Builder builder = new AlertDialog.Builder(context);
437 builder.setTitle(titleResId);
438 builder.setMessage(R.string.global_change_warning);
439 builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
440 @Override
441 public void onClick(DialogInterface dialog, int which) {
442 positiveAction.run();
443 }
444 });
445 builder.setNegativeButton(android.R.string.cancel, null);
446
447 return builder.create();
448 }
449
450 public static boolean hasMultipleUsers(Context context) {
451 return ((UserManager) context.getSystemService(Context.USER_SERVICE))
452 .getUsers().size() > 1;
453 }
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700454
455 /**
456 * Start a new instance of the activity, showing only the given fragment.
457 * When launched in this mode, the given preference fragment will be instantiated and fill the
458 * entire activity.
459 *
460 * @param context The context.
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000461 * @param fragmentName The name of the fragment to display.
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700462 * @param args Optional arguments to supply to the fragment.
Fabrice Di Meglioa9e77992014-06-09 12:52:24 -0700463 * @param resultTo Option fragment that should receive the result of the activity launch.
464 * @param resultRequestCode If resultTo is non-null, this is the request code in which
465 * to report the result.
466 * @param titleResId resource id for the String to display for the title of this set
467 * of preferences.
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700468 * @param title String to display for the title of this set of preferences.
469 */
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000470 public static void startWithFragment(Context context, String fragmentName, Bundle args,
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100471 Fragment resultTo, int resultRequestCode, int titleResId,
472 CharSequence title) {
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700473 startWithFragment(context, fragmentName, args, resultTo, resultRequestCode,
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100474 null /* titleResPackageName */, titleResId, title, false /* not a shortcut */);
475 }
476
477 /**
478 * Start a new instance of the activity, showing only the given fragment.
479 * When launched in this mode, the given preference fragment will be instantiated and fill the
480 * entire activity.
481 *
482 * @param context The context.
483 * @param fragmentName The name of the fragment to display.
484 * @param args Optional arguments to supply to the fragment.
485 * @param resultTo Option fragment that should receive the result of the activity launch.
486 * @param resultRequestCode If resultTo is non-null, this is the request code in which
487 * to report the result.
488 * @param titleResPackageName Optional package name for the resource id of the title.
489 * @param titleResId resource id for the String to display for the title of this set
490 * of preferences.
491 * @param title String to display for the title of this set of preferences.
492 */
493 public static void startWithFragment(Context context, String fragmentName, Bundle args,
494 Fragment resultTo, int resultRequestCode, String titleResPackageName, int titleResId,
495 CharSequence title) {
496 startWithFragment(context, fragmentName, args, resultTo, resultRequestCode,
497 titleResPackageName, titleResId, title, false /* not a shortcut */);
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700498 }
499
500 public static void startWithFragment(Context context, String fragmentName, Bundle args,
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100501 Fragment resultTo, int resultRequestCode, int titleResId,
502 CharSequence title, boolean isShortcut) {
503 Intent intent = onBuildStartFragmentIntent(context, fragmentName, args,
504 null /* titleResPackageName */, titleResId, title, isShortcut);
505 if (resultTo == null) {
506 context.startActivity(intent);
507 } else {
508 resultTo.startActivityForResult(intent, resultRequestCode);
509 }
510 }
511
512 public static void startWithFragment(Context context, String fragmentName, Bundle args,
513 Fragment resultTo, int resultRequestCode, String titleResPackageName, int titleResId,
514 CharSequence title, boolean isShortcut) {
515 Intent intent = onBuildStartFragmentIntent(context, fragmentName, args, titleResPackageName,
516 titleResId, title, isShortcut);
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700517 if (resultTo == null) {
518 context.startActivity(intent);
519 } else {
520 resultTo.startActivityForResult(intent, resultRequestCode);
521 }
522 }
523
Zoltan Szatmary-Ban7a2ccf22014-09-18 10:26:11 +0100524 public static void startWithFragmentAsUser(Context context, String fragmentName, Bundle args,
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100525 int titleResId, CharSequence title, boolean isShortcut,
526 UserHandle userHandle) {
Victor Chang16da2aa2016-03-11 19:44:56 +0000527 // workaround to avoid crash in b/17523189
528 if (userHandle.getIdentifier() == UserHandle.myUserId()) {
529 startWithFragment(context, fragmentName, args, null, 0, titleResId, title, isShortcut);
530 } else {
531 Intent intent = onBuildStartFragmentIntent(context, fragmentName, args,
532 null /* titleResPackageName */, titleResId, title, isShortcut);
533 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
534 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
535 context.startActivityAsUser(intent, userHandle);
536 }
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100537 }
538
539 public static void startWithFragmentAsUser(Context context, String fragmentName, Bundle args,
540 String titleResPackageName, int titleResId, CharSequence title, boolean isShortcut,
541 UserHandle userHandle) {
Victor Chang16da2aa2016-03-11 19:44:56 +0000542 // workaround to avoid crash in b/17523189
543 if (userHandle.getIdentifier() == UserHandle.myUserId()) {
544 startWithFragment(context, fragmentName, args, null, 0, titleResPackageName, titleResId,
545 title, isShortcut);
546 } else {
547 Intent intent = onBuildStartFragmentIntent(context, fragmentName, args,
548 titleResPackageName, titleResId, title, isShortcut);
549 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
550 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
551 context.startActivityAsUser(intent, userHandle);
552 }
Zoltan Szatmary-Ban7a2ccf22014-09-18 10:26:11 +0100553 }
554
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700555 /**
556 * Build an Intent to launch a new activity showing the selected fragment.
557 * The implementation constructs an Intent that re-launches the current activity with the
558 * appropriate arguments to display the fragment.
559 *
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700560 *
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700561 * @param context The Context.
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000562 * @param fragmentName The name of the fragment to display.
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700563 * @param args Optional arguments to supply to the fragment.
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100564 * @param titleResPackageName Optional package name for the resource id of the title.
Fabrice Di Meglioa9e77992014-06-09 12:52:24 -0700565 * @param titleResId Optional title resource id to show for this item.
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700566 * @param title Optional title to show for this item.
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700567 * @param isShortcut tell if this is a Launcher Shortcut or not
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700568 * @return Returns an Intent that can be launched to display the given
569 * fragment.
570 */
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000571 public static Intent onBuildStartFragmentIntent(Context context, String fragmentName,
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100572 Bundle args, String titleResPackageName, int titleResId, CharSequence title,
573 boolean isShortcut) {
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700574 Intent intent = new Intent(Intent.ACTION_MAIN);
575 intent.setClass(context, SubSettings.class);
Fabrice Di Meglio93b77b72014-05-17 00:01:07 +0000576 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT, fragmentName);
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700577 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS, args);
Alexandra Gherghina62464b82014-08-11 12:40:13 +0100578 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RES_PACKAGE_NAME,
579 titleResPackageName);
Fabrice Di Meglioa9e77992014-06-09 12:52:24 -0700580 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RESID, titleResId);
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700581 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE, title);
Fabrice Di Meglio0d643fd2014-06-16 20:11:27 -0700582 intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_AS_SHORTCUT, isShortcut);
Fabrice Di Meglio769630c2014-04-24 14:48:48 -0700583 return intent;
584 }
Alexandra Gherghina3939cd72014-06-04 10:02:55 +0100585
586 /**
587 * Returns the managed profile of the current user or null if none found.
588 */
589 public static UserHandle getManagedProfile(UserManager userManager) {
590 List<UserHandle> userProfiles = userManager.getUserProfiles();
591 final int count = userProfiles.size();
592 for (int i = 0; i < count; i++) {
593 final UserHandle profile = userProfiles.get(i);
594 if (profile.getIdentifier() == userManager.getUserHandle()) {
595 continue;
596 }
597 final UserInfo userInfo = userManager.getUserInfo(profile.getIdentifier());
598 if (userInfo.isManagedProfile()) {
599 return profile;
600 }
601 }
602 return null;
603 }
604
605 /**
606 * Returns true if the current profile is a managed one.
Benjamin Franz194300d2016-01-13 12:16:25 +0000607 *
608 * @throws IllegalArgumentException if userManager is null.
Alexandra Gherghina3939cd72014-06-04 10:02:55 +0100609 */
Benjamin Franz194300d2016-01-13 12:16:25 +0000610 public static boolean isManagedProfile(@NonNull UserManager userManager) {
611 return isManagedProfile(userManager, UserHandle.myUserId());
612 }
613
614 /**
Clara Bayarri462cce12016-02-18 12:09:21 +0000615 * Retrieves the id for the given user's managed profile.
616 *
617 * @return the managed profile id or UserHandle.USER_NULL if there is none.
618 */
619 public static int getManagedProfileId(UserManager um, int parentUserId) {
Fyodor Kupolov4a4af5a2016-04-07 16:46:18 -0700620 int[] profileIds = um.getProfileIdsWithDisabled(parentUserId);
621 for (int profileId : profileIds) {
622 if (profileId != parentUserId) {
623 return profileId;
Clara Bayarri462cce12016-02-18 12:09:21 +0000624 }
625 }
626 return UserHandle.USER_NULL;
627 }
628
629 /**
Benjamin Franz194300d2016-01-13 12:16:25 +0000630 * Returns true if the userId passed in is a managed profile.
631 *
632 * @throws IllegalArgumentException if userManager is null.
633 */
634 public static boolean isManagedProfile(@NonNull UserManager userManager, int userId) {
635 if (userManager == null) {
636 throw new IllegalArgumentException("userManager must not be null");
637 }
638 UserInfo userInfo = userManager.getUserInfo(userId);
639 return (userInfo != null) ? userInfo.isManagedProfile() : false;
Alexandra Gherghina3939cd72014-06-04 10:02:55 +0100640 }
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100641
642 /**
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100643 * Returns the target user for a Settings activity.
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100644 *
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100645 * The target user can be either the current user, the user that launched this activity or
646 * the user contained as an extra in the arguments or intent extras.
647 *
648 * Note: This is secure in the sense that it only returns a target user different to the current
649 * one if the app launching this activity is the Settings app itself, running in the same user
650 * 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 +0100651 */
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100652 public static UserHandle getSecureTargetUser(IBinder activityToken,
653 UserManager um, @Nullable Bundle arguments, @Nullable Bundle intentExtras) {
654 UserHandle currentUser = new UserHandle(UserHandle.myUserId());
655 IActivityManager am = ActivityManagerNative.getDefault();
656 try {
657 String launchedFromPackage = am.getLaunchedFromPackage(activityToken);
658 boolean launchedFromSettingsApp = SETTINGS_PACKAGE_NAME.equals(launchedFromPackage);
659
660 UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId(
661 am.getLaunchedFromUid(activityToken)));
662 if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) {
663 // Check it's secure
664 if (isProfileOf(um, launchedFromUser)) {
665 return launchedFromUser;
666 }
667 }
668 UserHandle extrasUser = intentExtras != null
669 ? (UserHandle) intentExtras.getParcelable(EXTRA_USER) : null;
670 if (extrasUser != null && !extrasUser.equals(currentUser)) {
671 // Check it's secure
672 if (launchedFromSettingsApp && isProfileOf(um, extrasUser)) {
673 return extrasUser;
674 }
675 }
676 UserHandle argumentsUser = arguments != null
677 ? (UserHandle) arguments.getParcelable(EXTRA_USER) : null;
678 if (argumentsUser != null && !argumentsUser.equals(currentUser)) {
679 // Check it's secure
680 if (launchedFromSettingsApp && isProfileOf(um, argumentsUser)) {
681 return argumentsUser;
682 }
683 }
684 } catch (RemoteException e) {
685 // Should not happen
686 Log.v(TAG, "Could not talk to activity manager.", e);
687 }
688 return currentUser;
689 }
690
691 /**
692 * Returns the target user for a Settings activity.
693 *
694 * The target user can be either the current user, the user that launched this activity or
695 * the user contained as an extra in the arguments or intent extras.
696 *
697 * You should use {@link #getSecureTargetUser(IBinder, UserManager, Bundle, Bundle)} if
698 * possible.
699 *
700 * @see #getInsecureTargetUser(IBinder, Bundle, Bundle)
701 */
702 public static UserHandle getInsecureTargetUser(IBinder activityToken, @Nullable Bundle arguments,
703 @Nullable Bundle intentExtras) {
704 UserHandle currentUser = new UserHandle(UserHandle.myUserId());
705 IActivityManager am = ActivityManagerNative.getDefault();
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100706 try {
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100707 UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId(
708 am.getLaunchedFromUid(activityToken)));
709 if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) {
710 return launchedFromUser;
711 }
712 UserHandle extrasUser = intentExtras != null
713 ? (UserHandle) intentExtras.getParcelable(EXTRA_USER) : null;
714 if (extrasUser != null && !extrasUser.equals(currentUser)) {
715 return extrasUser;
716 }
717 UserHandle argumentsUser = arguments != null
718 ? (UserHandle) arguments.getParcelable(EXTRA_USER) : null;
719 if (argumentsUser != null && !argumentsUser.equals(currentUser)) {
720 return argumentsUser;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100721 }
722 } catch (RemoteException e) {
723 // Should not happen
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100724 Log.v(TAG, "Could not talk to activity manager.", e);
725 return null;
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100726 }
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100727 return currentUser;
728 }
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100729
Alexandra Gherghina7d748c02014-06-27 12:33:42 +0100730 /**
731 * Returns true if the user provided is in the same profiles group as the current user.
732 */
733 private static boolean isProfileOf(UserManager um, UserHandle otherUser) {
734 if (um == null || otherUser == null) return false;
735 return (UserHandle.myUserId() == otherUser.getIdentifier())
736 || um.getUserProfiles().contains(otherUser);
Alexandra Gherghina1eb3f312014-06-10 14:01:10 +0100737 }
Amith Yamasani51c6dac2014-07-02 00:06:37 +0530738
Andres Moralesce249fe2014-07-07 16:58:16 -0700739
740 /**
741 * Returns whether or not this device is able to be OEM unlocked.
742 */
743 static boolean isOemUnlockEnabled(Context context) {
744 PersistentDataBlockManager manager =(PersistentDataBlockManager)
745 context.getSystemService(Context.PERSISTENT_DATA_BLOCK_SERVICE);
746 return manager.getOemUnlockEnabled();
747 }
748
749 /**
750 * Allows enabling or disabling OEM unlock on this device. OEM unlocked
751 * devices allow users to flash other OSes to them.
752 */
753 static void setOemUnlockEnabled(Context context, boolean enabled) {
754 PersistentDataBlockManager manager =(PersistentDataBlockManager)
755 context.getSystemService(Context.PERSISTENT_DATA_BLOCK_SERVICE);
756 manager.setOemUnlockEnabled(enabled);
757 }
Alexandra Gherghina95b86a52014-07-24 19:13:25 +0100758
759 /**
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700760 * Return whether or not the user should have a SIM Cards option in Settings.
761 * TODO: Change back to returning true if count is greater than one after testing.
762 * TODO: See bug 16533525.
763 */
764 public static boolean showSimCardTile(Context context) {
765 final TelephonyManager tm =
766 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
767
PauloftheWestdbd03822014-12-04 11:56:35 -0800768 return tm.getSimCount() > 1;
Fabrice Di Meglio22a2a492014-08-08 12:27:57 -0700769 }
Dan Sandlerb58b5122014-09-02 18:31:49 +0200770
771 /**
Elliott Hughes7253df32014-09-02 17:10:14 -0700772 * Returns elapsed time for the given millis, in the following format:
773 * 2d 5h 40m 29s
774 * @param context the application context
775 * @param millis the elapsed time in milli seconds
776 * @param withSeconds include seconds?
777 * @return the formatted elapsed time
778 */
779 public static String formatElapsedTime(Context context, double millis, boolean withSeconds) {
780 StringBuilder sb = new StringBuilder();
781 int seconds = (int) Math.floor(millis / 1000);
782 if (!withSeconds) {
783 // Round up.
784 seconds += 30;
785 }
786
787 int days = 0, hours = 0, minutes = 0;
788 if (seconds >= SECONDS_PER_DAY) {
789 days = seconds / SECONDS_PER_DAY;
790 seconds -= days * SECONDS_PER_DAY;
791 }
792 if (seconds >= SECONDS_PER_HOUR) {
793 hours = seconds / SECONDS_PER_HOUR;
794 seconds -= hours * SECONDS_PER_HOUR;
795 }
796 if (seconds >= SECONDS_PER_MINUTE) {
797 minutes = seconds / SECONDS_PER_MINUTE;
798 seconds -= minutes * SECONDS_PER_MINUTE;
799 }
800 if (withSeconds) {
801 if (days > 0) {
802 sb.append(context.getString(R.string.battery_history_days,
803 days, hours, minutes, seconds));
804 } else if (hours > 0) {
805 sb.append(context.getString(R.string.battery_history_hours,
806 hours, minutes, seconds));
807 } else if (minutes > 0) {
808 sb.append(context.getString(R.string.battery_history_minutes, minutes, seconds));
809 } else {
810 sb.append(context.getString(R.string.battery_history_seconds, seconds));
811 }
812 } else {
813 if (days > 0) {
814 sb.append(context.getString(R.string.battery_history_days_no_seconds,
815 days, hours, minutes));
816 } else if (hours > 0) {
817 sb.append(context.getString(R.string.battery_history_hours_no_seconds,
818 hours, minutes));
819 } else {
820 sb.append(context.getString(R.string.battery_history_minutes_no_seconds, minutes));
821 }
822 }
823 return sb.toString();
824 }
PauloftheWest0a0daca2014-11-06 15:02:58 -0800825
826 /**
Amith Yamasani45f86232014-11-19 17:12:46 -0800827 * Queries for the UserInfo of a user. Returns null if the user doesn't exist (was removed).
828 * @param userManager Instance of UserManager
829 * @param checkUser The user to check the existence of.
830 * @return UserInfo of the user or null for non-existent user.
831 */
832 public static UserInfo getExistingUser(UserManager userManager, UserHandle checkUser) {
833 final List<UserInfo> users = userManager.getUsers(true /* excludeDying */);
834 final int checkUserId = checkUser.getIdentifier();
835 for (UserInfo user : users) {
836 if (user.id == checkUserId) {
837 return user;
838 }
839 }
840 return null;
841 }
842
Zoltan Szatmary-Ban3af2e4c2014-12-19 17:17:23 +0000843 public static View inflateCategoryHeader(LayoutInflater inflater, ViewGroup parent) {
844 final TypedArray a = inflater.getContext().obtainStyledAttributes(null,
845 com.android.internal.R.styleable.Preference,
846 com.android.internal.R.attr.preferenceCategoryStyle, 0);
847 final int resId = a.getResourceId(com.android.internal.R.styleable.Preference_layout,
848 0);
849 a.recycle();
850 return inflater.inflate(resId, parent, false);
851 }
852
Fabrice Di Megliodff3faa2015-02-27 11:14:11 -0800853 /**
854 * Return if we are running low on storage space or not.
855 *
856 * @param context The context
857 * @return true if we are running low on storage space
858 */
859 public static boolean isLowStorage(Context context) {
860 final StorageManager sm = StorageManager.from(context);
861 return (sm.getStorageBytesUntilLow(context.getFilesDir()) < 0);
862 }
863
Zoltan Szatmary-Bane5814ff2014-12-19 16:27:45 +0000864 /**
865 * Returns a default user icon (as a {@link Bitmap}) for the given user.
866 *
867 * Note that for guest users, you should pass in {@code UserHandle.USER_NULL}.
868 * @param userId the user id or {@code UserHandle.USER_NULL} for a non-user specific icon
869 */
870 public static Bitmap getDefaultUserIconAsBitmap(int userId) {
871 Bitmap bitmap = null;
872 // Try finding the corresponding bitmap in the dark bitmap cache
873 bitmap = sDarkDefaultUserBitmapCache.get(userId);
874 if (bitmap == null) {
875 bitmap = UserIcons.convertToBitmap(UserIcons.getDefaultUserIcon(userId, false));
876 // Save it to cache
877 sDarkDefaultUserBitmapCache.put(userId, bitmap);
878 }
879 return bitmap;
880 }
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -0800881
Fabrice Di Meglio8b2ea392015-01-23 19:03:22 -0800882 public static boolean hasPreferredActivities(PackageManager pm, String packageName) {
883 // Get list of preferred activities
884 List<ComponentName> prefActList = new ArrayList<>();
885 // Intent list cannot be null. so pass empty list
886 List<IntentFilter> intentList = new ArrayList<>();
887 pm.getPreferredActivities(intentList, prefActList, packageName);
888 Log.d(TAG, "Have " + prefActList.size() + " number of activities in preferred list");
889 return prefActList.size() > 0;
890 }
891
Christopher Tatea08a2252015-07-01 16:52:43 -0700892 public static ArraySet<String> getHandledDomains(PackageManager pm, String packageName) {
893 List<IntentFilterVerificationInfo> iviList = pm.getIntentFilterVerifications(packageName);
894 List<IntentFilter> filters = pm.getAllIntentFilters(packageName);
895
896 ArraySet<String> result = new ArraySet<>();
897 if (iviList.size() > 0) {
898 for (IntentFilterVerificationInfo ivi : iviList) {
899 for (String host : ivi.getDomains()) {
900 result.add(host);
901 }
902 }
903 }
904 if (filters != null && filters.size() > 0) {
905 for (IntentFilter filter : filters) {
Christopher Tateddaa1422015-07-16 16:00:49 -0700906 if (filter.hasCategory(Intent.CATEGORY_BROWSABLE)
907 && (filter.hasDataScheme(IntentFilter.SCHEME_HTTP) ||
908 filter.hasDataScheme(IntentFilter.SCHEME_HTTPS))) {
Christopher Tatea08a2252015-07-01 16:52:43 -0700909 result.addAll(filter.getHostsList());
910 }
911 }
912 }
913 return result;
914 }
915
Jason Monkb5aa73f2015-03-31 12:59:33 -0400916 public static void handleLoadingContainer(View loading, View doneLoading, boolean done,
917 boolean animate) {
918 setViewShown(loading, !done, animate);
919 setViewShown(doneLoading, done, animate);
920 }
921
922 private static void setViewShown(final View view, boolean shown, boolean animate) {
923 if (animate) {
924 Animation animation = AnimationUtils.loadAnimation(view.getContext(),
925 shown ? android.R.anim.fade_in : android.R.anim.fade_out);
926 if (shown) {
927 view.setVisibility(View.VISIBLE);
928 } else {
929 animation.setAnimationListener(new AnimationListener() {
930 @Override
931 public void onAnimationStart(Animation animation) {
932 }
933
934 @Override
935 public void onAnimationRepeat(Animation animation) {
936 }
937
938 @Override
939 public void onAnimationEnd(Animation animation) {
940 view.setVisibility(View.INVISIBLE);
941 }
942 });
943 }
944 view.startAnimation(animation);
945 } else {
946 view.clearAnimation();
947 view.setVisibility(shown ? View.VISIBLE : View.INVISIBLE);
948 }
949 }
Sudheer Shankabc956302015-04-09 12:19:53 +0100950
951 /**
952 * Returns the application info of the currently installed MDM package.
953 */
954 public static ApplicationInfo getAdminApplicationInfo(Context context, int profileId) {
955 DevicePolicyManager dpm =
956 (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);
957 ComponentName mdmPackage = dpm.getProfileOwnerAsUser(profileId);
958 if (mdmPackage == null) {
959 return null;
960 }
961 String mdmPackageName = mdmPackage.getPackageName();
962 try {
963 IPackageManager ipm = AppGlobals.getPackageManager();
964 ApplicationInfo mdmApplicationInfo =
965 ipm.getApplicationInfo(mdmPackageName, 0, profileId);
966 return mdmApplicationInfo;
967 } catch (RemoteException e) {
968 Log.e(TAG, "Error while retrieving application info for package " + mdmPackageName
969 + ", userId " + profileId, e);
970 return null;
971 }
972 }
Jason Monkb45e27b2015-05-20 13:35:43 -0400973
974 public static boolean isBandwidthControlEnabled() {
975 final INetworkManagementService netManager = INetworkManagementService.Stub
976 .asInterface(ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE));
977 try {
978 return netManager.isBandwidthControlEnabled();
979 } catch (RemoteException e) {
980 return false;
981 }
982 }
Julia Reynoldsce25af42015-07-08 16:56:31 -0400983
984 /**
985 * Returns an accessible SpannableString.
986 * @param displayText the text to display
987 * @param accessibileText the text text-to-speech engines should read
988 */
989 public static SpannableString createAccessibleSequence(CharSequence displayText,
990 String accessibileText) {
991 SpannableString str = new SpannableString(displayText);
992 str.setSpan(new TtsSpan.TextBuilder(accessibileText).build(), 0,
993 displayText.length(),
994 Spannable.SPAN_INCLUSIVE_INCLUSIVE);
995 return str;
996 }
Andres Morales7bdffd82015-08-04 16:55:00 -0700997
Clara Bayarrife432e82015-10-12 12:07:02 +0100998 /**
Benjamin Franz194300d2016-01-13 12:16:25 +0000999 * Returns the user id present in the bundle with {@link Intent#EXTRA_USER_ID} if it
Clara Bayarrife432e82015-10-12 12:07:02 +01001000 * belongs to the current user.
1001 *
1002 * @throws SecurityException if the given userId does not belong to the current user group.
1003 */
Benjamin Franz194300d2016-01-13 12:16:25 +00001004 public static int getUserIdFromBundle(Context context, Bundle bundle) {
Clara Bayarrife432e82015-10-12 12:07:02 +01001005 if (bundle == null) {
Benjamin Franz194300d2016-01-13 12:16:25 +00001006 return getCredentialOwnerUserId(context);
Clara Bayarrife432e82015-10-12 12:07:02 +01001007 }
Clara Bayarri6934a042015-10-14 11:07:35 +01001008 int userId = bundle.getInt(Intent.EXTRA_USER_ID, UserHandle.myUserId());
Benjamin Franz194300d2016-01-13 12:16:25 +00001009 return enforceSameOwner(context, userId);
Clara Bayarrife432e82015-10-12 12:07:02 +01001010 }
1011
1012 /**
1013 * Returns the given user id if it belongs to the current user.
1014 *
1015 * @throws SecurityException if the given userId does not belong to the current user group.
1016 */
Benjamin Franz194300d2016-01-13 12:16:25 +00001017 public static int enforceSameOwner(Context context, int userId) {
1018 UserManager um = getUserManager(context);
1019 if (!um.getUserProfiles().contains(new UserHandle(userId))) {
1020 throw new SecurityException("Given user id " + userId + " does not belong to user "
1021 + UserHandle.myUserId());
Clara Bayarrife432e82015-10-12 12:07:02 +01001022 }
Benjamin Franz194300d2016-01-13 12:16:25 +00001023 return userId;
Clara Bayarrife432e82015-10-12 12:07:02 +01001024 }
1025
Benjamin Franz194300d2016-01-13 12:16:25 +00001026 /**
1027 * Returns the effective credential owner of the calling user.
1028 */
1029 public static int getCredentialOwnerUserId(Context context) {
1030 return getCredentialOwnerUserId(context, UserHandle.myUserId());
1031 }
1032
1033 /**
1034 * Returns the user id of the credential owner of the given user id.
1035 */
1036 public static int getCredentialOwnerUserId(Context context, int userId) {
1037 UserManager um = getUserManager(context);
1038 return um.getCredentialOwnerProfile(userId);
Andres Morales7bdffd82015-08-04 16:55:00 -07001039 }
Jason Monkdb4ed192015-12-11 16:48:31 -05001040
1041 public static int resolveResource(Context context, int attr) {
1042 TypedValue value = new TypedValue();
1043 context.getTheme().resolveAttribute(attr, value, true);
1044 return value.resourceId;
1045 }
Jason Monkb37e2882016-01-11 14:27:20 -05001046
1047 private static final StringBuilder sBuilder = new StringBuilder(50);
1048 private static final java.util.Formatter sFormatter = new java.util.Formatter(
1049 sBuilder, Locale.getDefault());
1050
1051 public static String formatDateRange(Context context, long start, long end) {
1052 final int flags = FORMAT_SHOW_DATE | FORMAT_ABBREV_MONTH;
1053
1054 synchronized (sBuilder) {
1055 sBuilder.setLength(0);
1056 return DateUtils.formatDateRange(context, sFormatter, start, end, flags, null)
1057 .toString();
1058 }
1059 }
Jason Monk91e2f892016-02-23 15:31:09 -05001060
1061 public static List<String> getNonIndexable(int xml, Context context) {
Jason Monk9ee80cd2016-03-03 11:21:42 -05001062 HandlerThread thread = new HandlerThread("Index_" + xml);
1063 thread.start();
1064 final List<String> ret = new ArrayList<>();
1065 new Handler(thread.getLooper()).post(new Runnable() {
1066 @Override
1067 public void run() {
1068 PreferenceManager manager = new PreferenceManager(context);
1069 PreferenceScreen screen = manager.inflateFromResource(context, xml, null);
1070 checkPrefs(screen, ret);
1071 }
1072 });
1073 thread.quitSafely();
Jason Monk91e2f892016-02-23 15:31:09 -05001074
1075 return ret;
1076 }
1077
1078 private static void checkPrefs(PreferenceGroup group, List<String> ret) {
1079 if (group == null) return;
1080 for (int i = 0; i < group.getPreferenceCount(); i++) {
1081 Preference pref = group.getPreference(i);
1082 if (pref instanceof SelfAvailablePreference
1083 && !((SelfAvailablePreference) pref).isAvailable(group.getContext())) {
1084 ret.add(pref.getKey());
1085 if (pref instanceof PreferenceGroup) {
1086 addAll((PreferenceGroup) pref, ret);
1087 }
1088 } else if (pref instanceof PreferenceGroup) {
1089 checkPrefs((PreferenceGroup) pref, ret);
1090 }
1091 }
1092 }
1093
1094 private static void addAll(PreferenceGroup group, List<String> ret) {
1095 if (group == null) return;
1096 for (int i = 0; i < group.getPreferenceCount(); i++) {
1097 Preference pref = group.getPreference(i);
1098 ret.add(pref.getKey());
1099 if (pref instanceof PreferenceGroup) {
1100 addAll((PreferenceGroup) pref, ret);
1101 }
1102 }
1103 }
Udam Saini679f7ad2016-03-25 10:47:00 -07001104
1105 public static boolean isDeviceProvisioned(Context context) {
1106 return Settings.Global.getInt(context.getContentResolver(),
1107 Settings.Global.DEVICE_PROVISIONED, 0) != 0;
1108 }
Ricky Wai616342b2016-04-13 10:40:22 +01001109
Bernard Chau88d523b2016-04-14 15:08:28 +01001110 public static boolean startQuietModeDialogIfNecessary(Context context, UserManager um,
Ricky Wai616342b2016-04-13 10:40:22 +01001111 int userId) {
1112 if (um.isQuietModeEnabled(UserHandle.of(userId))) {
1113 final Intent intent = UnlaunchableAppActivity.createInQuietModeDialogIntent(userId);
1114 context.startActivity(intent);
1115 return true;
1116 }
1117 return false;
1118 }
Andres Morales7bdffd82015-08-04 16:55:00 -07001119}
1120