Home | History | Annotate | Download | only in bluetooth 
      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 com.android.settings.R;
     20 
     21 import android.app.Activity;
     22 import android.app.AlertDialog;
     23 import android.bluetooth.BluetoothAdapter;
     24 import android.bluetooth.BluetoothDevice;
     25 import android.content.BroadcastReceiver;
     26 import android.content.Context;
     27 import android.content.DialogInterface;
     28 import android.content.Intent;
     29 import android.content.IntentFilter;
     30 import android.os.Bundle;
     31 import android.util.Log;
     32 
     33 /**
     34  * RequestPermissionActivity asks the user whether to enable discovery. This is
     35  * usually started by an application wanted to start bluetooth and or discovery
     36  */
     37 public class RequestPermissionActivity extends Activity implements
     38         DialogInterface.OnClickListener {
     39     // Command line to test this
     40     // adb shell am start -a android.bluetooth.adapter.action.REQUEST_ENABLE
     41     // adb shell am start -a android.bluetooth.adapter.action.REQUEST_DISCOVERABLE
     42 
     43     private static final String TAG = "RequestPermissionActivity";
     44 
     45     private static final int MAX_DISCOVERABLE_TIMEOUT = 3600; // 1 hr
     46 
     47     // Non-error return code: BT is starting or has started successfully. Used
     48     // by this Activity and RequestPermissionHelperActivity
     49     /* package */ static final int RESULT_BT_STARTING_OR_STARTED = -1000;
     50 
     51     private static final int REQUEST_CODE_START_BT = 1;
     52 
     53     private LocalBluetoothAdapter mLocalAdapter;
     54 
     55     private int mTimeout = BluetoothDiscoverableEnabler.DEFAULT_DISCOVERABLE_TIMEOUT;
     56 
     57     /*
     58      * True if bluetooth wasn't enabled and RequestPermissionHelperActivity was
     59      * started to ask the user and start bt.
     60      *
     61      * If/when that activity returns successfully, display please wait msg then
     62      * go away when bt has started and discovery mode has been enabled.
     63      */
     64     private boolean mNeededToEnableBluetooth;
     65 
     66     // True if requesting BT to be turned on
     67     // False if requesting BT to be turned on + discoverable mode
     68     private boolean mEnableOnly;
     69 
     70     private boolean mUserConfirmed;
     71 
     72     private AlertDialog mDialog;
     73 
     74     private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
     75 
     76         @Override
     77         public void onReceive(Context context, Intent intent) {
     78             if (intent == null) {
     79                 return;
     80             }
     81             if (mNeededToEnableBluetooth
     82                     && BluetoothAdapter.ACTION_STATE_CHANGED.equals(intent.getAction())) {
     83                 int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothDevice.ERROR);
     84                 if (state == BluetoothAdapter.STATE_ON) {
     85                     if (mUserConfirmed) {
     86                         proceedAndFinish();
     87                     }
     88                 }
     89             }
     90         }
     91     };
     92 
     93     @Override
     94     protected void onCreate(Bundle savedInstanceState) {
     95         super.onCreate(savedInstanceState);
     96 
     97         // Note: initializes mLocalAdapter and returns true on error
     98         if (parseIntent()) {
     99             finish();
    100             return;
    101         }
    102 
    103         int btState = mLocalAdapter.getState();
    104 
    105         switch (btState) {
    106             case BluetoothAdapter.STATE_OFF:
    107             case BluetoothAdapter.STATE_TURNING_OFF:
    108             case BluetoothAdapter.STATE_TURNING_ON:
    109                 /*
    110                  * Strictly speaking STATE_TURNING_ON belong with STATE_ON;
    111                  * however, BT may not be ready when the user clicks yes and we
    112                  * would fail to turn on discovery mode. By kicking this to the
    113                  * RequestPermissionHelperActivity, this class will handle that
    114                  * case via the broadcast receiver.
    115                  */
    116 
    117                 /*
    118                  * Start the helper activity to:
    119                  * 1) ask the user about enabling bt AND discovery
    120                  * 2) enable BT upon confirmation
    121                  */
    122                 registerReceiver(mReceiver,
    123                         new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED));
    124                 Intent intent = new Intent();
    125                 intent.setClass(this, RequestPermissionHelperActivity.class);
    126                 if (mEnableOnly) {
    127                     intent.setAction(RequestPermissionHelperActivity.ACTION_INTERNAL_REQUEST_BT_ON);
    128                 } else {
    129                     intent.setAction(RequestPermissionHelperActivity.
    130                             ACTION_INTERNAL_REQUEST_BT_ON_AND_DISCOVERABLE);
    131                     intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, mTimeout);
    132                 }
    133                 startActivityForResult(intent, REQUEST_CODE_START_BT);
    134                 mNeededToEnableBluetooth = true;
    135                 break;
    136             case BluetoothAdapter.STATE_ON:
    137                 if (mEnableOnly) {
    138                     // Nothing to do. Already enabled.
    139                     proceedAndFinish();
    140                 } else {
    141                     // Ask the user about enabling discovery mode
    142                     createDialog();
    143                 }
    144                 break;
    145             default:
    146                 Log.e(TAG, "Unknown adapter state: " + btState);
    147         }
    148     }
    149 
    150     private void createDialog() {
    151         AlertDialog.Builder builder = new AlertDialog.Builder(this);
    152         builder.setIcon(android.R.drawable.ic_dialog_info);
    153         builder.setTitle(getString(R.string.bluetooth_permission_request));
    154 
    155         if (mNeededToEnableBluetooth) {
    156             // RequestPermissionHelperActivity has gotten confirmation from user
    157             // to turn on BT
    158             builder.setMessage(getString(R.string.bluetooth_turning_on));
    159             builder.setCancelable(false);
    160         } else {
    161             // Ask the user whether to turn on discovery mode or not
    162             // For lasting discoverable mode there is a different message
    163             if (mTimeout == BluetoothDiscoverableEnabler.DISCOVERABLE_TIMEOUT_NEVER) {
    164                 builder.setMessage(
    165                         getString(R.string.bluetooth_ask_lasting_discovery));
    166             } else {
    167                 builder.setMessage(
    168                         getString(R.string.bluetooth_ask_discovery, mTimeout));
    169             }
    170             builder.setPositiveButton(getString(R.string.yes), this);
    171             builder.setNegativeButton(getString(R.string.no), this);
    172         }
    173 
    174         mDialog = builder.create();
    175         mDialog.show();
    176 
    177         if (getResources().getBoolean(R.bool.auto_confirm_bluetooth_activation_dialog) == true) {
    178             // dismiss dialog immediately if settings say so
    179             onClick(null, DialogInterface.BUTTON_POSITIVE);
    180         }
    181     }
    182 
    183     @Override
    184     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    185         if (requestCode != REQUEST_CODE_START_BT) {
    186             Log.e(TAG, "Unexpected onActivityResult " + requestCode + ' ' + resultCode);
    187             setResult(RESULT_CANCELED);
    188             finish();
    189             return;
    190         }
    191         if (resultCode != RESULT_BT_STARTING_OR_STARTED) {
    192             setResult(resultCode);
    193             finish();
    194             return;
    195         }
    196 
    197         // Back from RequestPermissionHelperActivity. User confirmed to enable
    198         // BT and discoverable mode.
    199         mUserConfirmed = true;
    200 
    201         if (mLocalAdapter.getBluetoothState() == BluetoothAdapter.STATE_ON) {
    202             proceedAndFinish();
    203         } else {
    204             // If BT is not up yet, show "Turning on Bluetooth..."
    205             createDialog();
    206         }
    207     }
    208 
    209     public void onClick(DialogInterface dialog, int which) {
    210         switch (which) {
    211             case DialogInterface.BUTTON_POSITIVE:
    212                 proceedAndFinish();
    213                 break;
    214 
    215             case DialogInterface.BUTTON_NEGATIVE:
    216                 setResult(RESULT_CANCELED);
    217                 finish();
    218                 break;
    219         }
    220     }
    221 
    222     private void proceedAndFinish() {
    223         int returnCode;
    224 
    225         if (mEnableOnly) {
    226             // BT enabled. Done
    227             returnCode = RESULT_OK;
    228         } else if (mLocalAdapter.setScanMode(
    229                 BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE, mTimeout)) {
    230             // If already in discoverable mode, this will extend the timeout.
    231             long endTime = System.currentTimeMillis() + (long) mTimeout * 1000;
    232             LocalBluetoothPreferences.persistDiscoverableEndTimestamp(
    233                     this, endTime);
    234             if (0 < mTimeout) {
    235                BluetoothDiscoverableTimeoutReceiver.setDiscoverableAlarm(this, endTime);
    236             }
    237             returnCode = mTimeout;
    238             // Activity.RESULT_FIRST_USER should be 1
    239             if (returnCode < RESULT_FIRST_USER) {
    240                 returnCode = RESULT_FIRST_USER;
    241             }
    242         } else {
    243             returnCode = RESULT_CANCELED;
    244         }
    245 
    246         if (mDialog != null) {
    247             mDialog.dismiss();
    248         }
    249 
    250         setResult(returnCode);
    251         finish();
    252     }
    253 
    254     /**
    255      * Parse the received Intent and initialize mLocalBluetoothAdapter.
    256      * @return true if an error occurred; false otherwise
    257      */
    258     private boolean parseIntent() {
    259         Intent intent = getIntent();
    260         if (intent != null && intent.getAction().equals(BluetoothAdapter.ACTION_REQUEST_ENABLE)) {
    261             mEnableOnly = true;
    262         } else if (intent != null
    263                 && intent.getAction().equals(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE)) {
    264             mTimeout = intent.getIntExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,
    265                     BluetoothDiscoverableEnabler.DEFAULT_DISCOVERABLE_TIMEOUT);
    266 
    267             Log.d(TAG, "Setting Bluetooth Discoverable Timeout = " + mTimeout);
    268 
    269             if (mTimeout < 0 || mTimeout > MAX_DISCOVERABLE_TIMEOUT) {
    270                 mTimeout = BluetoothDiscoverableEnabler.DEFAULT_DISCOVERABLE_TIMEOUT;
    271             }
    272         } else {
    273             Log.e(TAG, "Error: this activity may be started only with intent "
    274                     + BluetoothAdapter.ACTION_REQUEST_ENABLE + " or "
    275                     + BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
    276             setResult(RESULT_CANCELED);
    277             return true;
    278         }
    279 
    280         LocalBluetoothManager manager = LocalBluetoothManager.getInstance(this);
    281         if (manager == null) {
    282             Log.e(TAG, "Error: there's a problem starting Bluetooth");
    283             setResult(RESULT_CANCELED);
    284             return true;
    285         }
    286         mLocalAdapter = manager.getBluetoothAdapter();
    287 
    288         return false;
    289     }
    290 
    291     @Override
    292     protected void onDestroy() {
    293         super.onDestroy();
    294         if (mNeededToEnableBluetooth) {
    295             unregisterReceiver(mReceiver);
    296         }
    297     }
    298 
    299     @Override
    300     public void onBackPressed() {
    301         setResult(RESULT_CANCELED);
    302         super.onBackPressed();
    303     }
    304 }
    305