src/com/android/settings/bluetooth/RequestPermissionActivity.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.bluetooth;
  18
  19 import android.annotation.NonNull;
  20 import android.app.Activity;
  21 import android.app.AlertDialog;
  22 import android.bluetooth.BluetoothAdapter;
  23 import android.bluetooth.BluetoothDevice;
  24 import android.content.BroadcastReceiver;
  25 import android.content.Context;
  26 import android.content.DialogInterface;
  27 import android.content.Intent;
  28 import android.content.IntentFilter;
  29 import android.content.pm.ApplicationInfo;
  30 import android.content.pm.PackageManager;
  31 import android.os.Bundle;
  32 import android.text.TextUtils;
  33 import android.util.Log;
  34
  35 import com.android.settings.R;
  36 import com.android.settingslib.bluetooth.BluetoothDiscoverableTimeoutReceiver;
  37 import com.android.settingslib.bluetooth.LocalBluetoothAdapter;
  38 import com.android.settingslib.bluetooth.LocalBluetoothManager;
  39
  40 /**
  41  * RequestPermissionActivity asks the user whether to enable discovery. This is
  42  * usually started by an application wanted to start bluetooth and or discovery
  43  */
  44 public class RequestPermissionActivity extends Activity implements
  45         DialogInterface.OnClickListener {
  46     // Command line to test this
  47     // adb shell am start -a android.bluetooth.adapter.action.REQUEST_ENABLE
  48     // adb shell am start -a android.bluetooth.adapter.action.REQUEST_DISCOVERABLE
  49     // adb shell am start -a android.bluetooth.adapter.action.REQUEST_DISABLE
  50
  51     private static final String TAG = "RequestPermissionActivity";
  52
  53     private static final int MAX_DISCOVERABLE_TIMEOUT = 3600; // 1 hr
  54
  55     static final int REQUEST_ENABLE = 1;
  56     static final int REQUEST_ENABLE_DISCOVERABLE = 2;
  57     static final int REQUEST_DISABLE = 3;
  58
  59     private LocalBluetoothAdapter mLocalAdapter;
  60
  61     private int mTimeout = BluetoothDiscoverableEnabler.DEFAULT_DISCOVERABLE_TIMEOUT;
  62
  63     private int mRequest;
  64
  65     private AlertDialog mDialog;
  66
  67     private BroadcastReceiver mReceiver;
  68
  69     private @NonNull CharSequence mAppLabel;
  70
  71     @Override
  72     protected void onCreate(Bundle savedInstanceState) {
  73         super.onCreate(savedInstanceState);
  74
  75         setResult(Activity.RESULT_CANCELED);
  76
  77         // Note: initializes mLocalAdapter and returns true on error
  78         if (parseIntent()) {
  79             finish();
  80             return;
  81         }
  82
  83         int btState = mLocalAdapter.getState();
  84
  85         if (mRequest == REQUEST_DISABLE) {
  86             switch (btState) {
  87                 case BluetoothAdapter.STATE_OFF:
  88                 case BluetoothAdapter.STATE_TURNING_OFF: {
  89                     proceedAndFinish();
  90                 } break;
  91
  92                 case BluetoothAdapter.STATE_ON:
  93                 case BluetoothAdapter.STATE_TURNING_ON: {
  94                     Intent intent = new Intent(this, RequestPermissionHelperActivity.class);
  95                     intent.putExtra(RequestPermissionHelperActivity.EXTRA_APP_LABEL, mAppLabel);
  96                     intent.setAction(RequestPermissionHelperActivity
  97                                 .ACTION_INTERNAL_REQUEST_BT_OFF);
  98
  99                     startActivityForResult(intent, 0);
 100                 } break;
 101
 102                 default: {
 103                     Log.e(TAG, "Unknown adapter state: " + btState);
 104                     cancelAndFinish();
 105                 } break;
 106             }
 107         } else {
 108             switch (btState) {
 109                 case BluetoothAdapter.STATE_OFF:
 110                 case BluetoothAdapter.STATE_TURNING_OFF:
 111                 case BluetoothAdapter.STATE_TURNING_ON: {
 112                     /*
 113                      * Strictly speaking STATE_TURNING_ON belong with STATE_ON;
 114                      * however, BT may not be ready when the user clicks yes and we
 115                      * would fail to turn on discovery mode. By kicking this to the
 116                      * RequestPermissionHelperActivity, this class will handle that
 117                      * case via the broadcast receiver.
 118                      */
 119
 120                     /*
 121                      * Start the helper activity to:
 122                      * 1) ask the user about enabling bt AND discovery
 123                      * 2) enable BT upon confirmation
 124                      */
 125                     Intent intent = new Intent(this, RequestPermissionHelperActivity.class);
 126                     intent.setAction(RequestPermissionHelperActivity.ACTION_INTERNAL_REQUEST_BT_ON);
 127                     intent.putExtra(RequestPermissionHelperActivity.EXTRA_APP_LABEL, mAppLabel);
 128                     if (mRequest == REQUEST_ENABLE_DISCOVERABLE) {
 129                         intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, mTimeout);
 130                     }
 131                     startActivityForResult(intent, 0);
 132                 } break;
 133
 134                 case BluetoothAdapter.STATE_ON: {
 135                     if (mRequest == REQUEST_ENABLE) {
 136                         // Nothing to do. Already enabled.
 137                         proceedAndFinish();
 138                     } else {
 139                         // Ask the user about enabling discovery mode
 140                         createDialog();
 141                     }
 142                 } break;
 143
 144                 default: {
 145                     Log.e(TAG, "Unknown adapter state: " + btState);
 146                     cancelAndFinish();
 147                 } break;
 148             }
 149         }
 150     }
 151
 152     private void createDialog() {
 153         if (getResources().getBoolean(R.bool.auto_confirm_bluetooth_activation_dialog)) {
 154             onClick(null, DialogInterface.BUTTON_POSITIVE);
 155             return;
 156         }
 157
 158         AlertDialog.Builder builder = new AlertDialog.Builder(this);
 159
 160         // Non-null receiver means we are toggling
 161         if (mReceiver != null) {
 162             switch (mRequest) {
 163                 case REQUEST_ENABLE:
 164                 case REQUEST_ENABLE_DISCOVERABLE: {
 165                     builder.setMessage(getString(R.string.bluetooth_turning_on));
 166                 } break;
 167
 168                 default: {
 169                     builder.setMessage(getString(R.string.bluetooth_turning_off));
 170                 } break;
 171             }
 172             builder.setCancelable(false);
 173         } else {
 174             // Ask the user whether to turn on discovery mode or not
 175             // For lasting discoverable mode there is a different message
 176             if (mTimeout == BluetoothDiscoverableEnabler.DISCOVERABLE_TIMEOUT_NEVER) {
 177                 CharSequence message = mAppLabel != null
 178                         ? getString(R.string.bluetooth_ask_lasting_discovery, mAppLabel)
 179                         : getString(R.string.bluetooth_ask_lasting_discovery_no_name);
 180                 builder.setMessage(message);
 181             } else {
 182                 CharSequence message = mAppLabel != null
 183                         ? getString(R.string.bluetooth_ask_discovery, mAppLabel, mTimeout)
 184                         : getString(R.string.bluetooth_ask_discovery_no_name, mTimeout);
 185                 builder.setMessage(message);
 186             }
 187             builder.setPositiveButton(getString(R.string.allow), this);
 188             builder.setNegativeButton(getString(R.string.deny), this);
 189         }
 190
 191         mDialog = builder.create();
 192         mDialog.show();
 193     }
 194
 195     @Override
 196     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 197         if (resultCode != Activity.RESULT_OK) {
 198             cancelAndFinish();
 199             return;
 200         }
 201
 202         switch (mRequest) {
 203             case REQUEST_ENABLE:
 204             case REQUEST_ENABLE_DISCOVERABLE: {
 205                 if (mLocalAdapter.getBluetoothState() == BluetoothAdapter.STATE_ON) {
 206                     proceedAndFinish();
 207                 } else {
 208                     // If BT is not up yet, show "Turning on Bluetooth..."
 209                     mReceiver = new StateChangeReceiver();
 210                     registerReceiver(mReceiver, new IntentFilter(
 211                             BluetoothAdapter.ACTION_STATE_CHANGED));
 212                     createDialog();
 213                 }
 214             } break;
 215
 216             case REQUEST_DISABLE: {
 217                 if (mLocalAdapter.getBluetoothState() == BluetoothAdapter.STATE_OFF) {
 218                     proceedAndFinish();
 219                 } else {
 220                     // If BT is not up yet, show "Turning off Bluetooth..."
 221                     mReceiver = new StateChangeReceiver();
 222                     registerReceiver(mReceiver, new IntentFilter(
 223                             BluetoothAdapter.ACTION_STATE_CHANGED));
 224                     createDialog();
 225                 }
 226             } break;
 227
 228             default: {
 229                 cancelAndFinish();
 230             } break;
 231         }
 232     }
 233
 234     public void onClick(DialogInterface dialog, int which) {
 235         switch (which) {
 236             case DialogInterface.BUTTON_POSITIVE:
 237                 proceedAndFinish();
 238                 break;
 239
 240             case DialogInterface.BUTTON_NEGATIVE:
 241                 setResult(RESULT_CANCELED);
 242                 finish();
 243                 break;
 244         }
 245     }
 246
 247     private void proceedAndFinish() {
 248         int returnCode;
 249
 250         if (mRequest == REQUEST_ENABLE || mRequest == REQUEST_DISABLE) {
 251             // BT toggled. Done
 252             returnCode = RESULT_OK;
 253         } else if (mLocalAdapter.setScanMode(
 254                 BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE, mTimeout)) {
 255             // If already in discoverable mode, this will extend the timeout.
 256             long endTime = System.currentTimeMillis() + (long) mTimeout * 1000;
 257             LocalBluetoothPreferences.persistDiscoverableEndTimestamp(
 258                     this, endTime);
 259             if (0 < mTimeout) {
 260                BluetoothDiscoverableTimeoutReceiver.setDiscoverableAlarm(this, endTime);
 261             }
 262             returnCode = mTimeout;
 263             // Activity.RESULT_FIRST_USER should be 1
 264             if (returnCode < RESULT_FIRST_USER) {
 265                 returnCode = RESULT_FIRST_USER;
 266             }
 267         } else {
 268             returnCode = RESULT_CANCELED;
 269         }
 270
 271         if (mDialog != null) {
 272             mDialog.dismiss();
 273         }
 274
 275         setResult(returnCode);
 276         finish();
 277     }
 278
 279     private void cancelAndFinish() {
 280         setResult(Activity.RESULT_CANCELED);
 281         finish();
 282     }
 283
 284     /**
 285      * Parse the received Intent and initialize mLocalBluetoothAdapter.
 286      * @return true if an error occurred; false otherwise
 287      */
 288     private boolean parseIntent() {
 289         Intent intent = getIntent();
 290         if (intent == null) {
 291             return true;
 292         }
 293         if (intent.getAction().equals(BluetoothAdapter.ACTION_REQUEST_ENABLE)) {
 294             mRequest = REQUEST_ENABLE;
 295         } else if (intent.getAction().equals(BluetoothAdapter.ACTION_REQUEST_DISABLE)) {
 296             mRequest = REQUEST_DISABLE;
 297         } else if (intent.getAction().equals(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE)) {
 298             mRequest = REQUEST_ENABLE_DISCOVERABLE;
 299             mTimeout = intent.getIntExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,
 300                     BluetoothDiscoverableEnabler.DEFAULT_DISCOVERABLE_TIMEOUT);
 301
 302             Log.d(TAG, "Setting Bluetooth Discoverable Timeout = " + mTimeout);
 303
 304             if (mTimeout < 1 || mTimeout > MAX_DISCOVERABLE_TIMEOUT) {
 305                 mTimeout = BluetoothDiscoverableEnabler.DEFAULT_DISCOVERABLE_TIMEOUT;
 306             }
 307         } else {
 308             Log.e(TAG, "Error: this activity may be started only with intent "
 309                     + BluetoothAdapter.ACTION_REQUEST_ENABLE + " or "
 310                     + BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
 311             setResult(RESULT_CANCELED);
 312             return true;
 313         }
 314
 315         LocalBluetoothManager manager = Utils.getLocalBtManager(this);
 316         if (manager == null) {
 317             Log.e(TAG, "Error: there's a problem starting Bluetooth");
 318             setResult(RESULT_CANCELED);
 319             return true;
 320         }
 321
 322         String packageName = getCallingPackage();
 323         if (TextUtils.isEmpty(packageName)) {
 324             packageName = getIntent().getStringExtra(Intent.EXTRA_PACKAGE_NAME);
 325         }
 326         if (!TextUtils.isEmpty(packageName)) {
 327             try {
 328                 ApplicationInfo applicationInfo = getPackageManager().getApplicationInfo(
 329                         packageName, 0);
 330                 mAppLabel = applicationInfo.loadSafeLabel(getPackageManager());
 331             } catch (PackageManager.NameNotFoundException e) {
 332                 Log.e(TAG, "Couldn't find app with package name " + packageName);
 333                 setResult(RESULT_CANCELED);
 334                 return true;
 335             }
 336         }
 337
 338         mLocalAdapter = manager.getBluetoothAdapter();
 339
 340         return false;
 341     }
 342
 343     @Override
 344     protected void onDestroy() {
 345         super.onDestroy();
 346         if (mReceiver != null) {
 347             unregisterReceiver(mReceiver);
 348             mReceiver = null;
 349         }
 350     }
 351
 352     @Override
 353     public void onBackPressed() {
 354         setResult(RESULT_CANCELED);
 355         super.onBackPressed();
 356     }
 357
 358     private final class StateChangeReceiver extends BroadcastReceiver {
 359         private static final long TOGGLE_TIMEOUT_MILLIS = 10000; // 10 sec
 360
 361         public StateChangeReceiver() {
 362             getWindow().getDecorView().postDelayed(() -> {
 363                 if (!isFinishing() && !isDestroyed()) {
 364                     cancelAndFinish();
 365                 }
 366             }, TOGGLE_TIMEOUT_MILLIS);
 367         }
 368
 369         public void onReceive(Context context, Intent intent) {
 370             if (intent == null) {
 371                 return;
 372             }
 373             final int currentState = intent.getIntExtra(
 374                     BluetoothAdapter.EXTRA_STATE, BluetoothDevice.ERROR);
 375             switch (mRequest) {
 376                 case REQUEST_ENABLE:
 377                 case REQUEST_ENABLE_DISCOVERABLE: {
 378                     if (currentState == BluetoothAdapter.STATE_ON) {
 379                         proceedAndFinish();
 380                     }
 381                 } break;
 382
 383                 case REQUEST_DISABLE: {
 384                     if (currentState == BluetoothAdapter.STATE_OFF) {
 385                         proceedAndFinish();
 386                     }
 387                 } break;
 388             }
 389         }
 390     }
 391 }