src/com/android/settings/widget/SettingsAppWidgetProvider.java

   1 /*
   2  * Copyright (C) 2009 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.widget;
  18
  19 import android.app.PendingIntent;
  20 import android.appwidget.AppWidgetManager;
  21 import android.appwidget.AppWidgetProvider;
  22 import android.bluetooth.BluetoothAdapter;
  23 import android.content.ComponentName;
  24 import android.content.ContentResolver;
  25 import android.content.Context;
  26 import android.content.IContentService;
  27 import android.content.Intent;
  28 import android.content.pm.PackageManager;
  29 import android.location.LocationManager;
  30 import android.net.ConnectivityManager;
  31 import android.net.Uri;
  32 import android.net.wifi.WifiManager;
  33 import android.os.AsyncTask;
  34 import android.os.IPowerManager;
  35 import android.os.RemoteException;
  36 import android.os.ServiceManager;
  37 import android.provider.Settings;
  38 import android.util.Log;
  39 import android.widget.RemoteViews;
  40 import com.android.settings.R;
  41 import com.android.settings.bluetooth.LocalBluetoothManager;
  42
  43 /**
  44  * Provides control of power-related settings from a widget.
  45  */
  46 public class SettingsAppWidgetProvider extends AppWidgetProvider {
  47     static final String TAG = "SettingsAppWidgetProvider";
  48
  49     static final ComponentName THIS_APPWIDGET =
  50             new ComponentName("com.android.settings",
  51                     "com.android.settings.widget.SettingsAppWidgetProvider");
  52
  53     private static LocalBluetoothManager sLocalBluetoothManager = null;
  54
  55     private static final int BUTTON_WIFI = 0;
  56     private static final int BUTTON_BRIGHTNESS = 1;
  57     private static final int BUTTON_SYNC = 2;
  58     private static final int BUTTON_GPS = 3;
  59     private static final int BUTTON_BLUETOOTH = 4;
  60
  61     // This widget keeps track of two sets of states:
  62     // "3-state": STATE_DISABLED, STATE_ENABLED, STATE_INTERMEDIATE
  63     // "5-state": STATE_DISABLED, STATE_ENABLED, STATE_TURNING_ON, STATE_TURNING_OFF, STATE_UNKNOWN
  64     private static final int STATE_DISABLED = 0;
  65     private static final int STATE_ENABLED = 1;
  66     private static final int STATE_TURNING_ON = 2;
  67     private static final int STATE_TURNING_OFF = 3;
  68     private static final int STATE_UNKNOWN = 4;
  69     private static final int STATE_INTERMEDIATE = 5;
  70
  71
  72     /**
  73      * Minimum and maximum brightnesses.  Don't go to 0 since that makes the display unusable
  74      */
  75     private static final int MINIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_DIM + 10;
  76     private static final int MAXIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_ON;
  77     private static final int DEFAULT_BACKLIGHT = (int) (android.os.Power.BRIGHTNESS_ON * 0.4f);
  78
  79     private static final StateTracker sWifiState = new WifiStateTracker();
  80     private static final StateTracker sBluetoothState = new BluetoothStateTracker();
  81
  82     /**
  83      * The state machine for Wifi and Bluetooth toggling, tracking
  84      * reality versus the user's intent.
  85      *
  86      * This is necessary because reality moves relatively slowly
  87      * (turning on &amp; off radio drivers), compared to user's
  88      * expectations.
  89      */
  90     private abstract static class StateTracker {
  91         // Is the state in the process of changing?
  92         private boolean mInTransition = false;
  93         private Boolean mActualState = null;  // initially not set
  94         private Boolean mIntendedState = null;  // initially not set
  95
  96         // Did a toggle request arrive while a state update was
  97         // already in-flight?  If so, the mIntendedState needs to be
  98         // requested when the other one is done, unless we happened to
  99         // arrive at that state already.
 100         private boolean mDeferredStateChangeRequestNeeded = false;
 101
 102         /**
 103          * User pressed a button to change the state.  Something
 104          * should immediately appear to the user afterwards, even if
 105          * we effectively do nothing.  Their press must be heard.
 106          */
 107         public final void toggleState(Context context) {
 108             int currentState = getTriState(context);
 109             boolean newState = false;
 110             switch (currentState) {
 111                 case STATE_ENABLED:
 112                     newState = false;
 113                     break;
 114                 case STATE_DISABLED:
 115                     newState = true;
 116                     break;
 117                 case STATE_INTERMEDIATE:
 118                     if (mIntendedState != null) {
 119                         newState = !mIntendedState;
 120                     }
 121                     break;
 122             }
 123             mIntendedState = newState;
 124             if (mInTransition) {
 125                 // We don't send off a transition request if we're
 126                 // already transitioning.  Makes our state tracking
 127                 // easier, and is probably nicer on lower levels.
 128                 // (even though they should be able to take it...)
 129                 mDeferredStateChangeRequestNeeded = true;
 130             } else {
 131                 mInTransition = true;
 132                 requestStateChange(context, newState);
 133             }
 134         }
 135
 136         /**
 137          * Update internal state from a broadcast state change.
 138          */
 139         public abstract void onActualStateChange(Context context, Intent intent);
 140
 141         /**
 142          * Sets the value that we're now in.  To be called from onActualStateChange.
 143          *
 144          * @param newState one of STATE_DISABLED, STATE_ENABLED, STATE_TURNING_ON,
 145          *                 STATE_TURNING_OFF, STATE_UNKNOWN
 146          */
 147         protected final void setCurrentState(Context context, int newState) {
 148             final boolean wasInTransition = mInTransition;
 149             switch (newState) {
 150                 case STATE_DISABLED:
 151                     mInTransition = false;
 152                     mActualState = false;
 153                     break;
 154                 case STATE_ENABLED:
 155                     mInTransition = false;
 156                     mActualState = true;
 157                     break;
 158                 case STATE_TURNING_ON:
 159                     mInTransition = true;
 160                     mActualState = false;
 161                     break;
 162                 case STATE_TURNING_OFF:
 163                     mInTransition = true;
 164                     mActualState = true;
 165                     break;
 166             }
 167
 168             if (wasInTransition && !mInTransition) {
 169                 if (mDeferredStateChangeRequestNeeded) {
 170                     Log.v(TAG, "processing deferred state change");
 171                     if (mActualState != null && mIntendedState != null &&
 172                         mIntendedState.equals(mActualState)) {
 173                         Log.v(TAG, "... but intended state matches, so no changes.");
 174                     } else if (mIntendedState != null) {
 175                         mInTransition = true;
 176                         requestStateChange(context, mIntendedState);
 177                     }
 178                     mDeferredStateChangeRequestNeeded = false;
 179                 }
 180             }
 181         }
 182
 183
 184         /**
 185          * If we're in a transition mode, this returns true if we're
 186          * transitioning towards being enabled.
 187          */
 188         public final boolean isTurningOn() {
 189             return mIntendedState != null && mIntendedState;
 190         }
 191
 192         /**
 193          * Returns simplified 3-state value from underlying 5-state.
 194          *
 195          * @param context
 196          * @return STATE_ENABLED, STATE_DISABLED, or STATE_INTERMEDIATE
 197          */
 198         public final int getTriState(Context context) {
 199             if (mInTransition) {
 200                 // If we know we just got a toggle request recently
 201                 // (which set mInTransition), don't even ask the
 202                 // underlying interface for its state.  We know we're
 203                 // changing.  This avoids blocking the UI thread
 204                 // during UI refresh post-toggle if the underlying
 205                 // service state accessor has coarse locking on its
 206                 // state (to be fixed separately).
 207                 return STATE_INTERMEDIATE;
 208             }
 209             switch (getActualState(context)) {
 210                 case STATE_DISABLED:
 211                     return STATE_DISABLED;
 212                 case STATE_ENABLED:
 213                     return STATE_ENABLED;
 214                 default:
 215                     return STATE_INTERMEDIATE;
 216             }
 217         }
 218
 219         /**
 220          * Gets underlying actual state.
 221          *
 222          * @param context
 223          * @return STATE_ENABLED, STATE_DISABLED, STATE_ENABLING, STATE_DISABLING,
 224          *         or or STATE_UNKNOWN.
 225          */
 226         public abstract int getActualState(Context context);
 227
 228         /**
 229          * Actually make the desired change to the underlying radio
 230          * API.
 231          */
 232         protected abstract void requestStateChange(Context context, boolean desiredState);
 233     }
 234
 235     /**
 236      * Subclass of StateTracker to get/set Wifi state.
 237      */
 238     private static final class WifiStateTracker extends StateTracker {
 239         @Override
 240         public int getActualState(Context context) {
 241             WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
 242             if (wifiManager != null) {
 243                 return wifiStateToFiveState(wifiManager.getWifiState());
 244             }
 245             return STATE_UNKNOWN;
 246         }
 247
 248         @Override
 249         protected void requestStateChange(Context context, final boolean desiredState) {
 250             final WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
 251             if (wifiManager == null) {
 252                 Log.d(TAG, "No wifiManager.");
 253                 return;
 254             }
 255
 256             // Actually request the wifi change and persistent
 257             // settings write off the UI thread, as it can take a
 258             // user-noticeable amount of time, especially if there's
 259             // disk contention.
 260             new AsyncTask<Void, Void, Void>() {
 261                 @Override
 262                 protected Void doInBackground(Void... args) {
 263                     /**
 264                      * Disable tethering if enabling Wifi
 265                      */
 266                     int wifiApState = wifiManager.getWifiApState();
 267                     if (desiredState && ((wifiApState == WifiManager.WIFI_AP_STATE_ENABLING) ||
 268                                          (wifiApState == WifiManager.WIFI_AP_STATE_ENABLED))) {
 269                         wifiManager.setWifiApEnabled(null, false);
 270                     }
 271
 272                     wifiManager.setWifiEnabled(desiredState);
 273                     return null;
 274                 }
 275             }.execute();
 276         }
 277
 278         @Override
 279         public void onActualStateChange(Context context, Intent intent) {
 280             if (!WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {
 281                 return;
 282             }
 283             int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, -1);
 284             setCurrentState(context, wifiStateToFiveState(wifiState));
 285         }
 286
 287         /**
 288          * Converts WifiManager's state values into our
 289          * Wifi/Bluetooth-common state values.
 290          */
 291         private static int wifiStateToFiveState(int wifiState) {
 292             switch (wifiState) {
 293                 case WifiManager.WIFI_STATE_DISABLED:
 294                     return STATE_DISABLED;
 295                 case WifiManager.WIFI_STATE_ENABLED:
 296                     return STATE_ENABLED;
 297                 case WifiManager.WIFI_STATE_DISABLING:
 298                     return STATE_TURNING_OFF;
 299                 case WifiManager.WIFI_STATE_ENABLING:
 300                     return STATE_TURNING_ON;
 301                 default:
 302                     return STATE_UNKNOWN;
 303             }
 304         }
 305     }
 306
 307     /**
 308      * Subclass of StateTracker to get/set Bluetooth state.
 309      */
 310     private static final class BluetoothStateTracker extends StateTracker {
 311
 312         @Override
 313         public int getActualState(Context context) {
 314             if (sLocalBluetoothManager == null) {
 315                 sLocalBluetoothManager = LocalBluetoothManager.getInstance(context);
 316                 if (sLocalBluetoothManager == null) {
 317                     return STATE_UNKNOWN;  // On emulator?
 318                 }
 319             }
 320             return bluetoothStateToFiveState(sLocalBluetoothManager.getBluetoothState());
 321         }
 322
 323         @Override
 324         protected void requestStateChange(Context context, final boolean desiredState) {
 325             if (sLocalBluetoothManager == null) {
 326                 Log.d(TAG, "No LocalBluetoothManager");
 327                 return;
 328             }
 329             // Actually request the Bluetooth change and persistent
 330             // settings write off the UI thread, as it can take a
 331             // user-noticeable amount of time, especially if there's
 332             // disk contention.
 333             new AsyncTask<Void, Void, Void>() {
 334                 @Override
 335                 protected Void doInBackground(Void... args) {
 336                     sLocalBluetoothManager.setBluetoothEnabled(desiredState);
 337                     return null;
 338                 }
 339             }.execute();
 340         }
 341
 342         @Override
 343         public void onActualStateChange(Context context, Intent intent) {
 344             if (!BluetoothAdapter.ACTION_STATE_CHANGED.equals(intent.getAction())) {
 345                 return;
 346             }
 347             int bluetoothState = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1);
 348             setCurrentState(context, bluetoothStateToFiveState(bluetoothState));
 349         }
 350
 351         /**
 352          * Converts BluetoothAdapter's state values into our
 353          * Wifi/Bluetooth-common state values.
 354          */
 355         private static int bluetoothStateToFiveState(int bluetoothState) {
 356             switch (bluetoothState) {
 357                 case BluetoothAdapter.STATE_OFF:
 358                     return STATE_DISABLED;
 359                 case BluetoothAdapter.STATE_ON:
 360                     return STATE_ENABLED;
 361                 case BluetoothAdapter.STATE_TURNING_ON:
 362                     return STATE_TURNING_ON;
 363                 case BluetoothAdapter.STATE_TURNING_OFF:
 364                     return STATE_TURNING_OFF;
 365                 default:
 366                     return STATE_UNKNOWN;
 367             }
 368         }
 369     }
 370
 371
 372     @Override
 373     public void onUpdate(Context context, AppWidgetManager appWidgetManager,
 374             int[] appWidgetIds) {
 375         // Update each requested appWidgetId
 376         RemoteViews view = buildUpdate(context, -1);
 377
 378         for (int i = 0; i < appWidgetIds.length; i++) {
 379             appWidgetManager.updateAppWidget(appWidgetIds[i], view);
 380         }
 381     }
 382
 383     @Override
 384     public void onEnabled(Context context) {
 385         PackageManager pm = context.getPackageManager();
 386         pm.setComponentEnabledSetting(
 387                 new ComponentName("com.android.settings", ".widget.SettingsAppWidgetProvider"),
 388                 PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
 389                 PackageManager.DONT_KILL_APP);
 390     }
 391
 392     @Override
 393     public void onDisabled(Context context) {
 394         Class clazz = com.android.settings.widget.SettingsAppWidgetProvider.class;
 395         PackageManager pm = context.getPackageManager();
 396         pm.setComponentEnabledSetting(
 397                 new ComponentName("com.android.settings", ".widget.SettingsAppWidgetProvider"),
 398                 PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
 399                 PackageManager.DONT_KILL_APP);
 400     }
 401
 402     /**
 403      * Load image for given widget and build {@link RemoteViews} for it.
 404      */
 405     static RemoteViews buildUpdate(Context context, int appWidgetId) {
 406         RemoteViews views = new RemoteViews(context.getPackageName(),
 407                 R.layout.widget);
 408         views.setOnClickPendingIntent(R.id.btn_wifi, getLaunchPendingIntent(context, appWidgetId,
 409                 BUTTON_WIFI));
 410         views.setOnClickPendingIntent(R.id.btn_brightness,
 411                 getLaunchPendingIntent(context,
 412                         appWidgetId, BUTTON_BRIGHTNESS));
 413         views.setOnClickPendingIntent(R.id.btn_sync,
 414                 getLaunchPendingIntent(context,
 415                         appWidgetId, BUTTON_SYNC));
 416         views.setOnClickPendingIntent(R.id.btn_gps,
 417                 getLaunchPendingIntent(context, appWidgetId, BUTTON_GPS));
 418         views.setOnClickPendingIntent(R.id.btn_bluetooth,
 419                 getLaunchPendingIntent(context,
 420                         appWidgetId, BUTTON_BLUETOOTH));
 421
 422         updateButtons(views, context);
 423         return views;
 424     }
 425
 426     /**
 427      * Updates the widget when something changes, or when a button is pushed.
 428      *
 429      * @param context
 430      */
 431     public static void updateWidget(Context context) {
 432         RemoteViews views = buildUpdate(context, -1);
 433         // Update specific list of appWidgetIds if given, otherwise default to all
 434         final AppWidgetManager gm = AppWidgetManager.getInstance(context);
 435         gm.updateAppWidget(THIS_APPWIDGET, views);
 436     }
 437
 438     /**
 439      * Updates the buttons based on the underlying states of wifi, etc.
 440      *
 441      * @param views   The RemoteViews to update.
 442      * @param context
 443      */
 444     private static void updateButtons(RemoteViews views, Context context) {
 445         switch (sWifiState.getTriState(context)) {
 446             case STATE_DISABLED:
 447                 views.setImageViewResource(R.id.img_wifi,
 448                                            R.drawable.ic_appwidget_settings_wifi_off);
 449                 views.setImageViewResource(R.id.ind_wifi,
 450                                            R.drawable.appwidget_settings_ind_off_l);
 451                 break;
 452             case STATE_ENABLED:
 453                 views.setImageViewResource(R.id.img_wifi,
 454                                            R.drawable.ic_appwidget_settings_wifi_on);
 455                 views.setImageViewResource(R.id.ind_wifi,
 456                                            R.drawable.appwidget_settings_ind_on_l);
 457                 break;
 458             case STATE_INTERMEDIATE:
 459                 // In the transitional state, the bottom green bar
 460                 // shows the tri-state (on, off, transitioning), but
 461                 // the top dark-gray-or-bright-white logo shows the
 462                 // user's intent.  This is much easier to see in
 463                 // sunlight.
 464                 if (sWifiState.isTurningOn()) {
 465                     views.setImageViewResource(R.id.img_wifi,
 466                                                R.drawable.ic_appwidget_settings_wifi_on);
 467                     views.setImageViewResource(R.id.ind_wifi,
 468                                                R.drawable.appwidget_settings_ind_mid_l);
 469                 } else {
 470                     views.setImageViewResource(R.id.img_wifi,
 471                                                R.drawable.ic_appwidget_settings_wifi_off);
 472                     views.setImageViewResource(R.id.ind_wifi,
 473                                                R.drawable.appwidget_settings_ind_off_l);
 474                 }
 475                 break;
 476         }
 477         if (getBrightnessMode(context)) {
 478             views.setImageViewResource(R.id.img_brightness,
 479                                        R.drawable.ic_appwidget_settings_brightness_auto);
 480             views.setImageViewResource(R.id.ind_brightness,
 481                                        R.drawable.appwidget_settings_ind_on_r);
 482         } else if (getBrightness(context)) {
 483             views.setImageViewResource(R.id.img_brightness,
 484                                        R.drawable.ic_appwidget_settings_brightness_on);
 485             views.setImageViewResource(R.id.ind_brightness,
 486                                        R.drawable.appwidget_settings_ind_on_r);
 487         } else {
 488             views.setImageViewResource(R.id.img_brightness,
 489                                        R.drawable.ic_appwidget_settings_brightness_off);
 490             views.setImageViewResource(R.id.ind_brightness,
 491                                        R.drawable.appwidget_settings_ind_off_r);
 492         }
 493         if (getSync(context)) {
 494             views.setImageViewResource(R.id.img_sync, R.drawable.ic_appwidget_settings_sync_on);
 495             views.setImageViewResource(R.id.ind_sync, R.drawable.appwidget_settings_ind_on_c);
 496         } else {
 497             views.setImageViewResource(R.id.img_sync, R.drawable.ic_appwidget_settings_sync_off);
 498             views.setImageViewResource(R.id.ind_sync, R.drawable.appwidget_settings_ind_off_c);
 499         }
 500         if (getGpsState(context)) {
 501             views.setImageViewResource(R.id.img_gps, R.drawable.ic_appwidget_settings_gps_on);
 502             views.setImageViewResource(R.id.ind_gps, R.drawable.appwidget_settings_ind_on_c);
 503         } else {
 504             views.setImageViewResource(R.id.img_gps, R.drawable.ic_appwidget_settings_gps_off);
 505             views.setImageViewResource(R.id.ind_gps, R.drawable.appwidget_settings_ind_off_c);
 506         }
 507         switch (sBluetoothState.getTriState(context)) {
 508             case STATE_DISABLED:
 509                 views.setImageViewResource(R.id.img_bluetooth,
 510                                            R.drawable.ic_appwidget_settings_bluetooth_off);
 511                 views.setImageViewResource(R.id.ind_bluetooth,
 512                                            R.drawable.appwidget_settings_ind_off_c);
 513                 break;
 514             case STATE_ENABLED:
 515                 views.setImageViewResource(R.id.img_bluetooth,
 516                                            R.drawable.ic_appwidget_settings_bluetooth_on);
 517                 views.setImageViewResource(R.id.ind_bluetooth,
 518                                            R.drawable.appwidget_settings_ind_on_c);
 519                 break;
 520             case STATE_INTERMEDIATE:
 521                 // In the transitional state, the bottom green bar
 522                 // shows the tri-state (on, off, transitioning), but
 523                 // the top dark-gray-or-bright-white logo shows the
 524                 // user's intent.  This is much easier to see in
 525                 // sunlight.
 526                 if (sBluetoothState.isTurningOn()) {
 527                     views.setImageViewResource(R.id.img_bluetooth,
 528                                                R.drawable.ic_appwidget_settings_bluetooth_on);
 529                     views.setImageViewResource(R.id.ind_bluetooth,
 530                                                R.drawable.appwidget_settings_ind_mid_c);
 531                 } else {
 532                     views.setImageViewResource(R.id.img_bluetooth,
 533                                                R.drawable.ic_appwidget_settings_bluetooth_off);
 534                     views.setImageViewResource(R.id.ind_bluetooth,
 535                                                R.drawable.appwidget_settings_ind_off_c);
 536                 }
 537                 break;
 538         }
 539     }
 540
 541     /**
 542      * Creates PendingIntent to notify the widget of a button click.
 543      *
 544      * @param context
 545      * @param appWidgetId
 546      * @return
 547      */
 548     private static PendingIntent getLaunchPendingIntent(Context context, int appWidgetId,
 549             int buttonId) {
 550         Intent launchIntent = new Intent();
 551         launchIntent.setClass(context, SettingsAppWidgetProvider.class);
 552         launchIntent.addCategory(Intent.CATEGORY_ALTERNATIVE);
 553         launchIntent.setData(Uri.parse("custom:" + buttonId));
 554         PendingIntent pi = PendingIntent.getBroadcast(context, 0 /* no requestCode */,
 555                 launchIntent, 0 /* no flags */);
 556         return pi;
 557     }
 558
 559     /**
 560      * Receives and processes a button pressed intent or state change.
 561      *
 562      * @param context
 563      * @param intent  Indicates the pressed button.
 564      */
 565     @Override
 566     public void onReceive(Context context, Intent intent) {
 567         super.onReceive(context, intent);
 568         if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {
 569             sWifiState.onActualStateChange(context, intent);
 570         } else if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(intent.getAction())) {
 571             sBluetoothState.onActualStateChange(context, intent);
 572         } else if (intent.hasCategory(Intent.CATEGORY_ALTERNATIVE)) {
 573             Uri data = intent.getData();
 574             int buttonId = Integer.parseInt(data.getSchemeSpecificPart());
 575             if (buttonId == BUTTON_WIFI) {
 576                 sWifiState.toggleState(context);
 577             } else if (buttonId == BUTTON_BRIGHTNESS) {
 578                 toggleBrightness(context);
 579             } else if (buttonId == BUTTON_SYNC) {
 580                 toggleSync(context);
 581             } else if (buttonId == BUTTON_GPS) {
 582                 toggleGps(context);
 583             } else if (buttonId == BUTTON_BLUETOOTH) {
 584                 sBluetoothState.toggleState(context);
 585             }
 586         } else {
 587             // Don't fall-through to updating the widget.  The Intent
 588             // was something unrelated or that our super class took
 589             // care of.
 590             return;
 591         }
 592
 593         // State changes fall through
 594         updateWidget(context);
 595     }
 596
 597     /**
 598      * Gets the state of background data.
 599      *
 600      * @param context
 601      * @return true if enabled
 602      */
 603     private static boolean getBackgroundDataState(Context context) {
 604         ConnectivityManager connManager =
 605                 (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
 606         return connManager.getBackgroundDataSetting();
 607     }
 608
 609     /**
 610      * Gets the state of auto-sync.
 611      *
 612      * @param context
 613      * @return true if enabled
 614      */
 615     private static boolean getSync(Context context) {
 616         boolean backgroundData = getBackgroundDataState(context);
 617         boolean sync = ContentResolver.getMasterSyncAutomatically();
 618         return backgroundData && sync;
 619     }
 620
 621     /**
 622      * Toggle auto-sync
 623      *
 624      * @param context
 625      */
 626     private void toggleSync(Context context) {
 627         ConnectivityManager connManager =
 628                 (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
 629         boolean backgroundData = getBackgroundDataState(context);
 630         boolean sync = ContentResolver.getMasterSyncAutomatically();
 631
 632         // four cases to handle:
 633         // setting toggled from off to on:
 634         // 1. background data was off, sync was off: turn on both
 635         if (!backgroundData && !sync) {
 636             connManager.setBackgroundDataSetting(true);
 637             ContentResolver.setMasterSyncAutomatically(true);
 638         }
 639
 640         // 2. background data was off, sync was on: turn on background data
 641         if (!backgroundData && sync) {
 642             connManager.setBackgroundDataSetting(true);
 643         }
 644
 645         // 3. background data was on, sync was off: turn on sync
 646         if (backgroundData && !sync) {
 647             ContentResolver.setMasterSyncAutomatically(true);
 648         }
 649
 650         // setting toggled from on to off:
 651         // 4. background data was on, sync was on: turn off sync
 652         if (backgroundData && sync) {
 653             ContentResolver.setMasterSyncAutomatically(false);
 654         }
 655     }
 656
 657     /**
 658      * Gets the state of GPS location.
 659      *
 660      * @param context
 661      * @return true if enabled.
 662      */
 663     private static boolean getGpsState(Context context) {
 664         ContentResolver resolver = context.getContentResolver();
 665         return Settings.Secure.isLocationProviderEnabled(resolver, LocationManager.GPS_PROVIDER);
 666     }
 667
 668     /**
 669      * Toggles the state of GPS.
 670      *
 671      * @param context
 672      */
 673     private void toggleGps(Context context) {
 674         ContentResolver resolver = context.getContentResolver();
 675         boolean enabled = getGpsState(context);
 676         Settings.Secure.setLocationProviderEnabled(resolver, LocationManager.GPS_PROVIDER,
 677                 !enabled);
 678     }
 679
 680     /**
 681      * Gets state of brightness.
 682      *
 683      * @param context
 684      * @return true if more than moderately bright.
 685      */
 686     private static boolean getBrightness(Context context) {
 687         try {
 688             IPowerManager power = IPowerManager.Stub.asInterface(
 689                     ServiceManager.getService("power"));
 690             if (power != null) {
 691                 int brightness = Settings.System.getInt(context.getContentResolver(),
 692                         Settings.System.SCREEN_BRIGHTNESS);
 693                 return brightness > 100;
 694             }
 695         } catch (Exception e) {
 696             Log.d(TAG, "getBrightness: " + e);
 697         }
 698         return false;
 699     }
 700
 701     /**
 702      * Gets state of brightness mode.
 703      *
 704      * @param context
 705      * @return true if auto brightness is on.
 706      */
 707     private static boolean getBrightnessMode(Context context) {
 708         try {
 709             IPowerManager power = IPowerManager.Stub.asInterface(
 710                     ServiceManager.getService("power"));
 711             if (power != null) {
 712                 int brightnessMode = Settings.System.getInt(context.getContentResolver(),
 713                         Settings.System.SCREEN_BRIGHTNESS_MODE);
 714                 return brightnessMode == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC;
 715             }
 716         } catch (Exception e) {
 717             Log.d(TAG, "getBrightnessMode: " + e);
 718         }
 719         return false;
 720     }
 721
 722     /**
 723      * Increases or decreases the brightness.
 724      *
 725      * @param context
 726      */
 727     private void toggleBrightness(Context context) {
 728         try {
 729             IPowerManager power = IPowerManager.Stub.asInterface(
 730                     ServiceManager.getService("power"));
 731             if (power != null) {
 732                 ContentResolver cr = context.getContentResolver();
 733                 int brightness = Settings.System.getInt(cr,
 734                         Settings.System.SCREEN_BRIGHTNESS);
 735                 int brightnessMode = Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL;
 736                 //Only get brightness setting if available
 737                 if (context.getResources().getBoolean(
 738                         com.android.internal.R.bool.config_automatic_brightness_available)) {
 739                     brightnessMode = Settings.System.getInt(cr,
 740                             Settings.System.SCREEN_BRIGHTNESS_MODE);
 741                 }
 742
 743                 // Rotate AUTO -> MINIMUM -> DEFAULT -> MAXIMUM
 744                 // Technically, not a toggle...
 745                 if (brightnessMode == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC) {
 746                     brightness = MINIMUM_BACKLIGHT;
 747                     brightnessMode = Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL;
 748                 } else if (brightness < DEFAULT_BACKLIGHT) {
 749                     brightness = DEFAULT_BACKLIGHT;
 750                 } else if (brightness < MAXIMUM_BACKLIGHT) {
 751                     brightness = MAXIMUM_BACKLIGHT;
 752                 } else {
 753                     brightnessMode = Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC;
 754                     brightness = MINIMUM_BACKLIGHT;
 755                 }
 756
 757                 if (context.getResources().getBoolean(
 758                         com.android.internal.R.bool.config_automatic_brightness_available)) {
 759                     // Set screen brightness mode (automatic or manual)
 760                     Settings.System.putInt(context.getContentResolver(),
 761                             Settings.System.SCREEN_BRIGHTNESS_MODE,
 762                             brightnessMode);
 763                 } else {
 764                     // Make sure we set the brightness if automatic mode isn't available
 765                     brightnessMode = Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL;
 766                 }
 767                 if (brightnessMode == Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL) {
 768                     power.setBacklightBrightness(brightness);
 769                     Settings.System.putInt(cr, Settings.System.SCREEN_BRIGHTNESS, brightness);
 770                 }
 771             }
 772         } catch (RemoteException e) {
 773             Log.d(TAG, "toggleBrightness: " + e);
 774         } catch (Settings.SettingNotFoundException e) {
 775             Log.d(TAG, "toggleBrightness: " + e);
 776         }
 777     }
 778 }