src/com/android/settings/Utils.java

   1 /**
   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
  17 package com.android.settings;
  18
  19 import static android.content.Intent.EXTRA_USER;
  20 import static android.content.Intent.EXTRA_USER_ID;
  21 import static android.text.format.DateUtils.FORMAT_ABBREV_MONTH;
  22 import static android.text.format.DateUtils.FORMAT_SHOW_DATE;
  23
  24 import android.annotation.Nullable;
  25 import android.app.ActivityManager;
  26 import android.app.AlertDialog;
  27 import android.app.AppGlobals;
  28 import android.app.AppOpsManager;
  29 import android.app.Dialog;
  30 import android.app.Fragment;
  31 import android.app.IActivityManager;
  32 import android.app.KeyguardManager;
  33 import android.app.admin.DevicePolicyManager;
  34 import android.content.ActivityNotFoundException;
  35 import android.content.ComponentName;
  36 import android.content.ContentResolver;
  37 import android.content.Context;
  38 import android.content.DialogInterface;
  39 import android.content.Intent;
  40 import android.content.IntentFilter;
  41 import android.content.pm.ApplicationInfo;
  42 import android.content.pm.IPackageManager;
  43 import android.content.pm.IntentFilterVerificationInfo;
  44 import android.content.pm.PackageManager;
  45 import android.content.pm.PackageManager.NameNotFoundException;
  46 import android.content.pm.ResolveInfo;
  47 import android.content.pm.UserInfo;
  48 import android.content.res.Resources;
  49 import android.content.res.TypedArray;
  50 import android.database.Cursor;
  51 import android.graphics.Bitmap;
  52 import android.graphics.BitmapFactory;
  53 import android.hardware.fingerprint.FingerprintManager;
  54 import android.net.ConnectivityManager;
  55 import android.net.LinkProperties;
  56 import android.net.Network;
  57 import android.net.Uri;
  58 import android.net.wifi.WifiManager;
  59 import android.os.BatteryManager;
  60 import android.os.Bundle;
  61 import android.os.IBinder;
  62 import android.os.INetworkManagementService;
  63 import android.os.Looper;
  64 import android.os.RemoteException;
  65 import android.os.ServiceManager;
  66 import android.os.UserHandle;
  67 import android.os.UserManager;
  68 import android.os.storage.StorageManager;
  69 import android.os.storage.VolumeInfo;
  70 import android.preference.PreferenceFrameLayout;
  71 import android.provider.ContactsContract.CommonDataKinds;
  72 import android.provider.ContactsContract.Contacts;
  73 import android.provider.ContactsContract.Data;
  74 import android.provider.ContactsContract.Profile;
  75 import android.provider.ContactsContract.RawContacts;
  76 import android.provider.Settings;
  77 import android.support.annotation.StringRes;
  78 import android.support.v7.preference.Preference;
  79 import android.support.v7.preference.PreferenceGroup;
  80 import android.support.v7.preference.PreferenceManager;
  81 import android.support.v7.preference.PreferenceScreen;
  82 import android.telephony.TelephonyManager;
  83 import android.text.Spannable;
  84 import android.text.SpannableString;
  85 import android.text.SpannableStringBuilder;
  86 import android.text.Spanned;
  87 import android.text.TextUtils;
  88 import android.text.format.DateUtils;
  89 import android.text.style.TtsSpan;
  90 import android.util.ArraySet;
  91 import android.util.Log;
  92 import android.util.SparseArray;
  93 import android.util.TypedValue;
  94 import android.view.LayoutInflater;
  95 import android.view.View;
  96 import android.view.ViewGroup;
  97 import android.view.animation.Animation;
  98 import android.view.animation.Animation.AnimationListener;
  99 import android.view.animation.AnimationUtils;
 100 import android.widget.ListView;
 101 import android.widget.TabWidget;
 102
 103 import com.android.internal.app.UnlaunchableAppActivity;
 104 import com.android.internal.util.ArrayUtils;
 105 import com.android.internal.util.UserIcons;
 106 import com.android.internal.widget.LockPatternUtils;
 107 import com.android.settings.password.FingerprintManagerWrapper;
 108 import com.android.settings.password.IFingerprintManager;
 109
 110 import java.io.IOException;
 111 import java.io.InputStream;
 112 import java.net.InetAddress;
 113 import java.util.ArrayList;
 114 import java.util.Iterator;
 115 import java.util.List;
 116 import java.util.Locale;
 117
 118 public final class Utils extends com.android.settingslib.Utils {
 119
 120     private static final String TAG = "Settings";
 121
 122     /**
 123      * Set the preference's title to the matching activity's label.
 124      */
 125     public static final int UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY = 1;
 126
 127     /**
 128      * The opacity level of a disabled icon.
 129      */
 130     public static final float DISABLED_ALPHA = 0.4f;
 131
 132     /**
 133      * Color spectrum to use to indicate badness.  0 is completely transparent (no data),
 134      * 1 is most bad (red), the last value is least bad (green).
 135      */
 136     public static final int[] BADNESS_COLORS = new int[] {
 137             0x00000000, 0xffc43828, 0xffe54918, 0xfff47b00,
 138             0xfffabf2c, 0xff679e37, 0xff0a7f42
 139     };
 140
 141     private static final String SETTINGS_PACKAGE_NAME = "com.android.settings";
 142
 143     private static final int SECONDS_PER_MINUTE = 60;
 144     private static final int SECONDS_PER_HOUR = 60 * 60;
 145     private static final int SECONDS_PER_DAY = 24 * 60 * 60;
 146
 147     public static final String OS_PKG = "os";
 148
 149     private static SparseArray<Bitmap> sDarkDefaultUserBitmapCache = new SparseArray<Bitmap>();
 150
 151     /**
 152      * Finds a matching activity for a preference's intent. If a matching
 153      * activity is not found, it will remove the preference.
 154      *
 155      * @param context The context.
 156      * @param parentPreferenceGroup The preference group that contains the
 157      *            preference whose intent is being resolved.
 158      * @param preferenceKey The key of the preference whose intent is being
 159      *            resolved.
 160      * @param flags 0 or one or more of
 161      *            {@link #UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY}
 162      *            .
 163      * @return Whether an activity was found. If false, the preference was
 164      *         removed.
 165      */
 166     public static boolean updatePreferenceToSpecificActivityOrRemove(Context context,
 167             PreferenceGroup parentPreferenceGroup, String preferenceKey, int flags) {
 168
 169         Preference preference = parentPreferenceGroup.findPreference(preferenceKey);
 170         if (preference == null) {
 171             return false;
 172         }
 173
 174         Intent intent = preference.getIntent();
 175         if (intent != null) {
 176             // Find the activity that is in the system image
 177             PackageManager pm = context.getPackageManager();
 178             List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
 179             int listSize = list.size();
 180             for (int i = 0; i < listSize; i++) {
 181                 ResolveInfo resolveInfo = list.get(i);
 182                 if ((resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
 183                         != 0) {
 184
 185                     // Replace the intent with this specific activity
 186                     preference.setIntent(new Intent().setClassName(
 187                             resolveInfo.activityInfo.packageName,
 188                             resolveInfo.activityInfo.name));
 189
 190                     if ((flags & UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY) != 0) {
 191                         // Set the preference title to the activity's label
 192                         preference.setTitle(resolveInfo.loadLabel(pm));
 193                     }
 194
 195                     return true;
 196                 }
 197             }
 198         }
 199
 200         // Did not find a matching activity, so remove the preference
 201         parentPreferenceGroup.removePreference(preference);
 202
 203         return false;
 204     }
 205
 206     /**
 207      * Returns the UserManager for a given context
 208      *
 209      * @throws IllegalStateException if no UserManager could be retrieved.
 210      */
 211     public static UserManager getUserManager(Context context) {
 212         UserManager um = UserManager.get(context);
 213         if (um == null) {
 214             throw new IllegalStateException("Unable to load UserManager");
 215         }
 216         return um;
 217     }
 218
 219     /**
 220      * Returns true if Monkey is running.
 221      */
 222     public static boolean isMonkeyRunning() {
 223         return ActivityManager.isUserAMonkey();
 224     }
 225
 226     /**
 227      * Returns whether the device is voice-capable (meaning, it is also a phone).
 228      */
 229     public static boolean isVoiceCapable(Context context) {
 230         TelephonyManager telephony =
 231                 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
 232         return telephony != null && telephony.isVoiceCapable();
 233     }
 234
 235     public static boolean isWifiOnly(Context context) {
 236         ConnectivityManager cm = (ConnectivityManager)context.getSystemService(
 237                 Context.CONNECTIVITY_SERVICE);
 238         return (cm.isNetworkSupported(ConnectivityManager.TYPE_MOBILE) == false);
 239     }
 240
 241     /**
 242      * Returns the WIFI IP Addresses, if any, taking into account IPv4 and IPv6 style addresses.
 243      * @param context the application context
 244      * @return the formatted and newline-separated IP addresses, or null if none.
 245      */
 246     public static String getWifiIpAddresses(Context context) {
 247         WifiManager wifiManager = context.getSystemService(WifiManager.class);
 248         Network currentNetwork = wifiManager.getCurrentNetwork();
 249         if (currentNetwork != null) {
 250             ConnectivityManager cm = (ConnectivityManager)
 251                 context.getSystemService(Context.CONNECTIVITY_SERVICE);
 252             LinkProperties prop = cm.getLinkProperties(currentNetwork);
 253             return formatIpAddresses(prop);
 254         }
 255         return null;
 256     }
 257
 258     /**
 259      * Returns the default link's IP addresses, if any, taking into account IPv4 and IPv6 style
 260      * addresses.
 261      * @return the formatted and newline-separated IP addresses, or null if none.
 262      */
 263     public static String getDefaultIpAddresses(ConnectivityManager cm) {
 264         LinkProperties prop = cm.getActiveLinkProperties();
 265         return formatIpAddresses(prop);
 266     }
 267
 268     private static String formatIpAddresses(LinkProperties prop) {
 269         if (prop == null) return null;
 270         Iterator<InetAddress> iter = prop.getAllAddresses().iterator();
 271         // 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();
 277             if (iter.hasNext()) addresses += "\n";
 278         }
 279         return addresses;
 280     }
 281
 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     }
 301
 302     public static boolean isBatteryPresent(Intent batteryChangedIntent) {
 303         return batteryChangedIntent.getBooleanExtra(BatteryManager.EXTRA_PRESENT, true);
 304     }
 305
 306     public static String getBatteryPercentage(Intent batteryChangedIntent) {
 307         return formatPercentage(getBatteryLevel(batteryChangedIntent));
 308     }
 309
 310     /**
 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      */
 315     public static void prepareCustomPreferencesList(
 316             ViewGroup parent, View child, View list, boolean ignoreSidePadding) {
 317         final boolean movePadding = list.getScrollBarStyle() == View.SCROLLBARS_OUTSIDE_OVERLAY;
 318         if (movePadding) {
 319             final Resources res = list.getResources();
 320             final int paddingSide = res.getDimensionPixelSize(R.dimen.settings_side_margin);
 321             final int paddingBottom = res.getDimensionPixelSize(
 322                     com.android.internal.R.dimen.preference_fragment_padding_bottom);
 323
 324             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             }
 332         }
 333     }
 334
 335     public static void forceCustomPadding(View view, boolean additive) {
 336         final Resources res = view.getResources();
 337         final int paddingSide = res.getDimensionPixelSize(R.dimen.settings_side_margin);
 338
 339         final int paddingStart = paddingSide + (additive ? view.getPaddingStart() : 0);
 340         final int paddingEnd = paddingSide + (additive ? view.getPaddingEnd() : 0);
 341         final int paddingBottom = res.getDimensionPixelSize(
 342                 com.android.internal.R.dimen.preference_fragment_padding_bottom);
 343
 344         view.setPaddingRelative(paddingStart, 0, paddingEnd, paddingBottom);
 345     }
 346
 347     /* Used by UserSettings as well. Call this on a non-ui thread. */
 348     public static void copyMeProfilePhoto(Context context, UserInfo user) {
 349         Uri contactUri = Profile.CONTENT_URI;
 350
 351         int userId = user != null ? user.id : UserHandle.myUserId();
 352
 353         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) {
 358             assignDefaultPhoto(context, userId);
 359             return;
 360         }
 361
 362         UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);
 363         Bitmap icon = BitmapFactory.decodeStream(avatarDataStream);
 364         um.setUserIcon(userId, icon);
 365         try {
 366             avatarDataStream.close();
 367         } catch (IOException ioe) { }
 368     }
 369
 370     /**
 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         }
 380         UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);
 381         Bitmap bitmap = getDefaultUserIconAsBitmap(userId);
 382         um.setUserIcon(userId, bitmap);
 383
 384         return true;
 385     }
 386
 387     public static String getMeProfileName(Context context, boolean full) {
 388         if (full) {
 389             return getProfileDisplayName(context);
 390         } else {
 391             return getShorterNameIfPossible(context);
 392         }
 393     }
 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;
 412
 413         try {
 414             if (!localRawProfile.moveToFirst()) {
 415                 return null;
 416             }
 417             localRowProfileId = localRawProfile.getLong(0);
 418         } finally {
 419             localRawProfile.close();
 420         }
 421
 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         }
 459     }
 460
 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     }
 482
 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.
 489      * @param fragmentName The name of the fragment to display.
 490      * @param args Optional arguments to supply to the fragment.
 491      * @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.
 496      * @param title String to display for the title of this set of preferences.
 497      * @param metricsCategory The current metricsCategory for logging source when fragment starts
 498      */
 499     public static void startWithFragment(Context context, String fragmentName, Bundle args,
 500             Fragment resultTo, int resultRequestCode, int titleResId,
 501             CharSequence title, int metricsCategory) {
 502         startWithFragment(context, fragmentName, args, resultTo, resultRequestCode,
 503                 null /* titleResPackageName */, titleResId, title, false /* not a shortcut */,
 504                 metricsCategory);
 505     }
 506
 507     /**
 508      * Start a new instance of the activity, showing only the given fragment.
 509      * When launched in this mode, the given preference fragment will be instantiated and fill the
 510      * entire activity.
 511      *
 512      * @param context The context.
 513      * @param fragmentName The name of the fragment to display.
 514      * @param args Optional arguments to supply to the fragment.
 515      * @param resultTo Option fragment that should receive the result of the activity launch.
 516      * @param resultRequestCode If resultTo is non-null, this is the request code in which
 517      *                          to report the result.
 518      * @param titleResPackageName Optional package name for the resource id of the title.
 519      * @param titleResId resource id for the String to display for the title of this set
 520      *                   of preferences.
 521      * @param title String to display for the title of this set of preferences.
 522      * @param metricsCategory The current metricsCategory for logging source when fragment starts
 523      */
 524     public static void startWithFragment(Context context, String fragmentName, Bundle args,
 525             Fragment resultTo, int resultRequestCode, String titleResPackageName, int titleResId,
 526             CharSequence title, int metricsCategory) {
 527         startWithFragment(context, fragmentName, args, resultTo, resultRequestCode,
 528                 titleResPackageName, titleResId, title, false /* not a shortcut */,
 529                 metricsCategory);
 530     }
 531
 532     public static void startWithFragment(Context context, String fragmentName, Bundle args,
 533             Fragment resultTo, int resultRequestCode, int titleResId,
 534             CharSequence title, boolean isShortcut, int metricsCategory) {
 535         Intent intent = onBuildStartFragmentIntent(context, fragmentName, args,
 536                 null /* titleResPackageName */, titleResId, title, isShortcut, metricsCategory);
 537         if (resultTo == null) {
 538             context.startActivity(intent);
 539         } else {
 540             resultTo.getActivity().startActivityForResult(intent, resultRequestCode);
 541         }
 542     }
 543
 544     public static void startWithFragment(Context context, String fragmentName, Bundle args,
 545             Fragment resultTo, int resultRequestCode, String titleResPackageName, int titleResId,
 546             CharSequence title, boolean isShortcut, int metricsCategory) {
 547         Intent intent = onBuildStartFragmentIntent(context, fragmentName, args, titleResPackageName,
 548                 titleResId, title, isShortcut, metricsCategory);
 549         if (resultTo == null) {
 550             context.startActivity(intent);
 551         } else {
 552             resultTo.startActivityForResult(intent, resultRequestCode);
 553         }
 554     }
 555
 556     public static void startWithFragmentAsUser(Context context, String fragmentName, Bundle args,
 557             int titleResId, CharSequence title, boolean isShortcut, int metricsCategory,
 558             UserHandle userHandle) {
 559         // workaround to avoid crash in b/17523189
 560         if (userHandle.getIdentifier() == UserHandle.myUserId()) {
 561             startWithFragment(context, fragmentName, args, null, 0, titleResId, title, isShortcut,
 562                     metricsCategory);
 563         } else {
 564             Intent intent = onBuildStartFragmentIntent(context, fragmentName, args,
 565                     null /* titleResPackageName */, titleResId, title, isShortcut, metricsCategory);
 566             intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
 567             intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
 568             context.startActivityAsUser(intent, userHandle);
 569         }
 570     }
 571
 572     /**
 573      * Build an Intent to launch a new activity showing the selected fragment.
 574      * The implementation constructs an Intent that re-launches the current activity with the
 575      * appropriate arguments to display the fragment.
 576      *
 577      *
 578      * @param context The Context.
 579      * @param fragmentName The name of the fragment to display.
 580      * @param args Optional arguments to supply to the fragment.
 581      * @param titleResPackageName Optional package name for the resource id of the title.
 582      * @param titleResId Optional title resource id to show for this item.
 583      * @param title Optional title to show for this item.
 584      * @param isShortcut  tell if this is a Launcher Shortcut or not
 585      * @param sourceMetricsCategory The context (source) from which an action is performed
 586      * @return Returns an Intent that can be launched to display the given
 587      * fragment.
 588      */
 589     public static Intent onBuildStartFragmentIntent(Context context, String fragmentName,
 590             Bundle args, String titleResPackageName, int titleResId, CharSequence title,
 591             boolean isShortcut, int sourceMetricsCategory) {
 592         Intent intent = new Intent(Intent.ACTION_MAIN);
 593         intent.setClass(context, SubSettings.class);
 594         intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT, fragmentName);
 595         intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS, args);
 596         intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RES_PACKAGE_NAME,
 597                 titleResPackageName);
 598         intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RESID, titleResId);
 599         intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE, title);
 600         intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_AS_SHORTCUT, isShortcut);
 601         intent.putExtra(SettingsActivity.EXTRA_SOURCE_METRICS_CATEGORY, sourceMetricsCategory);
 602         return intent;
 603     }
 604
 605     /**
 606      * Returns the managed profile of the current user or {@code null} if none is found or a profile
 607      * exists but it is disabled.
 608      */
 609     public static UserHandle getManagedProfile(UserManager userManager) {
 610         List<UserHandle> userProfiles = userManager.getUserProfiles();
 611         final int count = userProfiles.size();
 612         for (int i = 0; i < count; i++) {
 613             final UserHandle profile = userProfiles.get(i);
 614             if (profile.getIdentifier() == userManager.getUserHandle()) {
 615                 continue;
 616             }
 617             final UserInfo userInfo = userManager.getUserInfo(profile.getIdentifier());
 618             if (userInfo.isManagedProfile()) {
 619                 return profile;
 620             }
 621         }
 622         return null;
 623     }
 624
 625     /**
 626      * Returns the managed profile of the current user or {@code null} if none is found. Unlike
 627      * {@link #getManagedProfile} this method returns enabled and disabled managed profiles.
 628      */
 629     public static UserHandle getManagedProfileWithDisabled(UserManager userManager) {
 630         // TODO: Call getManagedProfileId from here once Robolectric supports
 631         // API level 24 and UserManager.getProfileIdsWithDisabled can be Mocked (to avoid having
 632         // yet another implementation that loops over user profiles in this method). In the meantime
 633         // we need to use UserManager.getProfiles that is available on API 23 (the one currently
 634         // used for Settings Robolectric tests).
 635         final int myUserId = UserHandle.myUserId();
 636         List<UserInfo> profiles = userManager.getProfiles(myUserId);
 637         final int count = profiles.size();
 638         for (int i = 0; i < count; i++) {
 639             final UserInfo profile = profiles.get(i);
 640             if (profile.isManagedProfile()
 641                     && profile.getUserHandle().getIdentifier() != myUserId) {
 642                 return profile.getUserHandle();
 643             }
 644         }
 645         return null;
 646     }
 647
 648     /**
 649      * Retrieves the id for the given user's managed profile.
 650      *
 651      * @return the managed profile id or UserHandle.USER_NULL if there is none.
 652      */
 653     public static int getManagedProfileId(UserManager um, int parentUserId) {
 654         int[] profileIds = um.getProfileIdsWithDisabled(parentUserId);
 655         for (int profileId : profileIds) {
 656             if (profileId != parentUserId) {
 657                 return profileId;
 658             }
 659         }
 660         return UserHandle.USER_NULL;
 661     }
 662
 663     /**
 664      * Returns the target user for a Settings activity.
 665      * <p>
 666      * User would be retrieved in this order:
 667      * <ul>
 668      * <li> If this activity is launched from other user, return that user id.
 669      * <li> If this is launched from the Settings app in same user, return the user contained as an
 670      *      extra in the arguments or intent extras.
 671      * <li> Otherwise, return UserHandle.myUserId().
 672      * </ul>
 673      * <p>
 674      * Note: This is secure in the sense that it only returns a target user different to the current
 675      * one if the app launching this activity is the Settings app itself, running in the same user
 676      * or in one that is in the same profile group, or if the user id is provided by the system.
 677      */
 678     public static UserHandle getSecureTargetUser(IBinder activityToken,
 679             UserManager um, @Nullable Bundle arguments, @Nullable Bundle intentExtras) {
 680         UserHandle currentUser = new UserHandle(UserHandle.myUserId());
 681         IActivityManager am = ActivityManager.getService();
 682         try {
 683             String launchedFromPackage = am.getLaunchedFromPackage(activityToken);
 684             boolean launchedFromSettingsApp = SETTINGS_PACKAGE_NAME.equals(launchedFromPackage);
 685
 686             UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId(
 687                     am.getLaunchedFromUid(activityToken)));
 688             if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) {
 689                 // Check it's secure
 690                 if (isProfileOf(um, launchedFromUser)) {
 691                     return launchedFromUser;
 692                 }
 693             }
 694             UserHandle extrasUser = getUserHandleFromBundle(intentExtras);
 695             if (extrasUser != null && !extrasUser.equals(currentUser)) {
 696                 // Check it's secure
 697                 if (launchedFromSettingsApp && isProfileOf(um, extrasUser)) {
 698                     return extrasUser;
 699                 }
 700             }
 701             UserHandle argumentsUser = getUserHandleFromBundle(arguments);
 702             if (argumentsUser != null && !argumentsUser.equals(currentUser)) {
 703                 // Check it's secure
 704                 if (launchedFromSettingsApp && isProfileOf(um, argumentsUser)) {
 705                     return argumentsUser;
 706                 }
 707             }
 708         } catch (RemoteException e) {
 709             // Should not happen
 710             Log.v(TAG, "Could not talk to activity manager.", e);
 711         }
 712         return currentUser;
 713     }
 714
 715     /**
 716      * Lookup both {@link Intent#EXTRA_USER} and {@link Intent#EXTRA_USER_ID} in the bundle
 717      * and return the {@link UserHandle} object. Return {@code null} if nothing is found.
 718      */
 719     private static @Nullable UserHandle getUserHandleFromBundle(Bundle bundle) {
 720         if (bundle == null) {
 721             return null;
 722         }
 723         final UserHandle user = bundle.getParcelable(EXTRA_USER);
 724         if (user != null) {
 725             return user;
 726         }
 727         final int userId = bundle.getInt(EXTRA_USER_ID, -1);
 728         if (userId != -1) {
 729             return UserHandle.of(userId);
 730         }
 731         return null;
 732     }
 733
 734     /**
 735      * Returns the target user for a Settings activity.
 736      *
 737      * The target user can be either the current user, the user that launched this activity or
 738      * the user contained as an extra in the arguments or intent extras.
 739      *
 740      * You should use {@link #getSecureTargetUser(IBinder, UserManager, Bundle, Bundle)} if
 741      * possible.
 742      *
 743      * @see #getInsecureTargetUser(IBinder, Bundle, Bundle)
 744      */
 745    public static UserHandle getInsecureTargetUser(IBinder activityToken, @Nullable Bundle arguments,
 746            @Nullable Bundle intentExtras) {
 747        UserHandle currentUser = new UserHandle(UserHandle.myUserId());
 748        IActivityManager am = ActivityManager.getService();
 749        try {
 750            UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId(
 751                    am.getLaunchedFromUid(activityToken)));
 752            if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) {
 753                return launchedFromUser;
 754            }
 755            UserHandle extrasUser = intentExtras != null
 756                    ? (UserHandle) intentExtras.getParcelable(EXTRA_USER) : null;
 757            if (extrasUser != null && !extrasUser.equals(currentUser)) {
 758                return extrasUser;
 759            }
 760            UserHandle argumentsUser = arguments != null
 761                    ? (UserHandle) arguments.getParcelable(EXTRA_USER) : null;
 762            if (argumentsUser != null && !argumentsUser.equals(currentUser)) {
 763                return argumentsUser;
 764            }
 765        } catch (RemoteException e) {
 766            // Should not happen
 767            Log.v(TAG, "Could not talk to activity manager.", e);
 768            return null;
 769        }
 770        return currentUser;
 771    }
 772
 773    /**
 774     * Returns true if the user provided is in the same profiles group as the current user.
 775     */
 776    private static boolean isProfileOf(UserManager um, UserHandle otherUser) {
 777        if (um == null || otherUser == null) return false;
 778        return (UserHandle.myUserId() == otherUser.getIdentifier())
 779                || um.getUserProfiles().contains(otherUser);
 780    }
 781
 782     /**
 783      * Return whether or not the user should have a SIM Cards option in Settings.
 784      * TODO: Change back to returning true if count is greater than one after testing.
 785      * TODO: See bug 16533525.
 786      */
 787     public static boolean showSimCardTile(Context context) {
 788         final TelephonyManager tm =
 789                 (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
 790
 791         return tm.getSimCount() > 1;
 792     }
 793
 794     /**
 795      * Returns elapsed time for the given millis, in the following format:
 796      * 2d 5h 40m 29s
 797      * @param context the application context
 798      * @param millis the elapsed time in milli seconds
 799      * @param withSeconds include seconds?
 800      * @return the formatted elapsed time
 801      */
 802     public static CharSequence formatElapsedTime(Context context, double millis,
 803             boolean withSeconds) {
 804         SpannableStringBuilder sb = new SpannableStringBuilder();
 805         int seconds = (int) Math.floor(millis / 1000);
 806         if (!withSeconds) {
 807             // Round up.
 808             seconds += 30;
 809         }
 810
 811         int days = 0, hours = 0, minutes = 0;
 812         if (seconds >= SECONDS_PER_DAY) {
 813             days = seconds / SECONDS_PER_DAY;
 814             seconds -= days * SECONDS_PER_DAY;
 815         }
 816         if (seconds >= SECONDS_PER_HOUR) {
 817             hours = seconds / SECONDS_PER_HOUR;
 818             seconds -= hours * SECONDS_PER_HOUR;
 819         }
 820         if (seconds >= SECONDS_PER_MINUTE) {
 821             minutes = seconds / SECONDS_PER_MINUTE;
 822             seconds -= minutes * SECONDS_PER_MINUTE;
 823         }
 824         if (withSeconds) {
 825             if (days > 0) {
 826                 sb.append(context.getString(R.string.battery_history_days,
 827                         days, hours, minutes, seconds));
 828             } else if (hours > 0) {
 829                 sb.append(context.getString(R.string.battery_history_hours,
 830                         hours, minutes, seconds));
 831             } else if (minutes > 0) {
 832                 sb.append(context.getString(R.string.battery_history_minutes, minutes, seconds));
 833             } else {
 834                 sb.append(context.getString(R.string.battery_history_seconds, seconds));
 835             }
 836         } else {
 837             if (days > 0) {
 838                 sb.append(context.getString(R.string.battery_history_days_no_seconds,
 839                         days, hours, minutes));
 840             } else if (hours > 0) {
 841                 sb.append(context.getString(R.string.battery_history_hours_no_seconds,
 842                         hours, minutes));
 843             } else {
 844                 sb.append(context.getString(R.string.battery_history_minutes_no_seconds, minutes));
 845
 846                 // Add ttsSpan if it only have minute value, because it will be read as "meters"
 847                 TtsSpan ttsSpan = new TtsSpan.MeasureBuilder().setNumber(minutes)
 848                         .setUnit("minute").build();
 849                 sb.setSpan(ttsSpan, 0, sb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
 850             }
 851         }
 852
 853         return sb;
 854     }
 855
 856     /**
 857      * Queries for the UserInfo of a user. Returns null if the user doesn't exist (was removed).
 858      * @param userManager Instance of UserManager
 859      * @param checkUser The user to check the existence of.
 860      * @return UserInfo of the user or null for non-existent user.
 861      */
 862     public static UserInfo getExistingUser(UserManager userManager, UserHandle checkUser) {
 863         final List<UserInfo> users = userManager.getUsers(true /* excludeDying */);
 864         final int checkUserId = checkUser.getIdentifier();
 865         for (UserInfo user : users) {
 866             if (user.id == checkUserId) {
 867                 return user;
 868             }
 869         }
 870         return null;
 871     }
 872
 873     public static View inflateCategoryHeader(LayoutInflater inflater, ViewGroup parent) {
 874         final TypedArray a = inflater.getContext().obtainStyledAttributes(null,
 875                 com.android.internal.R.styleable.Preference,
 876                 com.android.internal.R.attr.preferenceCategoryStyle, 0);
 877         final int resId = a.getResourceId(com.android.internal.R.styleable.Preference_layout,
 878                 0);
 879         a.recycle();
 880         return inflater.inflate(resId, parent, false);
 881     }
 882
 883     /**
 884      * Return if we are running low on storage space or not.
 885      *
 886      * @param context The context
 887      * @return true if we are running low on storage space
 888      */
 889     public static boolean isLowStorage(Context context) {
 890         final StorageManager sm = StorageManager.from(context);
 891         return (sm.getStorageBytesUntilLow(context.getFilesDir()) < 0);
 892     }
 893
 894     /**
 895      * Returns a default user icon (as a {@link Bitmap}) for the given user.
 896      *
 897      * Note that for guest users, you should pass in {@code UserHandle.USER_NULL}.
 898      * @param userId the user id or {@code UserHandle.USER_NULL} for a non-user specific icon
 899      */
 900     public static Bitmap getDefaultUserIconAsBitmap(int userId) {
 901         Bitmap bitmap = null;
 902         // Try finding the corresponding bitmap in the dark bitmap cache
 903         bitmap = sDarkDefaultUserBitmapCache.get(userId);
 904         if (bitmap == null) {
 905             bitmap = UserIcons.convertToBitmap(UserIcons.getDefaultUserIcon(userId, false));
 906             // Save it to cache
 907             sDarkDefaultUserBitmapCache.put(userId, bitmap);
 908         }
 909         return bitmap;
 910     }
 911
 912     public static boolean hasPreferredActivities(PackageManager pm, String packageName) {
 913         // Get list of preferred activities
 914         List<ComponentName> prefActList = new ArrayList<>();
 915         // Intent list cannot be null. so pass empty list
 916         List<IntentFilter> intentList = new ArrayList<>();
 917         pm.getPreferredActivities(intentList, prefActList, packageName);
 918         Log.d(TAG, "Have " + prefActList.size() + " number of activities in preferred list");
 919         return prefActList.size() > 0;
 920     }
 921
 922     public static ArraySet<String> getHandledDomains(PackageManager pm, String packageName) {
 923         List<IntentFilterVerificationInfo> iviList = pm.getIntentFilterVerifications(packageName);
 924         List<IntentFilter> filters = pm.getAllIntentFilters(packageName);
 925
 926         ArraySet<String> result = new ArraySet<>();
 927         if (iviList.size() > 0) {
 928             for (IntentFilterVerificationInfo ivi : iviList) {
 929                 for (String host : ivi.getDomains()) {
 930                     result.add(host);
 931                 }
 932             }
 933         }
 934         if (filters != null && filters.size() > 0) {
 935             for (IntentFilter filter : filters) {
 936                 if (filter.hasCategory(Intent.CATEGORY_BROWSABLE)
 937                         && (filter.hasDataScheme(IntentFilter.SCHEME_HTTP) ||
 938                                 filter.hasDataScheme(IntentFilter.SCHEME_HTTPS))) {
 939                     result.addAll(filter.getHostsList());
 940                 }
 941             }
 942         }
 943         return result;
 944     }
 945
 946     public static void handleLoadingContainer(View loading, View doneLoading, boolean done,
 947             boolean animate) {
 948         setViewShown(loading, !done, animate);
 949         setViewShown(doneLoading, done, animate);
 950     }
 951
 952     private static void setViewShown(final View view, boolean shown, boolean animate) {
 953         if (animate) {
 954             Animation animation = AnimationUtils.loadAnimation(view.getContext(),
 955                     shown ? android.R.anim.fade_in : android.R.anim.fade_out);
 956             if (shown) {
 957                 view.setVisibility(View.VISIBLE);
 958             } else {
 959                 animation.setAnimationListener(new AnimationListener() {
 960                     @Override
 961                     public void onAnimationStart(Animation animation) {
 962                     }
 963
 964                     @Override
 965                     public void onAnimationRepeat(Animation animation) {
 966                     }
 967
 968                     @Override
 969                     public void onAnimationEnd(Animation animation) {
 970                         view.setVisibility(View.INVISIBLE);
 971                     }
 972                 });
 973             }
 974             view.startAnimation(animation);
 975         } else {
 976             view.clearAnimation();
 977             view.setVisibility(shown ? View.VISIBLE : View.INVISIBLE);
 978         }
 979     }
 980
 981     /**
 982      * Returns the application info of the currently installed MDM package.
 983      */
 984     public static ApplicationInfo getAdminApplicationInfo(Context context, int profileId) {
 985         DevicePolicyManager dpm =
 986                 (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);
 987         ComponentName mdmPackage = dpm.getProfileOwnerAsUser(profileId);
 988         if (mdmPackage == null) {
 989             return null;
 990         }
 991         String mdmPackageName = mdmPackage.getPackageName();
 992         try {
 993             IPackageManager ipm = AppGlobals.getPackageManager();
 994             ApplicationInfo mdmApplicationInfo =
 995                     ipm.getApplicationInfo(mdmPackageName, 0, profileId);
 996             return mdmApplicationInfo;
 997         } catch (RemoteException e) {
 998             Log.e(TAG, "Error while retrieving application info for package " + mdmPackageName
 999                     + ", userId " + profileId, e);
1000             return null;
1001         }
1002     }
1003
1004     public static boolean isBandwidthControlEnabled() {
1005         final INetworkManagementService netManager = INetworkManagementService.Stub
1006                 .asInterface(ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE));
1007         try {
1008             return netManager.isBandwidthControlEnabled();
1009         } catch (RemoteException e) {
1010             return false;
1011         }
1012     }
1013
1014     /**
1015      * Returns an accessible SpannableString.
1016      * @param displayText the text to display
1017      * @param accessibileText the text text-to-speech engines should read
1018      */
1019     public static SpannableString createAccessibleSequence(CharSequence displayText,
1020             String accessibileText) {
1021         SpannableString str = new SpannableString(displayText);
1022         str.setSpan(new TtsSpan.TextBuilder(accessibileText).build(), 0,
1023                 displayText.length(),
1024                 Spannable.SPAN_INCLUSIVE_INCLUSIVE);
1025         return str;
1026     }
1027
1028     /**
1029      * Returns the user id present in the bundle with {@link Intent#EXTRA_USER_ID} if it
1030      * belongs to the current user.
1031      *
1032      * @throws SecurityException if the given userId does not belong to the current user group.
1033      */
1034     public static int getUserIdFromBundle(Context context, Bundle bundle) {
1035         if (bundle == null) {
1036             return getCredentialOwnerUserId(context);
1037         }
1038         int userId = bundle.getInt(Intent.EXTRA_USER_ID, UserHandle.myUserId());
1039         return enforceSameOwner(context, userId);
1040     }
1041
1042     /**
1043      * Returns the given user id if it belongs to the current user.
1044      *
1045      * @throws SecurityException if the given userId does not belong to the current user group.
1046      */
1047     public static int enforceSameOwner(Context context, int userId) {
1048         final UserManager um = getUserManager(context);
1049         final int[] profileIds = um.getProfileIdsWithDisabled(UserHandle.myUserId());
1050         if (ArrayUtils.contains(profileIds, userId)) {
1051             return userId;
1052         }
1053         throw new SecurityException("Given user id " + userId + " does not belong to user "
1054                 + UserHandle.myUserId());
1055     }
1056
1057     /**
1058      * Returns the effective credential owner of the calling user.
1059      */
1060     public static int getCredentialOwnerUserId(Context context) {
1061         return getCredentialOwnerUserId(context, UserHandle.myUserId());
1062     }
1063
1064     /**
1065      * Returns the user id of the credential owner of the given user id.
1066      */
1067     public static int getCredentialOwnerUserId(Context context, int userId) {
1068         UserManager um = getUserManager(context);
1069         return um.getCredentialOwnerProfile(userId);
1070     }
1071
1072     public static int resolveResource(Context context, int attr) {
1073         TypedValue value = new TypedValue();
1074         context.getTheme().resolveAttribute(attr, value, true);
1075         return value.resourceId;
1076     }
1077
1078     private static final StringBuilder sBuilder = new StringBuilder(50);
1079     private static final java.util.Formatter sFormatter = new java.util.Formatter(
1080             sBuilder, Locale.getDefault());
1081
1082     public static String formatDateRange(Context context, long start, long end) {
1083         final int flags = FORMAT_SHOW_DATE | FORMAT_ABBREV_MONTH;
1084
1085         synchronized (sBuilder) {
1086             sBuilder.setLength(0);
1087             return DateUtils.formatDateRange(context, sFormatter, start, end, flags, null)
1088                     .toString();
1089         }
1090     }
1091
1092     public static List<String> getNonIndexable(int xml, Context context) {
1093         if (Looper.myLooper() == null) {
1094             // Hack to make sure Preferences can initialize.  Prefs expect a looper, but
1095             // don't actually use it for the basic stuff here.
1096             Looper.prepare();
1097         }
1098         final List<String> ret = new ArrayList<>();
1099         PreferenceManager manager = new PreferenceManager(context);
1100         PreferenceScreen screen = manager.inflateFromResource(context, xml, null);
1101         checkPrefs(screen, ret);
1102
1103         return ret;
1104     }
1105
1106     private static void checkPrefs(PreferenceGroup group, List<String> ret) {
1107         if (group == null) return;
1108         for (int i = 0; i < group.getPreferenceCount(); i++) {
1109             Preference pref = group.getPreference(i);
1110             if (pref instanceof SelfAvailablePreference
1111                     && !((SelfAvailablePreference) pref).isAvailable(group.getContext())) {
1112                 ret.add(pref.getKey());
1113                 if (pref instanceof PreferenceGroup) {
1114                     addAll((PreferenceGroup) pref, ret);
1115                 }
1116             } else if (pref instanceof PreferenceGroup) {
1117                 checkPrefs((PreferenceGroup) pref, ret);
1118             }
1119         }
1120     }
1121
1122     private static void addAll(PreferenceGroup group, List<String> ret) {
1123         if (group == null) return;
1124         for (int i = 0; i < group.getPreferenceCount(); i++) {
1125             Preference pref = group.getPreference(i);
1126             ret.add(pref.getKey());
1127             if (pref instanceof PreferenceGroup) {
1128                 addAll((PreferenceGroup) pref, ret);
1129             }
1130         }
1131     }
1132
1133     public static boolean isDeviceProvisioned(Context context) {
1134         return Settings.Global.getInt(context.getContentResolver(),
1135                 Settings.Global.DEVICE_PROVISIONED, 0) != 0;
1136     }
1137
1138     public static boolean startQuietModeDialogIfNecessary(Context context, UserManager um,
1139             int userId) {
1140         if (um.isQuietModeEnabled(UserHandle.of(userId))) {
1141             final Intent intent = UnlaunchableAppActivity.createInQuietModeDialogIntent(userId);
1142             context.startActivity(intent);
1143             return true;
1144         }
1145         return false;
1146     }
1147
1148     public static boolean unlockWorkProfileIfNecessary(Context context, int userId) {
1149         try {
1150             if (!ActivityManager.getService().isUserRunning(userId,
1151                     ActivityManager.FLAG_AND_LOCKED)) {
1152                 return false;
1153             }
1154         } catch (RemoteException e) {
1155             return false;
1156         }
1157         if (!(new LockPatternUtils(context)).isSecure(userId)) {
1158             return false;
1159         }
1160         return confirmWorkProfileCredentials(context, userId);
1161     }
1162
1163     public static boolean confirmWorkProfileCredentialsIfNecessary(Context context, int userId) {
1164         KeyguardManager km = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
1165         if (!km.isDeviceLocked(userId)) {
1166             return false;
1167         }
1168         return confirmWorkProfileCredentials(context, userId);
1169     }
1170
1171     private static boolean confirmWorkProfileCredentials(Context context, int userId) {
1172         final KeyguardManager km = (KeyguardManager) context.getSystemService(
1173                 Context.KEYGUARD_SERVICE);
1174         final Intent unlockIntent = km.createConfirmDeviceCredentialIntent(null, null, userId);
1175         if (unlockIntent != null) {
1176             context.startActivity(unlockIntent);
1177             return true;
1178         } else {
1179             return false;
1180         }
1181     }
1182
1183     public static CharSequence getApplicationLabel(Context context, String packageName) {
1184         try {
1185             final ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(
1186                     packageName,
1187                     PackageManager.MATCH_DISABLED_COMPONENTS
1188                     | PackageManager.MATCH_ANY_USER);
1189             return appInfo.loadLabel(context.getPackageManager());
1190         } catch (PackageManager.NameNotFoundException e) {
1191             Log.w(TAG, "Unable to find info for package: " + packageName);
1192         }
1193         return null;
1194     }
1195
1196     public static boolean isPackageDirectBootAware(Context context, String packageName) {
1197         try {
1198             final ApplicationInfo ai = context.getPackageManager().getApplicationInfo(
1199                     packageName, 0);
1200             return ai.isDirectBootAware() || ai.isPartiallyDirectBootAware();
1201         } catch (NameNotFoundException ignored) {
1202         }
1203         return false;
1204     }
1205
1206     /**
1207      * Returns a context created from the given context for the given user, or null if it fails
1208      */
1209     public static Context createPackageContextAsUser(Context context, int userId) {
1210         try {
1211             return context.createPackageContextAsUser(
1212                     context.getPackageName(), 0 /* flags */, UserHandle.of(userId));
1213         } catch (PackageManager.NameNotFoundException e) {
1214             Log.e(TAG, "Failed to create user context", e);
1215         }
1216         return null;
1217     }
1218
1219     public static FingerprintManager getFingerprintManagerOrNull(Context context) {
1220         if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
1221             return context.getSystemService(FingerprintManager.class);
1222         } else {
1223             return null;
1224         }
1225     }
1226
1227     public static IFingerprintManager getFingerprintManagerWrapperOrNull(Context context) {
1228         FingerprintManager fingerprintManager = getFingerprintManagerOrNull(context);
1229         if (fingerprintManager != null) {
1230             return new FingerprintManagerWrapper(fingerprintManager);
1231         } else {
1232             return null;
1233         }
1234     }
1235
1236     /**
1237      * Launches an intent which may optionally have a user id defined.
1238      * @param fragment Fragment to use to launch the activity.
1239      * @param intent Intent to launch.
1240      */
1241     public static void launchIntent(Fragment fragment, Intent intent) {
1242         try {
1243             final int userId = intent.getIntExtra(Intent.EXTRA_USER_ID, -1);
1244
1245             if (userId == -1) {
1246                 fragment.startActivity(intent);
1247             } else {
1248                 fragment.getActivity().startActivityAsUser(intent, new UserHandle(userId));
1249             }
1250         } catch (ActivityNotFoundException e) {
1251             Log.w(TAG, "No activity found for " + intent);
1252         }
1253     }
1254
1255     public static boolean isCarrierDemoUser(Context context) {
1256         final String carrierDemoModeSetting =
1257                 context.getString(com.android.internal.R.string.config_carrierDemoModeSetting);
1258         return UserManager.isDeviceInDemoMode(context)
1259                 && getUserManager(context).isDemoUser()
1260                 && !TextUtils.isEmpty(carrierDemoModeSetting)
1261                 && (Settings.Secure.getInt(context.getContentResolver(),
1262                         carrierDemoModeSetting, 0) == 1);
1263     }
1264
1265     /**
1266      * Returns if a given user is a profile of another user.
1267      * @param user The user whose profiles will be checked.
1268      * @param profile The (potential) profile.
1269      * @return if the profile is actually a profile
1270      */
1271     public static boolean isProfileOf(UserInfo user, UserInfo profile) {
1272         return user.id == profile.id ||
1273                 (user.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID
1274                         && user.profileGroupId == profile.profileGroupId);
1275     }
1276
1277     /**
1278      * Tries to initalize a volume with the given bundle. If it is a valid, private, and readable
1279      * {@link VolumeInfo}, it is returned. If it is not valid, null is returned.
1280      */
1281     @Nullable
1282     public static VolumeInfo maybeInitializeVolume(StorageManager sm, Bundle bundle) {
1283         final String volumeId = bundle.getString(VolumeInfo.EXTRA_VOLUME_ID,
1284                 VolumeInfo.ID_PRIVATE_INTERNAL);
1285         VolumeInfo volume = sm.findVolumeById(volumeId);
1286         return isVolumeValid(volume) ? volume : null;
1287     }
1288
1289     /**
1290      * Return the resource id to represent the install status for an app
1291      */
1292     @StringRes
1293     public static int getInstallationStatus(ApplicationInfo info) {
1294         if ((info.flags & ApplicationInfo.FLAG_INSTALLED) == 0) {
1295             return R.string.not_installed;
1296         }
1297         return info.enabled ? R.string.installed : R.string.disabled;
1298     }
1299
1300     /**
1301      * Control if other apps can display overlays. By default this is allowed. Be sure to
1302      * re-enable overlays, as the effect is system-wide.
1303      */
1304     public static void setOverlayAllowed(Context context, IBinder token, boolean allowed) {
1305         AppOpsManager appOpsManager = context.getSystemService(AppOpsManager.class);
1306         if (appOpsManager != null) {
1307             appOpsManager.setUserRestriction(AppOpsManager.OP_SYSTEM_ALERT_WINDOW,
1308                     !allowed, token);
1309             appOpsManager.setUserRestriction(AppOpsManager.OP_TOAST_WINDOW,
1310                     !allowed, token);
1311         }
1312     }
1313
1314
1315
1316     private static boolean isVolumeValid(VolumeInfo volume) {
1317         return (volume != null) && (volume.getType() == VolumeInfo.TYPE_PRIVATE)
1318                 && volume.isMountedReadable();
1319     }
1320
1321 }