| /** |
| * Copyright (C) 2007 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy |
| * of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package com.android.settings; |
| |
| import static android.content.Intent.EXTRA_USER; |
| |
| import android.annotation.Nullable; |
| import android.app.ActivityManager; |
| import android.app.ActivityManagerNative; |
| import android.app.AlertDialog; |
| import android.app.Dialog; |
| import android.app.Fragment; |
| import android.app.IActivityManager; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageInfo; |
| import android.content.pm.PackageManager; |
| import android.content.pm.PackageManager.NameNotFoundException; |
| import android.content.pm.ResolveInfo; |
| import android.content.pm.Signature; |
| import android.content.pm.UserInfo; |
| import android.content.res.Resources; |
| import android.content.res.Resources.NotFoundException; |
| import android.database.Cursor; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.graphics.drawable.Drawable; |
| import android.net.ConnectivityManager; |
| import android.net.LinkProperties; |
| import android.net.Uri; |
| import android.os.BatteryManager; |
| import android.os.Bundle; |
| import android.os.IBinder; |
| import android.os.RemoteException; |
| import android.os.UserHandle; |
| import android.os.UserManager; |
| import android.preference.Preference; |
| import android.preference.PreferenceFrameLayout; |
| import android.preference.PreferenceGroup; |
| import android.provider.ContactsContract.CommonDataKinds; |
| import android.provider.ContactsContract.Contacts; |
| import android.provider.ContactsContract.Data; |
| import android.provider.ContactsContract.Profile; |
| import android.provider.ContactsContract.RawContacts; |
| import android.service.persistentdata.PersistentDataBlockManager; |
| import android.telephony.SubscriptionInfo; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyManager; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.widget.ListView; |
| import android.widget.TabWidget; |
| |
| import com.android.internal.util.UserIcons; |
| import com.android.settings.UserSpinnerAdapter.UserDetails; |
| import com.android.settings.dashboard.DashboardTile; |
| import com.android.settings.drawable.CircleFramedDrawable; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.InetAddress; |
| import java.text.NumberFormat; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Locale; |
| |
| public final class Utils { |
| private static final String TAG = "Settings"; |
| |
| /** |
| * Set the preference's title to the matching activity's label. |
| */ |
| public static final int UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY = 1; |
| |
| /** |
| * The opacity level of a disabled icon. |
| */ |
| public static final float DISABLED_ALPHA = 0.4f; |
| |
| /** |
| * Color spectrum to use to indicate badness. 0 is completely transparent (no data), |
| * 1 is most bad (red), the last value is least bad (green). |
| */ |
| public static final int[] BADNESS_COLORS = new int[] { |
| 0x00000000, 0xffc43828, 0xffe54918, 0xfff47b00, |
| 0xfffabf2c, 0xff679e37, 0xff0a7f42 |
| }; |
| |
| /** |
| * Name of the meta-data item that should be set in the AndroidManifest.xml |
| * to specify the icon that should be displayed for the preference. |
| */ |
| private static final String META_DATA_PREFERENCE_ICON = "com.android.settings.icon"; |
| |
| /** |
| * Name of the meta-data item that should be set in the AndroidManifest.xml |
| * to specify the title that should be displayed for the preference. |
| */ |
| private static final String META_DATA_PREFERENCE_TITLE = "com.android.settings.title"; |
| |
| /** |
| * Name of the meta-data item that should be set in the AndroidManifest.xml |
| * to specify the summary text that should be displayed for the preference. |
| */ |
| private static final String META_DATA_PREFERENCE_SUMMARY = "com.android.settings.summary"; |
| |
| private static final String SETTINGS_PACKAGE_NAME = "com.android.settings"; |
| |
| private static final int SECONDS_PER_MINUTE = 60; |
| private static final int SECONDS_PER_HOUR = 60 * 60; |
| private static final int SECONDS_PER_DAY = 24 * 60 * 60; |
| |
| /** |
| * Finds a matching activity for a preference's intent. If a matching |
| * activity is not found, it will remove the preference. |
| * |
| * @param context The context. |
| * @param parentPreferenceGroup The preference group that contains the |
| * preference whose intent is being resolved. |
| * @param preferenceKey The key of the preference whose intent is being |
| * resolved. |
| * @param flags 0 or one or more of |
| * {@link #UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY} |
| * . |
| * @return Whether an activity was found. If false, the preference was |
| * removed. |
| */ |
| public static boolean updatePreferenceToSpecificActivityOrRemove(Context context, |
| PreferenceGroup parentPreferenceGroup, String preferenceKey, int flags) { |
| |
| Preference preference = parentPreferenceGroup.findPreference(preferenceKey); |
| if (preference == null) { |
| return false; |
| } |
| |
| Intent intent = preference.getIntent(); |
| if (intent != null) { |
| // Find the activity that is in the system image |
| PackageManager pm = context.getPackageManager(); |
| List<ResolveInfo> list = pm.queryIntentActivities(intent, 0); |
| int listSize = list.size(); |
| for (int i = 0; i < listSize; i++) { |
| ResolveInfo resolveInfo = list.get(i); |
| if ((resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) |
| != 0) { |
| |
| // Replace the intent with this specific activity |
| preference.setIntent(new Intent().setClassName( |
| resolveInfo.activityInfo.packageName, |
| resolveInfo.activityInfo.name)); |
| |
| if ((flags & UPDATE_PREFERENCE_FLAG_SET_TITLE_TO_MATCHING_ACTIVITY) != 0) { |
| // Set the preference title to the activity's label |
| preference.setTitle(resolveInfo.loadLabel(pm)); |
| } |
| |
| return true; |
| } |
| } |
| } |
| |
| // Did not find a matching activity, so remove the preference |
| parentPreferenceGroup.removePreference(preference); |
| |
| return false; |
| } |
| |
| public static boolean updateTileToSpecificActivityFromMetaDataOrRemove(Context context, |
| DashboardTile tile) { |
| |
| Intent intent = tile.intent; |
| if (intent != null) { |
| // Find the activity that is in the system image |
| PackageManager pm = context.getPackageManager(); |
| List<ResolveInfo> list = pm.queryIntentActivities(intent, PackageManager.GET_META_DATA); |
| int listSize = list.size(); |
| for (int i = 0; i < listSize; i++) { |
| ResolveInfo resolveInfo = list.get(i); |
| if ((resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) |
| != 0) { |
| Drawable icon = null; |
| String title = null; |
| String summary = null; |
| |
| // Get the activity's meta-data |
| try { |
| Resources res = pm.getResourcesForApplication( |
| resolveInfo.activityInfo.packageName); |
| Bundle metaData = resolveInfo.activityInfo.metaData; |
| |
| if (res != null && metaData != null) { |
| icon = res.getDrawable( |
| metaData.getInt(META_DATA_PREFERENCE_ICON), null); |
| title = res.getString(metaData.getInt(META_DATA_PREFERENCE_TITLE)); |
| summary = res.getString(metaData.getInt(META_DATA_PREFERENCE_SUMMARY)); |
| } |
| } catch (NameNotFoundException e) { |
| // Ignore |
| } catch (NotFoundException e) { |
| // Ignore |
| } |
| |
| // Set the preference title to the activity's label if no |
| // meta-data is found |
| if (TextUtils.isEmpty(title)) { |
| title = resolveInfo.loadLabel(pm).toString(); |
| } |
| |
| // Set icon, title and summary for the preference |
| // TODO: |
| //tile.icon = icon; |
| tile.title = title; |
| tile.summary = summary; |
| // Replace the intent with this specific activity |
| tile.intent = new Intent().setClassName(resolveInfo.activityInfo.packageName, |
| resolveInfo.activityInfo.name); |
| |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Returns true if Monkey is running. |
| */ |
| public static boolean isMonkeyRunning() { |
| return ActivityManager.isUserAMonkey(); |
| } |
| |
| /** |
| * Returns whether the device is voice-capable (meaning, it is also a phone). |
| */ |
| public static boolean isVoiceCapable(Context context) { |
| TelephonyManager telephony = |
| (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); |
| return telephony != null && telephony.isVoiceCapable(); |
| } |
| |
| public static boolean isWifiOnly(Context context) { |
| ConnectivityManager cm = (ConnectivityManager)context.getSystemService( |
| Context.CONNECTIVITY_SERVICE); |
| return (cm.isNetworkSupported(ConnectivityManager.TYPE_MOBILE) == false); |
| } |
| |
| /** |
| * Returns the WIFI IP Addresses, if any, taking into account IPv4 and IPv6 style addresses. |
| * @param context the application context |
| * @return the formatted and newline-separated IP addresses, or null if none. |
| */ |
| public static String getWifiIpAddresses(Context context) { |
| ConnectivityManager cm = (ConnectivityManager) |
| context.getSystemService(Context.CONNECTIVITY_SERVICE); |
| LinkProperties prop = cm.getLinkProperties(ConnectivityManager.TYPE_WIFI); |
| return formatIpAddresses(prop); |
| } |
| |
| /** |
| * Returns the default link's IP addresses, if any, taking into account IPv4 and IPv6 style |
| * addresses. |
| * @param context the application context |
| * @return the formatted and newline-separated IP addresses, or null if none. |
| */ |
| public static String getDefaultIpAddresses(ConnectivityManager cm) { |
| LinkProperties prop = cm.getActiveLinkProperties(); |
| return formatIpAddresses(prop); |
| } |
| |
| private static String formatIpAddresses(LinkProperties prop) { |
| if (prop == null) return null; |
| Iterator<InetAddress> iter = prop.getAllAddresses().iterator(); |
| // If there are no entries, return null |
| if (!iter.hasNext()) return null; |
| // Concatenate all available addresses, comma separated |
| String addresses = ""; |
| while (iter.hasNext()) { |
| addresses += iter.next().getHostAddress(); |
| if (iter.hasNext()) addresses += "\n"; |
| } |
| return addresses; |
| } |
| |
| public static Locale createLocaleFromString(String localeStr) { |
| // TODO: is there a better way to actually construct a locale that will match? |
| // The main problem is, on top of Java specs, locale.toString() and |
| // new Locale(locale.toString()).toString() do not return equal() strings in |
| // many cases, because the constructor takes the only string as the language |
| // code. So : new Locale("en", "US").toString() => "en_US" |
| // And : new Locale("en_US").toString() => "en_us" |
| if (null == localeStr) |
| return Locale.getDefault(); |
| String[] brokenDownLocale = localeStr.split("_", 3); |
| // split may not return a 0-length array. |
| if (1 == brokenDownLocale.length) { |
| return new Locale(brokenDownLocale[0]); |
| } else if (2 == brokenDownLocale.length) { |
| return new Locale(brokenDownLocale[0], brokenDownLocale[1]); |
| } else { |
| return new Locale(brokenDownLocale[0], brokenDownLocale[1], brokenDownLocale[2]); |
| } |
| } |
| |
| /** Formats the ratio of amount/total as a percentage. */ |
| public static String formatPercentage(long amount, long total) { |
| return formatPercentage(((double) amount) / total); |
| } |
| |
| /** Formats an integer from 0..100 as a percentage. */ |
| public static String formatPercentage(int percentage) { |
| return formatPercentage(((double) percentage) / 100.0); |
| } |
| |
| /** Formats a double from 0.0..1.0 as a percentage. */ |
| private static String formatPercentage(double percentage) { |
| return NumberFormat.getPercentInstance().format(percentage); |
| } |
| |
| public static boolean isBatteryPresent(Intent batteryChangedIntent) { |
| return batteryChangedIntent.getBooleanExtra(BatteryManager.EXTRA_PRESENT, true); |
| } |
| |
| public static String getBatteryPercentage(Intent batteryChangedIntent) { |
| return formatPercentage(getBatteryLevel(batteryChangedIntent)); |
| } |
| |
| public static int getBatteryLevel(Intent batteryChangedIntent) { |
| int level = batteryChangedIntent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0); |
| int scale = batteryChangedIntent.getIntExtra(BatteryManager.EXTRA_SCALE, 100); |
| return (level * 100) / scale; |
| } |
| |
| public static String getBatteryStatus(Resources res, Intent batteryChangedIntent) { |
| final Intent intent = batteryChangedIntent; |
| |
| int plugType = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0); |
| int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, |
| BatteryManager.BATTERY_STATUS_UNKNOWN); |
| String statusString; |
| if (status == BatteryManager.BATTERY_STATUS_CHARGING) { |
| int resId; |
| if (plugType == BatteryManager.BATTERY_PLUGGED_AC) { |
| resId = R.string.battery_info_status_charging_ac; |
| } else if (plugType == BatteryManager.BATTERY_PLUGGED_USB) { |
| resId = R.string.battery_info_status_charging_usb; |
| } else if (plugType == BatteryManager.BATTERY_PLUGGED_WIRELESS) { |
| resId = R.string.battery_info_status_charging_wireless; |
| } else { |
| resId = R.string.battery_info_status_charging; |
| } |
| statusString = res.getString(resId); |
| } else if (status == BatteryManager.BATTERY_STATUS_DISCHARGING) { |
| statusString = res.getString(R.string.battery_info_status_discharging); |
| } else if (status == BatteryManager.BATTERY_STATUS_NOT_CHARGING) { |
| statusString = res.getString(R.string.battery_info_status_not_charging); |
| } else if (status == BatteryManager.BATTERY_STATUS_FULL) { |
| statusString = res.getString(R.string.battery_info_status_full); |
| } else { |
| statusString = res.getString(R.string.battery_info_status_unknown); |
| } |
| |
| return statusString; |
| } |
| |
| public static void forcePrepareCustomPreferencesList( |
| ViewGroup parent, View child, ListView list, boolean ignoreSidePadding) { |
| list.setScrollBarStyle(View.SCROLLBARS_OUTSIDE_OVERLAY); |
| list.setClipToPadding(false); |
| prepareCustomPreferencesList(parent, child, list, ignoreSidePadding); |
| } |
| |
| /** |
| * Prepare a custom preferences layout, moving padding to {@link ListView} |
| * when outside scrollbars are requested. Usually used to display |
| * {@link ListView} and {@link TabWidget} with correct padding. |
| */ |
| public static void prepareCustomPreferencesList( |
| ViewGroup parent, View child, View list, boolean ignoreSidePadding) { |
| final boolean movePadding = list.getScrollBarStyle() == View.SCROLLBARS_OUTSIDE_OVERLAY; |
| if (movePadding) { |
| final Resources res = list.getResources(); |
| final int paddingSide = res.getDimensionPixelSize(R.dimen.settings_side_margin); |
| final int paddingBottom = res.getDimensionPixelSize( |
| com.android.internal.R.dimen.preference_fragment_padding_bottom); |
| |
| if (parent instanceof PreferenceFrameLayout) { |
| ((PreferenceFrameLayout.LayoutParams) child.getLayoutParams()).removeBorders = true; |
| |
| final int effectivePaddingSide = ignoreSidePadding ? 0 : paddingSide; |
| list.setPaddingRelative(effectivePaddingSide, 0, effectivePaddingSide, paddingBottom); |
| } else { |
| list.setPaddingRelative(paddingSide, 0, paddingSide, paddingBottom); |
| } |
| } |
| } |
| |
| public static void forceCustomPadding(View view, boolean additive) { |
| final Resources res = view.getResources(); |
| final int paddingSide = res.getDimensionPixelSize(R.dimen.settings_side_margin); |
| |
| final int paddingStart = paddingSide + (additive ? view.getPaddingStart() : 0); |
| final int paddingEnd = paddingSide + (additive ? view.getPaddingEnd() : 0); |
| final int paddingBottom = res.getDimensionPixelSize( |
| com.android.internal.R.dimen.preference_fragment_padding_bottom); |
| |
| view.setPaddingRelative(paddingStart, 0, paddingEnd, paddingBottom); |
| } |
| |
| /** |
| * Return string resource that best describes combination of tethering |
| * options available on this device. |
| */ |
| public static int getTetheringLabel(ConnectivityManager cm) { |
| String[] usbRegexs = cm.getTetherableUsbRegexs(); |
| String[] wifiRegexs = cm.getTetherableWifiRegexs(); |
| String[] bluetoothRegexs = cm.getTetherableBluetoothRegexs(); |
| |
| boolean usbAvailable = usbRegexs.length != 0; |
| boolean wifiAvailable = wifiRegexs.length != 0; |
| boolean bluetoothAvailable = bluetoothRegexs.length != 0; |
| |
| if (wifiAvailable && usbAvailable && bluetoothAvailable) { |
| return R.string.tether_settings_title_all; |
| } else if (wifiAvailable && usbAvailable) { |
| return R.string.tether_settings_title_all; |
| } else if (wifiAvailable && bluetoothAvailable) { |
| return R.string.tether_settings_title_all; |
| } else if (wifiAvailable) { |
| return R.string.tether_settings_title_wifi; |
| } else if (usbAvailable && bluetoothAvailable) { |
| return R.string.tether_settings_title_usb_bluetooth; |
| } else if (usbAvailable) { |
| return R.string.tether_settings_title_usb; |
| } else { |
| return R.string.tether_settings_title_bluetooth; |
| } |
| } |
| |
| /* Used by UserSettings as well. Call this on a non-ui thread. */ |
| public static boolean copyMeProfilePhoto(Context context, UserInfo user) { |
| Uri contactUri = Profile.CONTENT_URI; |
| |
| InputStream avatarDataStream = Contacts.openContactPhotoInputStream( |
| context.getContentResolver(), |
| contactUri, true); |
| // If there's no profile photo, assign a default avatar |
| if (avatarDataStream == null) { |
| return false; |
| } |
| int userId = user != null ? user.id : UserHandle.myUserId(); |
| UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE); |
| Bitmap icon = BitmapFactory.decodeStream(avatarDataStream); |
| um.setUserIcon(userId, icon); |
| try { |
| avatarDataStream.close(); |
| } catch (IOException ioe) { } |
| return true; |
| } |
| |
| public static String getMeProfileName(Context context, boolean full) { |
| if (full) { |
| return getProfileDisplayName(context); |
| } else { |
| return getShorterNameIfPossible(context); |
| } |
| } |
| |
| private static String getShorterNameIfPossible(Context context) { |
| final String given = getLocalProfileGivenName(context); |
| return !TextUtils.isEmpty(given) ? given : getProfileDisplayName(context); |
| } |
| |
| private static String getLocalProfileGivenName(Context context) { |
| final ContentResolver cr = context.getContentResolver(); |
| |
| // Find the raw contact ID for the local ME profile raw contact. |
| final long localRowProfileId; |
| final Cursor localRawProfile = cr.query( |
| Profile.CONTENT_RAW_CONTACTS_URI, |
| new String[] {RawContacts._ID}, |
| RawContacts.ACCOUNT_TYPE + " IS NULL AND " + |
| RawContacts.ACCOUNT_NAME + " IS NULL", |
| null, null); |
| if (localRawProfile == null) return null; |
| |
| try { |
| if (!localRawProfile.moveToFirst()) { |
| return null; |
| } |
| localRowProfileId = localRawProfile.getLong(0); |
| } finally { |
| localRawProfile.close(); |
| } |
| |
| // Find the structured name for the raw contact. |
| final Cursor structuredName = cr.query( |
| Profile.CONTENT_URI.buildUpon().appendPath(Contacts.Data.CONTENT_DIRECTORY).build(), |
| new String[] {CommonDataKinds.StructuredName.GIVEN_NAME, |
| CommonDataKinds.StructuredName.FAMILY_NAME}, |
| Data.RAW_CONTACT_ID + "=" + localRowProfileId, |
| null, null); |
| if (structuredName == null) return null; |
| |
| try { |
| if (!structuredName.moveToFirst()) { |
| return null; |
| } |
| String partialName = structuredName.getString(0); |
| if (TextUtils.isEmpty(partialName)) { |
| partialName = structuredName.getString(1); |
| } |
| return partialName; |
| } finally { |
| structuredName.close(); |
| } |
| } |
| |
| private static final String getProfileDisplayName(Context context) { |
| final ContentResolver cr = context.getContentResolver(); |
| final Cursor profile = cr.query(Profile.CONTENT_URI, |
| new String[] {Profile.DISPLAY_NAME}, null, null, null); |
| if (profile == null) return null; |
| |
| try { |
| if (!profile.moveToFirst()) { |
| return null; |
| } |
| return profile.getString(0); |
| } finally { |
| profile.close(); |
| } |
| } |
| |
| /** Not global warming, it's global change warning. */ |
| public static Dialog buildGlobalChangeWarningDialog(final Context context, int titleResId, |
| final Runnable positiveAction) { |
| final AlertDialog.Builder builder = new AlertDialog.Builder(context); |
| builder.setTitle(titleResId); |
| builder.setMessage(R.string.global_change_warning); |
| builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| positiveAction.run(); |
| } |
| }); |
| builder.setNegativeButton(android.R.string.cancel, null); |
| |
| return builder.create(); |
| } |
| |
| public static boolean hasMultipleUsers(Context context) { |
| return ((UserManager) context.getSystemService(Context.USER_SERVICE)) |
| .getUsers().size() > 1; |
| } |
| |
| /** |
| * Start a new instance of the activity, showing only the given fragment. |
| * When launched in this mode, the given preference fragment will be instantiated and fill the |
| * entire activity. |
| * |
| * @param context The context. |
| * @param fragmentName The name of the fragment to display. |
| * @param args Optional arguments to supply to the fragment. |
| * @param resultTo Option fragment that should receive the result of the activity launch. |
| * @param resultRequestCode If resultTo is non-null, this is the request code in which |
| * to report the result. |
| * @param titleResId resource id for the String to display for the title of this set |
| * of preferences. |
| * @param title String to display for the title of this set of preferences. |
| */ |
| public static void startWithFragment(Context context, String fragmentName, Bundle args, |
| Fragment resultTo, int resultRequestCode, int titleResId, CharSequence title) { |
| startWithFragment(context, fragmentName, args, resultTo, resultRequestCode, |
| titleResId, title, false /* not a shortcut */); |
| } |
| |
| public static void startWithFragment(Context context, String fragmentName, Bundle args, |
| Fragment resultTo, int resultRequestCode, int titleResId, CharSequence title, |
| boolean isShortcut) { |
| Intent intent = onBuildStartFragmentIntent(context, fragmentName, args, titleResId, |
| title, isShortcut); |
| if (resultTo == null) { |
| context.startActivity(intent); |
| } else { |
| resultTo.startActivityForResult(intent, resultRequestCode); |
| } |
| } |
| |
| public static void startWithFragmentAsUser(Context context, String fragmentName, Bundle args, |
| int titleResId, CharSequence title, boolean isShortcut, UserHandle userHandle) { |
| Intent intent = onBuildStartFragmentIntent(context, fragmentName, args, titleResId, |
| title, isShortcut); |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK); |
| context.startActivityAsUser(intent, userHandle); |
| } |
| |
| /** |
| * Build an Intent to launch a new activity showing the selected fragment. |
| * The implementation constructs an Intent that re-launches the current activity with the |
| * appropriate arguments to display the fragment. |
| * |
| * |
| * @param context The Context. |
| * @param fragmentName The name of the fragment to display. |
| * @param args Optional arguments to supply to the fragment. |
| * @param titleResId Optional title resource id to show for this item. |
| * @param title Optional title to show for this item. |
| * @param isShortcut tell if this is a Launcher Shortcut or not |
| * @return Returns an Intent that can be launched to display the given |
| * fragment. |
| */ |
| public static Intent onBuildStartFragmentIntent(Context context, String fragmentName, |
| Bundle args, int titleResId, CharSequence title, boolean isShortcut) { |
| Intent intent = new Intent(Intent.ACTION_MAIN); |
| intent.setClass(context, SubSettings.class); |
| intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT, fragmentName); |
| intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS, args); |
| intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RESID, titleResId); |
| intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE, title); |
| intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_AS_SHORTCUT, isShortcut); |
| return intent; |
| } |
| |
| /** |
| * Returns the managed profile of the current user or null if none found. |
| */ |
| public static UserHandle getManagedProfile(UserManager userManager) { |
| List<UserHandle> userProfiles = userManager.getUserProfiles(); |
| final int count = userProfiles.size(); |
| for (int i = 0; i < count; i++) { |
| final UserHandle profile = userProfiles.get(i); |
| if (profile.getIdentifier() == userManager.getUserHandle()) { |
| continue; |
| } |
| final UserInfo userInfo = userManager.getUserInfo(profile.getIdentifier()); |
| if (userInfo.isManagedProfile()) { |
| return profile; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns true if the current profile is a managed one. |
| */ |
| public static boolean isManagedProfile(UserManager userManager) { |
| UserInfo currentUser = userManager.getUserInfo(userManager.getUserHandle()); |
| return currentUser.isManagedProfile(); |
| } |
| |
| /** |
| * Creates a {@link UserSpinnerAdapter} if there is more than one profile on the device. |
| * |
| * <p> The adapter can be used to populate a spinner that switches between the Settings |
| * app on the different profiles. |
| * |
| * @return a {@link UserSpinnerAdapter} or null if there is only one profile. |
| */ |
| public static UserSpinnerAdapter createUserSpinnerAdapter(UserManager userManager, |
| Context context) { |
| List<UserHandle> userProfiles = userManager.getUserProfiles(); |
| if (userProfiles.size() < 2) { |
| return null; |
| } |
| |
| UserHandle myUserHandle = new UserHandle(UserHandle.myUserId()); |
| // The first option should be the current profile |
| userProfiles.remove(myUserHandle); |
| userProfiles.add(0, myUserHandle); |
| |
| ArrayList<UserDetails> userDetails = new ArrayList<UserDetails>(userProfiles.size()); |
| final int count = userProfiles.size(); |
| for (int i = 0; i < count; i++) { |
| userDetails.add(new UserDetails(userProfiles.get(i), userManager, context)); |
| } |
| return new UserSpinnerAdapter(context, userDetails); |
| } |
| |
| /** |
| * Returns the target user for a Settings activity. |
| * |
| * The target user can be either the current user, the user that launched this activity or |
| * the user contained as an extra in the arguments or intent extras. |
| * |
| * Note: This is secure in the sense that it only returns a target user different to the current |
| * one if the app launching this activity is the Settings app itself, running in the same user |
| * or in one that is in the same profile group, or if the user id is provided by the system. |
| */ |
| public static UserHandle getSecureTargetUser(IBinder activityToken, |
| UserManager um, @Nullable Bundle arguments, @Nullable Bundle intentExtras) { |
| UserHandle currentUser = new UserHandle(UserHandle.myUserId()); |
| IActivityManager am = ActivityManagerNative.getDefault(); |
| try { |
| String launchedFromPackage = am.getLaunchedFromPackage(activityToken); |
| boolean launchedFromSettingsApp = SETTINGS_PACKAGE_NAME.equals(launchedFromPackage); |
| |
| UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId( |
| am.getLaunchedFromUid(activityToken))); |
| if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) { |
| // Check it's secure |
| if (isProfileOf(um, launchedFromUser)) { |
| return launchedFromUser; |
| } |
| } |
| UserHandle extrasUser = intentExtras != null |
| ? (UserHandle) intentExtras.getParcelable(EXTRA_USER) : null; |
| if (extrasUser != null && !extrasUser.equals(currentUser)) { |
| // Check it's secure |
| if (launchedFromSettingsApp && isProfileOf(um, extrasUser)) { |
| return extrasUser; |
| } |
| } |
| UserHandle argumentsUser = arguments != null |
| ? (UserHandle) arguments.getParcelable(EXTRA_USER) : null; |
| if (argumentsUser != null && !argumentsUser.equals(currentUser)) { |
| // Check it's secure |
| if (launchedFromSettingsApp && isProfileOf(um, argumentsUser)) { |
| return argumentsUser; |
| } |
| } |
| } catch (RemoteException e) { |
| // Should not happen |
| Log.v(TAG, "Could not talk to activity manager.", e); |
| } |
| return currentUser; |
| } |
| |
| /** |
| * Returns the target user for a Settings activity. |
| * |
| * The target user can be either the current user, the user that launched this activity or |
| * the user contained as an extra in the arguments or intent extras. |
| * |
| * You should use {@link #getSecureTargetUser(IBinder, UserManager, Bundle, Bundle)} if |
| * possible. |
| * |
| * @see #getInsecureTargetUser(IBinder, Bundle, Bundle) |
| */ |
| public static UserHandle getInsecureTargetUser(IBinder activityToken, @Nullable Bundle arguments, |
| @Nullable Bundle intentExtras) { |
| UserHandle currentUser = new UserHandle(UserHandle.myUserId()); |
| IActivityManager am = ActivityManagerNative.getDefault(); |
| try { |
| UserHandle launchedFromUser = new UserHandle(UserHandle.getUserId( |
| am.getLaunchedFromUid(activityToken))); |
| if (launchedFromUser != null && !launchedFromUser.equals(currentUser)) { |
| return launchedFromUser; |
| } |
| UserHandle extrasUser = intentExtras != null |
| ? (UserHandle) intentExtras.getParcelable(EXTRA_USER) : null; |
| if (extrasUser != null && !extrasUser.equals(currentUser)) { |
| return extrasUser; |
| } |
| UserHandle argumentsUser = arguments != null |
| ? (UserHandle) arguments.getParcelable(EXTRA_USER) : null; |
| if (argumentsUser != null && !argumentsUser.equals(currentUser)) { |
| return argumentsUser; |
| } |
| } catch (RemoteException e) { |
| // Should not happen |
| Log.v(TAG, "Could not talk to activity manager.", e); |
| return null; |
| } |
| return currentUser; |
| } |
| |
| /** |
| * Returns true if the user provided is in the same profiles group as the current user. |
| */ |
| private static boolean isProfileOf(UserManager um, UserHandle otherUser) { |
| if (um == null || otherUser == null) return false; |
| return (UserHandle.myUserId() == otherUser.getIdentifier()) |
| || um.getUserProfiles().contains(otherUser); |
| } |
| |
| /** |
| * Creates a dialog to confirm with the user if it's ok to remove the user |
| * and delete all the data. |
| * |
| * @param context a Context object |
| * @param removingUserId The userId of the user to remove |
| * @param onConfirmListener Callback object for positive action |
| * @return the created Dialog |
| */ |
| public static Dialog createRemoveConfirmationDialog(Context context, int removingUserId, |
| DialogInterface.OnClickListener onConfirmListener) { |
| UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE); |
| UserInfo userInfo = um.getUserInfo(removingUserId); |
| int titleResId; |
| int messageResId; |
| if (UserHandle.myUserId() == removingUserId) { |
| titleResId = R.string.user_confirm_remove_self_title; |
| messageResId = R.string.user_confirm_remove_self_message; |
| } else if (userInfo.isRestricted()) { |
| titleResId = R.string.user_profile_confirm_remove_title; |
| messageResId = R.string.user_profile_confirm_remove_message; |
| } else if (userInfo.isManagedProfile()) { |
| titleResId = R.string.work_profile_confirm_remove_title; |
| messageResId = R.string.work_profile_confirm_remove_message; |
| } else { |
| titleResId = R.string.user_confirm_remove_title; |
| messageResId = R.string.user_confirm_remove_message; |
| } |
| Dialog dlg = new AlertDialog.Builder(context) |
| .setTitle(titleResId) |
| .setMessage(messageResId) |
| .setPositiveButton(R.string.user_delete_button, |
| onConfirmListener) |
| .setNegativeButton(android.R.string.cancel, null) |
| .create(); |
| return dlg; |
| } |
| |
| /** |
| * Returns whether or not this device is able to be OEM unlocked. |
| */ |
| static boolean isOemUnlockEnabled(Context context) { |
| PersistentDataBlockManager manager =(PersistentDataBlockManager) |
| context.getSystemService(Context.PERSISTENT_DATA_BLOCK_SERVICE); |
| return manager.getOemUnlockEnabled(); |
| } |
| |
| /** |
| * Allows enabling or disabling OEM unlock on this device. OEM unlocked |
| * devices allow users to flash other OSes to them. |
| */ |
| static void setOemUnlockEnabled(Context context, boolean enabled) { |
| PersistentDataBlockManager manager =(PersistentDataBlockManager) |
| context.getSystemService(Context.PERSISTENT_DATA_BLOCK_SERVICE); |
| manager.setOemUnlockEnabled(enabled); |
| } |
| |
| /** |
| * Returns a circular icon for a user. |
| */ |
| public static Drawable getUserIcon(Context context, UserManager um, UserInfo user) { |
| if (user.isManagedProfile()) { |
| // We use predefined values for managed profiles |
| Bitmap b = BitmapFactory.decodeResource(context.getResources(), |
| com.android.internal.R.drawable.ic_corp_icon); |
| return CircleFramedDrawable.getInstance(context, b); |
| } |
| if (user.iconPath != null) { |
| Bitmap icon = um.getUserIcon(user.id); |
| if (icon != null) { |
| return CircleFramedDrawable.getInstance(context, icon); |
| } |
| } |
| return UserIcons.getDefaultUserIcon(user.id, /* light= */ false); |
| } |
| |
| /** |
| * Returns a label for the user, in the form of "User: user name" or "Work profile". |
| */ |
| public static String getUserLabel(Context context, UserInfo info) { |
| if (info.isManagedProfile()) { |
| // We use predefined values for managed profiles |
| return context.getString(R.string.managed_user_title); |
| } |
| String name = info != null ? info.name : null; |
| if (name == null && info != null) { |
| name = Integer.toString(info.id); |
| } else if (info == null) { |
| name = context.getString(R.string.unknown); |
| } |
| return context.getResources().getString(R.string.running_process_item_user_label, name); |
| } |
| |
| /** |
| * Return whether or not the user should have a SIM Cards option in Settings. |
| * TODO: Change back to returning true if count is greater than one after testing. |
| * TODO: See bug 16533525. |
| */ |
| public static boolean showSimCardTile(Context context) { |
| final TelephonyManager tm = |
| (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); |
| |
| return tm.getSimCount() > 0; |
| } |
| |
| /** |
| * Determine whether a package is a "system package", in which case certain things (like |
| * disabling notifications or disabling the package altogether) should be disallowed. |
| */ |
| public static boolean isSystemPackage(PackageManager pm, PackageInfo pkg) { |
| if (sSystemSignature == null) { |
| sSystemSignature = new Signature[]{ getSystemSignature(pm) }; |
| } |
| return sSystemSignature[0] != null && sSystemSignature[0].equals(getFirstSignature(pkg)); |
| } |
| |
| private static Signature[] sSystemSignature; |
| |
| private static Signature getFirstSignature(PackageInfo pkg) { |
| if (pkg != null && pkg.signatures != null && pkg.signatures.length > 0) { |
| return pkg.signatures[0]; |
| } |
| return null; |
| } |
| |
| private static Signature getSystemSignature(PackageManager pm) { |
| try { |
| final PackageInfo sys = pm.getPackageInfo("android", PackageManager.GET_SIGNATURES); |
| return getFirstSignature(sys); |
| } catch (NameNotFoundException e) { |
| } |
| return null; |
| } |
| |
| /** |
| * Returns elapsed time for the given millis, in the following format: |
| * 2d 5h 40m 29s |
| * @param context the application context |
| * @param millis the elapsed time in milli seconds |
| * @param withSeconds include seconds? |
| * @return the formatted elapsed time |
| */ |
| public static String formatElapsedTime(Context context, double millis, boolean withSeconds) { |
| StringBuilder sb = new StringBuilder(); |
| int seconds = (int) Math.floor(millis / 1000); |
| if (!withSeconds) { |
| // Round up. |
| seconds += 30; |
| } |
| |
| int days = 0, hours = 0, minutes = 0; |
| if (seconds >= SECONDS_PER_DAY) { |
| days = seconds / SECONDS_PER_DAY; |
| seconds -= days * SECONDS_PER_DAY; |
| } |
| if (seconds >= SECONDS_PER_HOUR) { |
| hours = seconds / SECONDS_PER_HOUR; |
| seconds -= hours * SECONDS_PER_HOUR; |
| } |
| if (seconds >= SECONDS_PER_MINUTE) { |
| minutes = seconds / SECONDS_PER_MINUTE; |
| seconds -= minutes * SECONDS_PER_MINUTE; |
| } |
| if (withSeconds) { |
| if (days > 0) { |
| sb.append(context.getString(R.string.battery_history_days, |
| days, hours, minutes, seconds)); |
| } else if (hours > 0) { |
| sb.append(context.getString(R.string.battery_history_hours, |
| hours, minutes, seconds)); |
| } else if (minutes > 0) { |
| sb.append(context.getString(R.string.battery_history_minutes, minutes, seconds)); |
| } else { |
| sb.append(context.getString(R.string.battery_history_seconds, seconds)); |
| } |
| } else { |
| if (days > 0) { |
| sb.append(context.getString(R.string.battery_history_days_no_seconds, |
| days, hours, minutes)); |
| } else if (hours > 0) { |
| sb.append(context.getString(R.string.battery_history_hours_no_seconds, |
| hours, minutes)); |
| } else { |
| sb.append(context.getString(R.string.battery_history_minutes_no_seconds, minutes)); |
| } |
| } |
| return sb.toString(); |
| } |
| |
| /** |
| * finds a record with subId. |
| * Since the number of SIMs are few, an array is fine. |
| */ |
| public static SubscriptionInfo findRecordBySubId(final int subId) { |
| final List<SubscriptionInfo> subInfoList = |
| SubscriptionManager.getActiveSubscriptionInfoList(); |
| final int subInfoLength = subInfoList.size(); |
| |
| for (int i = 0; i < subInfoLength; ++i) { |
| final SubscriptionInfo sir = subInfoList.get(i); |
| if (sir != null && sir.getSubscriptionId() == subId) { |
| return sir; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * finds a record with slotId. |
| * Since the number of SIMs are few, an array is fine. |
| */ |
| public static SubscriptionInfo findRecordBySlotId(final int slotId) { |
| final List<SubscriptionInfo> subInfoList = |
| SubscriptionManager.getActiveSubscriptionInfoList(); |
| final int subInfoLength = subInfoList.size(); |
| |
| for (int i = 0; i < subInfoLength; ++i) { |
| final SubscriptionInfo sir = subInfoList.get(i); |
| if (sir.getSimSlotIndex() == slotId) { |
| //Right now we take the first subscription on a SIM. |
| return sir; |
| } |
| } |
| |
| return null; |
| } |
| |
| } |
