src/com/android/settings/SettingsActivity.java

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy 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,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settings;
  18
  19 import android.app.ActionBar;
  20 import android.app.ActivityManager;
  21 import android.app.Fragment;
  22 import android.app.FragmentManager;
  23 import android.app.FragmentTransaction;
  24 import android.content.BroadcastReceiver;
  25 import android.content.ComponentName;
  26 import android.content.Context;
  27 import android.content.Intent;
  28 import android.content.IntentFilter;
  29 import android.content.SharedPreferences;
  30 import android.content.pm.ActivityInfo;
  31 import android.content.pm.PackageManager;
  32 import android.content.pm.PackageManager.NameNotFoundException;
  33 import android.graphics.Bitmap;
  34 import android.graphics.Canvas;
  35 import android.graphics.drawable.Drawable;
  36 import android.nfc.NfcAdapter;
  37 import android.os.AsyncTask;
  38 import android.os.Bundle;
  39 import android.os.UserHandle;
  40 import android.os.UserManager;
  41 import android.support.annotation.VisibleForTesting;
  42 import android.support.v14.preference.PreferenceFragment;
  43 import android.support.v7.preference.Preference;
  44 import android.support.v7.preference.PreferenceManager;
  45 import android.text.TextUtils;
  46 import android.transition.TransitionManager;
  47 import android.util.Log;
  48 import android.view.Menu;
  49 import android.view.View;
  50 import android.view.View.OnClickListener;
  51 import android.view.ViewGroup;
  52 import android.widget.Button;
  53
  54 import com.android.internal.util.ArrayUtils;
  55 import com.android.settings.Settings.WifiSettingsActivity;
  56 import com.android.settings.backup.BackupSettingsActivity;
  57 import com.android.settings.core.gateway.SettingsGateway;
  58 import com.android.settings.core.instrumentation.MetricsFeatureProvider;
  59 import com.android.settings.core.instrumentation.SharedPreferencesLogger;
  60 import com.android.settings.dashboard.DashboardFeatureProvider;
  61 import com.android.settings.dashboard.DashboardSummary;
  62 import com.android.settings.development.DevelopmentSettings;
  63 import com.android.settings.overlay.FeatureFactory;
  64 import com.android.settings.search.DynamicIndexableContentMonitor;
  65 import com.android.settings.search2.SearchFeatureProvider;
  66 import com.android.settings.wfd.WifiDisplaySettings;
  67 import com.android.settings.widget.SwitchBar;
  68 import com.android.settingslib.drawer.DashboardCategory;
  69 import com.android.settingslib.drawer.SettingsDrawerActivity;
  70
  71 import java.util.ArrayList;
  72 import java.util.List;
  73 import java.util.Set;
  74
  75 public class SettingsActivity extends SettingsDrawerActivity
  76         implements PreferenceManager.OnPreferenceTreeClickListener,
  77         PreferenceFragment.OnPreferenceStartFragmentCallback,
  78         ButtonBarHandler, FragmentManager.OnBackStackChangedListener {
  79
  80     private static final String LOG_TAG = "Settings";
  81
  82     public static final int LOADER_ID_INDEXABLE_CONTENT_MONITOR = 1;
  83
  84     // Constants for state save/restore
  85     private static final String SAVE_KEY_CATEGORIES = ":settings:categories";
  86     @VisibleForTesting
  87     static final String SAVE_KEY_SHOW_HOME_AS_UP = ":settings:show_home_as_up";
  88     @VisibleForTesting
  89     static final String SAVE_KEY_SHOW_SEARCH = ":settings:show_search";
  90
  91     /**
  92      * When starting this activity, the invoking Intent can contain this extra
  93      * string to specify which fragment should be initially displayed.
  94      * <p/>Starting from Key Lime Pie, when this argument is passed in, the activity
  95      * will call isValidFragment() to confirm that the fragment class name is valid for this
  96      * activity.
  97      */
  98     public static final String EXTRA_SHOW_FRAGMENT = ":settings:show_fragment";
  99
 100     /**
 101      * The metrics category constant for logging source when a setting fragment is opened.
 102      */
 103     public static final String EXTRA_SOURCE_METRICS_CATEGORY = ":settings:source_metrics";
 104
 105     /**
 106      * When starting this activity and using {@link #EXTRA_SHOW_FRAGMENT},
 107      * this extra can also be specified to supply a Bundle of arguments to pass
 108      * to that fragment when it is instantiated during the initial creation
 109      * of the activity.
 110      */
 111     public static final String EXTRA_SHOW_FRAGMENT_ARGUMENTS = ":settings:show_fragment_args";
 112
 113     /**
 114      * Fragment "key" argument passed thru {@link #EXTRA_SHOW_FRAGMENT_ARGUMENTS}
 115      */
 116     public static final String EXTRA_FRAGMENT_ARG_KEY = ":settings:fragment_args_key";
 117
 118     public static final String BACK_STACK_PREFS = ":settings:prefs";
 119
 120     // extras that allow any preference activity to be launched as part of a wizard
 121
 122     // show Back and Next buttons? takes boolean parameter
 123     // Back will then return RESULT_CANCELED and Next RESULT_OK
 124     protected static final String EXTRA_PREFS_SHOW_BUTTON_BAR = "extra_prefs_show_button_bar";
 125
 126     // add a Skip button?
 127     private static final String EXTRA_PREFS_SHOW_SKIP = "extra_prefs_show_skip";
 128
 129     // specify custom text for the Back or Next buttons, or cause a button to not appear
 130     // at all by setting it to null
 131     protected static final String EXTRA_PREFS_SET_NEXT_TEXT = "extra_prefs_set_next_text";
 132     protected static final String EXTRA_PREFS_SET_BACK_TEXT = "extra_prefs_set_back_text";
 133
 134     /**
 135      * When starting this activity and using {@link #EXTRA_SHOW_FRAGMENT},
 136      * those extra can also be specify to supply the title or title res id to be shown for
 137      * that fragment.
 138      */
 139     public static final String EXTRA_SHOW_FRAGMENT_TITLE = ":settings:show_fragment_title";
 140     /**
 141      * The package name used to resolve the title resource id.
 142      */
 143     public static final String EXTRA_SHOW_FRAGMENT_TITLE_RES_PACKAGE_NAME =
 144             ":settings:show_fragment_title_res_package_name";
 145     public static final String EXTRA_SHOW_FRAGMENT_TITLE_RESID =
 146             ":settings:show_fragment_title_resid";
 147     public static final String EXTRA_SHOW_FRAGMENT_AS_SHORTCUT =
 148             ":settings:show_fragment_as_shortcut";
 149
 150     public static final String EXTRA_SHOW_FRAGMENT_AS_SUBSETTING =
 151             ":settings:show_fragment_as_subsetting";
 152
 153     @Deprecated
 154     public static final String EXTRA_HIDE_DRAWER = ":settings:hide_drawer";
 155
 156     public static final String META_DATA_KEY_FRAGMENT_CLASS =
 157         "com.android.settings.FRAGMENT_CLASS";
 158
 159     private static final String EXTRA_UI_OPTIONS = "settings:ui_options";
 160
 161     private static final int REQUEST_SUGGESTION = 42;
 162
 163     private String mFragmentClass;
 164
 165     private CharSequence mInitialTitle;
 166     private int mInitialTitleResId;
 167
 168     private static final String[] LIKE_SHORTCUT_INTENT_ACTION_ARRAY = {
 169             "android.settings.APPLICATION_DETAILS_SETTINGS"
 170     };
 171
 172     private SharedPreferences mDevelopmentPreferences;
 173     private SharedPreferences.OnSharedPreferenceChangeListener mDevelopmentPreferencesListener;
 174
 175     private boolean mBatteryPresent = true;
 176     private BroadcastReceiver mBatteryInfoReceiver = new BroadcastReceiver() {
 177         @Override
 178         public void onReceive(Context context, Intent intent) {
 179             String action = intent.getAction();
 180             if (Intent.ACTION_BATTERY_CHANGED.equals(action)) {
 181                 boolean batteryPresent = Utils.isBatteryPresent(intent);
 182
 183                 if (mBatteryPresent != batteryPresent) {
 184                     mBatteryPresent = batteryPresent;
 185                     updateTilesList();
 186                 }
 187             }
 188         }
 189     };
 190
 191     private DynamicIndexableContentMonitor mDynamicIndexableContentMonitor;
 192
 193     private ActionBar mActionBar;
 194     private SwitchBar mSwitchBar;
 195
 196     private Button mNextButton;
 197
 198     @VisibleForTesting
 199     boolean mDisplayHomeAsUpEnabled;
 200     @VisibleForTesting
 201     boolean mDisplaySearch;
 202
 203     private boolean mIsShowingDashboard;
 204     private boolean mIsShortcut;
 205
 206     private ViewGroup mContent;
 207
 208     private SearchFeatureProvider mSearchFeatureProvider;
 209     private MetricsFeatureProvider mMetricsFeatureProvider;
 210
 211     // Categories
 212     private ArrayList<DashboardCategory> mCategories = new ArrayList<>();
 213
 214     private DashboardFeatureProvider mDashboardFeatureProvider;
 215     private ComponentName mCurrentSuggestion;
 216
 217     public SwitchBar getSwitchBar() {
 218         return mSwitchBar;
 219     }
 220
 221     @Override
 222     public boolean onPreferenceStartFragment(PreferenceFragment caller, Preference pref) {
 223         startPreferencePanel(caller, pref.getFragment(), pref.getExtras(), -1, pref.getTitle(),
 224                 null, 0);
 225         return true;
 226     }
 227
 228     @Override
 229     public boolean onPreferenceTreeClick(Preference preference) {
 230         return false;
 231     }
 232
 233     @Override
 234     public boolean onCreateOptionsMenu(Menu menu) {
 235         if (!mDisplaySearch) {
 236             return false;
 237         }
 238         mSearchFeatureProvider.setUpSearchMenu(menu, this);
 239         return true;
 240     }
 241
 242     @Override
 243     public SharedPreferences getSharedPreferences(String name, int mode) {
 244         if (name.equals(getPackageName() + "_preferences")) {
 245             return new SharedPreferencesLogger(this, getMetricsTag());
 246         }
 247         return super.getSharedPreferences(name, mode);
 248     }
 249
 250     private String getMetricsTag() {
 251         String tag = getClass().getName();
 252         if (getIntent() != null && getIntent().hasExtra(EXTRA_SHOW_FRAGMENT)) {
 253             tag = getIntent().getStringExtra(EXTRA_SHOW_FRAGMENT);
 254         }
 255         if (tag.startsWith("com.android.settings.")) {
 256             tag = tag.replace("com.android.settings.", "");
 257         }
 258         return tag;
 259     }
 260
 261     private static boolean isShortCutIntent(final Intent intent) {
 262         Set<String> categories = intent.getCategories();
 263         return (categories != null) && categories.contains("com.android.settings.SHORTCUT");
 264     }
 265
 266     private static boolean isLikeShortCutIntent(final Intent intent) {
 267         String action = intent.getAction();
 268         if (action == null) {
 269             return false;
 270         }
 271         for (int i = 0; i < LIKE_SHORTCUT_INTENT_ACTION_ARRAY.length; i++) {
 272             if (LIKE_SHORTCUT_INTENT_ACTION_ARRAY[i].equals(action)) return true;
 273         }
 274         return false;
 275     }
 276
 277     @Override
 278     protected void onCreate(Bundle savedState) {
 279         super.onCreate(savedState);
 280         long startTime = System.currentTimeMillis();
 281
 282         final FeatureFactory factory = FeatureFactory.getFactory(this);
 283
 284         mDashboardFeatureProvider = factory.getDashboardFeatureProvider(this);
 285         mSearchFeatureProvider = factory.getSearchFeatureProvider();
 286         mMetricsFeatureProvider = factory.getMetricsFeatureProvider();
 287
 288         // Should happen before any call to getIntent()
 289         getMetaData();
 290
 291         final Intent intent = getIntent();
 292         if (intent.hasExtra(EXTRA_UI_OPTIONS)) {
 293             getWindow().setUiOptions(intent.getIntExtra(EXTRA_UI_OPTIONS, 0));
 294         }
 295
 296         mDevelopmentPreferences = getSharedPreferences(DevelopmentSettings.PREF_FILE,
 297                 Context.MODE_PRIVATE);
 298
 299         // Getting Intent properties can only be done after the super.onCreate(...)
 300         final String initialFragmentName = intent.getStringExtra(EXTRA_SHOW_FRAGMENT);
 301
 302         mIsShortcut = isShortCutIntent(intent) || isLikeShortCutIntent(intent) ||
 303                 intent.getBooleanExtra(EXTRA_SHOW_FRAGMENT_AS_SHORTCUT, false);
 304
 305         final ComponentName cn = intent.getComponent();
 306         final String className = cn.getClassName();
 307
 308         mIsShowingDashboard = className.equals(Settings.class.getName());
 309
 310         // This is a "Sub Settings" when:
 311         // - this is a real SubSettings
 312         // - or :settings:show_fragment_as_subsetting is passed to the Intent
 313         final boolean isSubSettings = this instanceof SubSettings ||
 314                 intent.getBooleanExtra(EXTRA_SHOW_FRAGMENT_AS_SUBSETTING, false);
 315
 316         // If this is a sub settings, then apply the SubSettings Theme for the ActionBar content
 317         // insets
 318         if (isSubSettings) {
 319             setTheme(R.style.Theme_SubSettings);
 320         }
 321
 322         setContentView(mIsShowingDashboard ?
 323                 R.layout.settings_main_dashboard : R.layout.settings_main_prefs);
 324
 325         mContent = (ViewGroup) findViewById(R.id.main_content);
 326
 327         getFragmentManager().addOnBackStackChangedListener(this);
 328
 329         if (savedState != null) {
 330             // We are restarting from a previous saved state; used that to initialize, instead
 331             // of starting fresh.
 332             setTitleFromIntent(intent);
 333
 334             ArrayList<DashboardCategory> categories =
 335                     savedState.getParcelableArrayList(SAVE_KEY_CATEGORIES);
 336             if (categories != null) {
 337                 mCategories.clear();
 338                 mCategories.addAll(categories);
 339                 setTitleFromBackStack();
 340             }
 341
 342             mDisplayHomeAsUpEnabled = savedState.getBoolean(SAVE_KEY_SHOW_HOME_AS_UP);
 343
 344         } else {
 345             launchSettingFragment(initialFragmentName, isSubSettings, intent);
 346         }
 347
 348         mActionBar = getActionBar();
 349         if (mActionBar != null) {
 350             mActionBar.setDisplayHomeAsUpEnabled(mDisplayHomeAsUpEnabled);
 351             mActionBar.setHomeButtonEnabled(mDisplayHomeAsUpEnabled);
 352         }
 353         mSwitchBar = (SwitchBar) findViewById(R.id.switch_bar);
 354         if (mSwitchBar != null) {
 355             mSwitchBar.setMetricsTag(getMetricsTag());
 356         }
 357
 358         // see if we should show Back/Next buttons
 359         if (intent.getBooleanExtra(EXTRA_PREFS_SHOW_BUTTON_BAR, false)) {
 360
 361             View buttonBar = findViewById(R.id.button_bar);
 362             if (buttonBar != null) {
 363                 buttonBar.setVisibility(View.VISIBLE);
 364
 365                 Button backButton = (Button)findViewById(R.id.back_button);
 366                 backButton.setOnClickListener(new OnClickListener() {
 367                     public void onClick(View v) {
 368                         setResult(RESULT_CANCELED, null);
 369                         finish();
 370                     }
 371                 });
 372                 Button skipButton = (Button)findViewById(R.id.skip_button);
 373                 skipButton.setOnClickListener(new OnClickListener() {
 374                     public void onClick(View v) {
 375                         setResult(RESULT_OK, null);
 376                         finish();
 377                     }
 378                 });
 379                 mNextButton = (Button)findViewById(R.id.next_button);
 380                 mNextButton.setOnClickListener(new OnClickListener() {
 381                     public void onClick(View v) {
 382                         setResult(RESULT_OK, null);
 383                         finish();
 384                     }
 385                 });
 386
 387                 // set our various button parameters
 388                 if (intent.hasExtra(EXTRA_PREFS_SET_NEXT_TEXT)) {
 389                     String buttonText = intent.getStringExtra(EXTRA_PREFS_SET_NEXT_TEXT);
 390                     if (TextUtils.isEmpty(buttonText)) {
 391                         mNextButton.setVisibility(View.GONE);
 392                     }
 393                     else {
 394                         mNextButton.setText(buttonText);
 395                     }
 396                 }
 397                 if (intent.hasExtra(EXTRA_PREFS_SET_BACK_TEXT)) {
 398                     String buttonText = intent.getStringExtra(EXTRA_PREFS_SET_BACK_TEXT);
 399                     if (TextUtils.isEmpty(buttonText)) {
 400                         backButton.setVisibility(View.GONE);
 401                     }
 402                     else {
 403                         backButton.setText(buttonText);
 404                     }
 405                 }
 406                 if (intent.getBooleanExtra(EXTRA_PREFS_SHOW_SKIP, false)) {
 407                     skipButton.setVisibility(View.VISIBLE);
 408                 }
 409             }
 410         }
 411
 412         if (DEBUG_TIMING) {
 413             Log.d(LOG_TAG, "onCreate took " + (System.currentTimeMillis() - startTime) + " ms");
 414         }
 415     }
 416
 417     @VisibleForTesting
 418     void launchSettingFragment(String initialFragmentName, boolean isSubSettings, Intent intent) {
 419         if (!mIsShowingDashboard && initialFragmentName != null) {
 420             mDisplaySearch = false;
 421             // UP will be shown only if it is a sub settings
 422             if (mIsShortcut) {
 423                 mDisplayHomeAsUpEnabled = isSubSettings;
 424             } else if (isSubSettings) {
 425                 mDisplayHomeAsUpEnabled = true;
 426             } else {
 427                 mDisplayHomeAsUpEnabled = false;
 428             }
 429             setTitleFromIntent(intent);
 430
 431             Bundle initialArguments = intent.getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS);
 432             switchToFragment(initialFragmentName, initialArguments, true, false,
 433                 mInitialTitleResId, mInitialTitle, false);
 434         } else {
 435             // No UP affordance if we are displaying the main Dashboard
 436             mDisplayHomeAsUpEnabled = false;
 437             // Show Search affordance
 438             mDisplaySearch = true;
 439             mInitialTitleResId = R.string.dashboard_title;
 440
 441             switchToFragment(DashboardSummary.class.getName(), null /* args */, false, false,
 442                 mInitialTitleResId, mInitialTitle, false);
 443         }
 444     }
 445
 446     public void setDisplaySearchMenu(boolean displaySearch) {
 447         if (displaySearch != mDisplaySearch) {
 448             mDisplaySearch = displaySearch;
 449             invalidateOptionsMenu();
 450         }
 451     }
 452
 453     private void setTitleFromIntent(Intent intent) {
 454         final int initialTitleResId = intent.getIntExtra(EXTRA_SHOW_FRAGMENT_TITLE_RESID, -1);
 455         if (initialTitleResId > 0) {
 456             mInitialTitle = null;
 457             mInitialTitleResId = initialTitleResId;
 458
 459             final String initialTitleResPackageName = intent.getStringExtra(
 460                     EXTRA_SHOW_FRAGMENT_TITLE_RES_PACKAGE_NAME);
 461             if (initialTitleResPackageName != null) {
 462                 try {
 463                     Context authContext = createPackageContextAsUser(initialTitleResPackageName,
 464                             0 /* flags */, new UserHandle(UserHandle.myUserId()));
 465                     mInitialTitle = authContext.getResources().getText(mInitialTitleResId);
 466                     setTitle(mInitialTitle);
 467                     mInitialTitleResId = -1;
 468                     return;
 469                 } catch (NameNotFoundException e) {
 470                     Log.w(LOG_TAG, "Could not find package" + initialTitleResPackageName);
 471                 }
 472             } else {
 473                 setTitle(mInitialTitleResId);
 474             }
 475         } else {
 476             mInitialTitleResId = -1;
 477             final String initialTitle = intent.getStringExtra(EXTRA_SHOW_FRAGMENT_TITLE);
 478             mInitialTitle = (initialTitle != null) ? initialTitle : getTitle();
 479             setTitle(mInitialTitle);
 480         }
 481     }
 482
 483     @Override
 484     public void onBackStackChanged() {
 485         setTitleFromBackStack();
 486     }
 487
 488     private void setTitleFromBackStack() {
 489         final int count = getFragmentManager().getBackStackEntryCount();
 490
 491         if (count == 0) {
 492             if (mInitialTitleResId > 0) {
 493                 setTitle(mInitialTitleResId);
 494             } else {
 495                 setTitle(mInitialTitle);
 496             }
 497             return;
 498         }
 499
 500         FragmentManager.BackStackEntry bse = getFragmentManager().getBackStackEntryAt(count - 1);
 501         setTitleFromBackStackEntry(bse);
 502     }
 503
 504     private void setTitleFromBackStackEntry(FragmentManager.BackStackEntry bse) {
 505         final CharSequence title;
 506         final int titleRes = bse.getBreadCrumbTitleRes();
 507         if (titleRes > 0) {
 508             title = getText(titleRes);
 509         } else {
 510             title = bse.getBreadCrumbTitle();
 511         }
 512         if (title != null) {
 513             setTitle(title);
 514         }
 515     }
 516
 517     @Override
 518     protected void onSaveInstanceState(Bundle outState) {
 519         super.onSaveInstanceState(outState);
 520         saveState(outState);
 521     }
 522
 523     /**
 524      * For testing purposes to avoid crashes from final variables in Activity's onSaveInstantState.
 525      */
 526     @VisibleForTesting
 527     void saveState(Bundle outState) {
 528         if (mCategories.size() > 0) {
 529             outState.putParcelableArrayList(SAVE_KEY_CATEGORIES, mCategories);
 530         }
 531
 532         outState.putBoolean(SAVE_KEY_SHOW_HOME_AS_UP, mDisplayHomeAsUpEnabled);
 533         outState.putBoolean(SAVE_KEY_SHOW_SEARCH, mDisplaySearch);
 534     }
 535
 536     @Override
 537     protected void onRestoreInstanceState(Bundle savedInstanceState) {
 538         super.onRestoreInstanceState(savedInstanceState);
 539
 540         mDisplayHomeAsUpEnabled = savedInstanceState.getBoolean(SAVE_KEY_SHOW_HOME_AS_UP);
 541         mDisplaySearch = savedInstanceState.getBoolean(SAVE_KEY_SHOW_SEARCH);
 542     }
 543
 544     @Override
 545     protected void onResume() {
 546         super.onResume();
 547
 548         mDevelopmentPreferencesListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
 549             @Override
 550             public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
 551                 updateTilesList();
 552             }
 553         };
 554         mDevelopmentPreferences.registerOnSharedPreferenceChangeListener(
 555                 mDevelopmentPreferencesListener);
 556
 557         registerReceiver(mBatteryInfoReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
 558         if (mDynamicIndexableContentMonitor == null) {
 559             mDynamicIndexableContentMonitor = new DynamicIndexableContentMonitor();
 560         }
 561         mDynamicIndexableContentMonitor.register(this, LOADER_ID_INDEXABLE_CONTENT_MONITOR);
 562
 563         updateTilesList();
 564     }
 565
 566     @Override
 567     protected void onPause() {
 568         super.onPause();
 569         mDevelopmentPreferences.unregisterOnSharedPreferenceChangeListener(
 570                 mDevelopmentPreferencesListener);
 571         mDevelopmentPreferencesListener = null;
 572         unregisterReceiver(mBatteryInfoReceiver);
 573         if (mDynamicIndexableContentMonitor != null) {
 574             mDynamicIndexableContentMonitor.unregister(this, LOADER_ID_INDEXABLE_CONTENT_MONITOR);
 575         }
 576     }
 577
 578     @Override
 579     public void setTaskDescription(ActivityManager.TaskDescription taskDescription) {
 580         final Bitmap icon = getBitmapFromXmlResource(R.drawable.ic_launcher_settings);
 581         taskDescription.setIcon(icon);
 582         super.setTaskDescription(taskDescription);
 583     }
 584
 585     protected boolean isValidFragment(String fragmentName) {
 586         // Almost all fragments are wrapped in this,
 587         // except for a few that have their own activities.
 588         for (int i = 0; i < SettingsGateway.ENTRY_FRAGMENTS.length; i++) {
 589             if (SettingsGateway.ENTRY_FRAGMENTS[i].equals(fragmentName)) return true;
 590         }
 591         return false;
 592     }
 593
 594     @Override
 595     public Intent getIntent() {
 596         Intent superIntent = super.getIntent();
 597         String startingFragment = getStartingFragmentClass(superIntent);
 598         // This is called from super.onCreate, isMultiPane() is not yet reliable
 599         // Do not use onIsHidingHeaders either, which relies itself on this method
 600         if (startingFragment != null) {
 601             Intent modIntent = new Intent(superIntent);
 602             modIntent.putExtra(EXTRA_SHOW_FRAGMENT, startingFragment);
 603             Bundle args = superIntent.getExtras();
 604             if (args != null) {
 605                 args = new Bundle(args);
 606             } else {
 607                 args = new Bundle();
 608             }
 609             args.putParcelable("intent", superIntent);
 610             modIntent.putExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS, args);
 611             return modIntent;
 612         }
 613         return superIntent;
 614     }
 615
 616     /**
 617      * Checks if the component name in the intent is different from the Settings class and
 618      * returns the class name to load as a fragment.
 619      */
 620     private String getStartingFragmentClass(Intent intent) {
 621         if (mFragmentClass != null) return mFragmentClass;
 622
 623         String intentClass = intent.getComponent().getClassName();
 624         if (intentClass.equals(getClass().getName())) return null;
 625
 626         if ("com.android.settings.ManageApplications".equals(intentClass)
 627                 || "com.android.settings.RunningServices".equals(intentClass)
 628                 || "com.android.settings.applications.StorageUse".equals(intentClass)) {
 629             // Old names of manage apps.
 630             intentClass = com.android.settings.applications.ManageApplications.class.getName();
 631         }
 632
 633         return intentClass;
 634     }
 635
 636     /**
 637      * Start a new fragment containing a preference panel.  If the preferences
 638      * are being displayed in multi-pane mode, the given fragment class will
 639      * be instantiated and placed in the appropriate pane.  If running in
 640      * single-pane mode, a new activity will be launched in which to show the
 641      * fragment.
 642      *
 643      * @param fragmentClass Full name of the class implementing the fragment.
 644      * @param args Any desired arguments to supply to the fragment.
 645      * @param titleRes Optional resource identifier of the title of this
 646      * fragment.
 647      * @param titleText Optional text of the title of this fragment.
 648      * @param resultTo Optional fragment that result data should be sent to.
 649      * If non-null, resultTo.onActivityResult() will be called when this
 650      * preference panel is done.  The launched panel must use
 651      * {@link #finishPreferencePanel(Fragment, int, Intent)} when done.
 652      * @param resultRequestCode If resultTo is non-null, this is the caller's
 653      * request code to be received with the result.
 654      */
 655     public void startPreferencePanel(Fragment caller, String fragmentClass, Bundle args,
 656             int titleRes, CharSequence titleText, Fragment resultTo, int resultRequestCode) {
 657         String title = null;
 658         if (titleRes < 0) {
 659             if (titleText != null) {
 660                 title = titleText.toString();
 661             } else {
 662                 // There not much we can do in that case
 663                 title = "";
 664             }
 665         }
 666         Utils.startWithFragment(this, fragmentClass, args, resultTo, resultRequestCode,
 667                 titleRes, title, mIsShortcut, mMetricsFeatureProvider.getMetricsCategory(caller));
 668     }
 669
 670     /**
 671      * Start a new fragment in a new activity containing a preference panel for a given user. If the
 672      * preferences are being displayed in multi-pane mode, the given fragment class will be
 673      * instantiated and placed in the appropriate pane. If running in single-pane mode, a new
 674      * activity will be launched in which to show the fragment.
 675      *
 676      * @param fragmentClass Full name of the class implementing the fragment.
 677      * @param args Any desired arguments to supply to the fragment.
 678      * @param titleRes Optional resource identifier of the title of this fragment.
 679      * @param titleText Optional text of the title of this fragment.
 680      * @param userHandle The user for which the panel has to be started.
 681      */
 682     public void startPreferencePanelAsUser(Fragment caller, String fragmentClass,
 683             Bundle args, int titleRes, CharSequence titleText, UserHandle userHandle) {
 684         // This is a workaround.
 685         //
 686         // Calling startWithFragmentAsUser() without specifying FLAG_ACTIVITY_NEW_TASK to the intent
 687         // starting the fragment could cause a native stack corruption. See b/17523189. However,
 688         // adding that flag and start the preference panel with the same UserHandler will make it
 689         // impossible to use back button to return to the previous screen. See b/20042570.
 690         //
 691         // We work around this issue by adding FLAG_ACTIVITY_NEW_TASK to the intent, while doing
 692         // another check here to call startPreferencePanel() instead of startWithFragmentAsUser()
 693         // when we're calling it as the same user.
 694         if (userHandle.getIdentifier() == UserHandle.myUserId()) {
 695             startPreferencePanel(caller, fragmentClass, args, titleRes, titleText, null, 0);
 696         } else {
 697             String title = null;
 698             if (titleRes < 0) {
 699                 if (titleText != null) {
 700                     title = titleText.toString();
 701                 } else {
 702                     // There not much we can do in that case
 703                     title = "";
 704                 }
 705             }
 706             Utils.startWithFragmentAsUser(this, fragmentClass, args, titleRes, title,
 707                     mIsShortcut, mMetricsFeatureProvider.getMetricsCategory(caller), userHandle);
 708         }
 709     }
 710
 711     /**
 712      * Called by a preference panel fragment to finish itself.
 713      *
 714      * @param caller The fragment that is asking to be finished.
 715      * @param resultCode Optional result code to send back to the original
 716      * launching fragment.
 717      * @param resultData Optional result data to send back to the original
 718      * launching fragment.
 719      */
 720     public void finishPreferencePanel(Fragment caller, int resultCode, Intent resultData) {
 721         setResult(resultCode, resultData);
 722         finish();
 723     }
 724
 725     /**
 726      * Start a new fragment.
 727      *
 728      * @param fragment The fragment to start
 729      * @param push If true, the current fragment will be pushed onto the back stack.  If false,
 730      * the current fragment will be replaced.
 731      */
 732     public void startPreferenceFragment(Fragment fragment, boolean push) {
 733         FragmentTransaction transaction = getFragmentManager().beginTransaction();
 734         transaction.replace(R.id.main_content, fragment);
 735         if (push) {
 736             transaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
 737             transaction.addToBackStack(BACK_STACK_PREFS);
 738         } else {
 739             transaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
 740         }
 741         transaction.commitAllowingStateLoss();
 742     }
 743
 744     /**
 745      * Switch to a specific Fragment with taking care of validation, Title and BackStack
 746      */
 747     private Fragment switchToFragment(String fragmentName, Bundle args, boolean validate,
 748             boolean addToBackStack, int titleResId, CharSequence title, boolean withTransition) {
 749         if (validate && !isValidFragment(fragmentName)) {
 750             throw new IllegalArgumentException("Invalid fragment for this activity: "
 751                     + fragmentName);
 752         }
 753         Fragment f = Fragment.instantiate(this, fragmentName, args);
 754         FragmentTransaction transaction = getFragmentManager().beginTransaction();
 755         transaction.replace(R.id.main_content, f);
 756         if (withTransition) {
 757             TransitionManager.beginDelayedTransition(mContent);
 758         }
 759         if (addToBackStack) {
 760             transaction.addToBackStack(SettingsActivity.BACK_STACK_PREFS);
 761         }
 762         if (titleResId > 0) {
 763             transaction.setBreadCrumbTitle(titleResId);
 764         } else if (title != null) {
 765             transaction.setBreadCrumbTitle(title);
 766         }
 767         transaction.commitAllowingStateLoss();
 768         getFragmentManager().executePendingTransactions();
 769         return f;
 770     }
 771
 772     private void updateTilesList() {
 773         // Generally the items that are will be changing from these updates will
 774         // not be in the top list of tiles, so run it in the background and the
 775         // SettingsDrawerActivity will pick up on the updates automatically.
 776         AsyncTask.execute(new Runnable() {
 777             @Override
 778             public void run() {
 779                 doUpdateTilesList();
 780             }
 781         });
 782     }
 783
 784     private void doUpdateTilesList() {
 785         PackageManager pm = getPackageManager();
 786         final UserManager um = UserManager.get(this);
 787         final boolean isAdmin = um.isAdminUser();
 788
 789         String packageName = getPackageName();
 790         setTileEnabled(new ComponentName(packageName, WifiSettingsActivity.class.getName()),
 791                 pm.hasSystemFeature(PackageManager.FEATURE_WIFI), isAdmin);
 792
 793         setTileEnabled(new ComponentName(packageName,
 794                         Settings.BluetoothSettingsActivity.class.getName()),
 795                 pm.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH), isAdmin);
 796
 797         setTileEnabled(new ComponentName(packageName,
 798                         Settings.DataUsageSummaryActivity.class.getName()),
 799                 Utils.isBandwidthControlEnabled(), isAdmin);
 800
 801         setTileEnabled(new ComponentName(packageName,
 802                         Settings.SimSettingsActivity.class.getName()),
 803                 Utils.showSimCardTile(this), isAdmin);
 804
 805         setTileEnabled(new ComponentName(packageName,
 806                         Settings.PowerUsageSummaryActivity.class.getName()),
 807                 mBatteryPresent, isAdmin);
 808
 809         setTileEnabled(new ComponentName(packageName,
 810                         Settings.UserSettingsActivity.class.getName()),
 811                 UserHandle.MU_ENABLED && UserManager.supportsMultipleUsers()
 812                         && !Utils.isMonkeyRunning(), isAdmin);
 813
 814         setTileEnabled(new ComponentName(packageName,
 815                         Settings.NetworkDashboardActivity.class.getName()),
 816                 !UserManager.isDeviceInDemoMode(this), isAdmin);
 817
 818         setTileEnabled(new ComponentName(packageName,
 819                         Settings.ConnectedDeviceDashboardActivity.class.getName()),
 820                 !UserManager.isDeviceInDemoMode(this), isAdmin);
 821
 822         setTileEnabled(new ComponentName(packageName,
 823                         Settings.DateTimeSettingsActivity.class.getName()),
 824                 !UserManager.isDeviceInDemoMode(this), isAdmin);
 825         NfcAdapter adapter = NfcAdapter.getDefaultAdapter(this);
 826         setTileEnabled(new ComponentName(packageName,
 827                         Settings.PaymentSettingsActivity.class.getName()),
 828                 pm.hasSystemFeature(PackageManager.FEATURE_NFC)
 829                         && pm.hasSystemFeature(PackageManager.FEATURE_NFC_HOST_CARD_EMULATION)
 830                         && adapter != null && adapter.isEnabled(), isAdmin);
 831
 832         setTileEnabled(new ComponentName(packageName,
 833                         Settings.PrintSettingsActivity.class.getName()),
 834                 pm.hasSystemFeature(PackageManager.FEATURE_PRINTING), isAdmin);
 835
 836         final boolean showDev = mDevelopmentPreferences.getBoolean(
 837                 DevelopmentSettings.PREF_SHOW, android.os.Build.TYPE.equals("eng"))
 838                 && !um.hasUserRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES);
 839         setTileEnabled(new ComponentName(packageName,
 840                         Settings.DevelopmentSettingsActivity.class.getName()),
 841                 showDev, isAdmin);
 842
 843         // Enable/disable backup settings depending on whether the user is admin.
 844         setTileEnabled(new ComponentName(packageName,
 845                         BackupSettingsActivity.class.getName()), true, isAdmin);
 846
 847         setTileEnabled(new ComponentName(packageName,
 848                         Settings.WifiDisplaySettingsActivity.class.getName()),
 849                 WifiDisplaySettings.isAvailable(this), isAdmin);
 850
 851         if (UserHandle.MU_ENABLED && !isAdmin) {
 852
 853             // When on restricted users, disable all extra categories (but only the settings ones).
 854             final List<DashboardCategory> categories = mDashboardFeatureProvider.getAllCategories();
 855             synchronized (categories) {
 856                 for (DashboardCategory category : categories) {
 857                     final int tileCount = category.getTilesCount();
 858                     for (int i = 0; i < tileCount; i++) {
 859                         final ComponentName component = category.getTile(i).intent.getComponent();
 860
 861                         final String name = component.getClassName();
 862                         final boolean isEnabledForRestricted = ArrayUtils.contains(
 863                                 SettingsGateway.SETTINGS_FOR_RESTRICTED, name);
 864                         if (packageName.equals(component.getPackageName())
 865                                 && !isEnabledForRestricted) {
 866                             setTileEnabled(component, false, isAdmin);
 867                         }
 868                     }
 869                 }
 870             }
 871         }
 872
 873         // Final step, refresh categories.
 874         updateCategories();
 875     }
 876
 877     private void setTileEnabled(ComponentName component, boolean enabled, boolean isAdmin) {
 878         if (UserHandle.MU_ENABLED && !isAdmin && getPackageName().equals(component.getPackageName())
 879                 && !ArrayUtils.contains(SettingsGateway.SETTINGS_FOR_RESTRICTED,
 880                 component.getClassName())) {
 881             enabled = false;
 882         }
 883         setTileEnabled(component, enabled);
 884     }
 885
 886     private void getMetaData() {
 887         try {
 888             ActivityInfo ai = getPackageManager().getActivityInfo(getComponentName(),
 889                     PackageManager.GET_META_DATA);
 890             if (ai == null || ai.metaData == null) return;
 891             mFragmentClass = ai.metaData.getString(META_DATA_KEY_FRAGMENT_CLASS);
 892         } catch (NameNotFoundException nnfe) {
 893             // No recovery
 894             Log.d(LOG_TAG, "Cannot get Metadata for: " + getComponentName().toString());
 895         }
 896     }
 897
 898     // give subclasses access to the Next button
 899     public boolean hasNextButton() {
 900         return mNextButton != null;
 901     }
 902
 903     public Button getNextButton() {
 904         return mNextButton;
 905     }
 906
 907     @Override
 908     public boolean shouldUpRecreateTask(Intent targetIntent) {
 909         return super.shouldUpRecreateTask(new Intent(this, SettingsActivity.class));
 910     }
 911
 912     public void startSuggestion(Intent intent) {
 913         if (intent == null || ActivityManager.isUserAMonkey()) {
 914             return;
 915         }
 916         mCurrentSuggestion = intent.getComponent();
 917         startActivityForResult(intent, REQUEST_SUGGESTION);
 918     }
 919
 920     @Override
 921     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 922         if (requestCode == REQUEST_SUGGESTION && mCurrentSuggestion != null
 923                 && resultCode != RESULT_CANCELED) {
 924             getPackageManager().setComponentEnabledSetting(mCurrentSuggestion,
 925                     PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP);
 926         }
 927         super.onActivityResult(requestCode, resultCode, data);
 928     }
 929
 930     @VisibleForTesting
 931     Bitmap getBitmapFromXmlResource(int drawableRes) {
 932         Drawable drawable = getResources().getDrawable(drawableRes, getTheme());
 933         Canvas canvas = new Canvas();
 934         Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(),
 935                 drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
 936         canvas.setBitmap(bitmap);
 937         drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
 938         drawable.draw(canvas);
 939
 940         return bitmap;
 941     }
 942 }