396 lines
15 KiB
Java
396 lines
15 KiB
Java
/*
|
|
* Copyright (C) 2009 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.settings.bluetooth;
|
|
|
|
import android.annotation.NonNull;
|
|
import android.app.Activity;
|
|
import android.app.AlertDialog;
|
|
import android.bluetooth.BluetoothAdapter;
|
|
import android.bluetooth.BluetoothDevice;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.pm.ApplicationInfo;
|
|
import android.content.pm.PackageItemInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.os.Bundle;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
|
|
import com.android.settings.R;
|
|
import com.android.settingslib.bluetooth.BluetoothDiscoverableTimeoutReceiver;
|
|
import com.android.settingslib.bluetooth.LocalBluetoothAdapter;
|
|
import com.android.settingslib.bluetooth.LocalBluetoothManager;
|
|
|
|
/**
|
|
* RequestPermissionActivity asks the user whether to enable discovery. This is
|
|
* usually started by an application wanted to start bluetooth and or discovery
|
|
*/
|
|
public class RequestPermissionActivity extends Activity implements
|
|
DialogInterface.OnClickListener {
|
|
// Command line to test this
|
|
// adb shell am start -a android.bluetooth.adapter.action.REQUEST_ENABLE
|
|
// adb shell am start -a android.bluetooth.adapter.action.REQUEST_DISCOVERABLE
|
|
// adb shell am start -a android.bluetooth.adapter.action.REQUEST_DISABLE
|
|
|
|
private static final String TAG = "BtRequestPermission";
|
|
|
|
private static final int MAX_DISCOVERABLE_TIMEOUT = 3600; // 1 hr
|
|
|
|
static final int REQUEST_ENABLE = 1;
|
|
static final int REQUEST_ENABLE_DISCOVERABLE = 2;
|
|
static final int REQUEST_DISABLE = 3;
|
|
|
|
private LocalBluetoothAdapter mLocalAdapter;
|
|
|
|
private int mTimeout = BluetoothDiscoverableEnabler.DEFAULT_DISCOVERABLE_TIMEOUT;
|
|
|
|
private int mRequest;
|
|
|
|
private AlertDialog mDialog;
|
|
|
|
private BroadcastReceiver mReceiver;
|
|
|
|
private @NonNull CharSequence mAppLabel;
|
|
|
|
@Override
|
|
protected void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
|
|
setResult(Activity.RESULT_CANCELED);
|
|
|
|
// Note: initializes mLocalAdapter and returns true on error
|
|
if (parseIntent()) {
|
|
finish();
|
|
return;
|
|
}
|
|
|
|
int btState = mLocalAdapter.getState();
|
|
|
|
if (mRequest == REQUEST_DISABLE) {
|
|
switch (btState) {
|
|
case BluetoothAdapter.STATE_OFF:
|
|
case BluetoothAdapter.STATE_TURNING_OFF: {
|
|
proceedAndFinish();
|
|
} break;
|
|
|
|
case BluetoothAdapter.STATE_ON:
|
|
case BluetoothAdapter.STATE_TURNING_ON: {
|
|
Intent intent = new Intent(this, RequestPermissionHelperActivity.class);
|
|
intent.putExtra(RequestPermissionHelperActivity.EXTRA_APP_LABEL, mAppLabel);
|
|
intent.setAction(RequestPermissionHelperActivity
|
|
.ACTION_INTERNAL_REQUEST_BT_OFF);
|
|
|
|
startActivityForResult(intent, 0);
|
|
} break;
|
|
|
|
default: {
|
|
Log.e(TAG, "Unknown adapter state: " + btState);
|
|
cancelAndFinish();
|
|
} break;
|
|
}
|
|
} else {
|
|
switch (btState) {
|
|
case BluetoothAdapter.STATE_OFF:
|
|
case BluetoothAdapter.STATE_TURNING_OFF:
|
|
case BluetoothAdapter.STATE_TURNING_ON: {
|
|
/*
|
|
* Strictly speaking STATE_TURNING_ON belong with STATE_ON;
|
|
* however, BT may not be ready when the user clicks yes and we
|
|
* would fail to turn on discovery mode. By kicking this to the
|
|
* RequestPermissionHelperActivity, this class will handle that
|
|
* case via the broadcast receiver.
|
|
*/
|
|
|
|
/*
|
|
* Start the helper activity to:
|
|
* 1) ask the user about enabling bt AND discovery
|
|
* 2) enable BT upon confirmation
|
|
*/
|
|
Intent intent = new Intent(this, RequestPermissionHelperActivity.class);
|
|
intent.setAction(RequestPermissionHelperActivity.ACTION_INTERNAL_REQUEST_BT_ON);
|
|
intent.putExtra(RequestPermissionHelperActivity.EXTRA_APP_LABEL, mAppLabel);
|
|
if (mRequest == REQUEST_ENABLE_DISCOVERABLE) {
|
|
intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, mTimeout);
|
|
}
|
|
startActivityForResult(intent, 0);
|
|
} break;
|
|
|
|
case BluetoothAdapter.STATE_ON: {
|
|
if (mRequest == REQUEST_ENABLE) {
|
|
// Nothing to do. Already enabled.
|
|
proceedAndFinish();
|
|
} else {
|
|
// Ask the user about enabling discovery mode
|
|
createDialog();
|
|
}
|
|
} break;
|
|
|
|
default: {
|
|
Log.e(TAG, "Unknown adapter state: " + btState);
|
|
cancelAndFinish();
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void createDialog() {
|
|
if (getResources().getBoolean(R.bool.auto_confirm_bluetooth_activation_dialog)) {
|
|
onClick(null, DialogInterface.BUTTON_POSITIVE);
|
|
return;
|
|
}
|
|
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(this);
|
|
|
|
// Non-null receiver means we are toggling
|
|
if (mReceiver != null) {
|
|
switch (mRequest) {
|
|
case REQUEST_ENABLE:
|
|
case REQUEST_ENABLE_DISCOVERABLE: {
|
|
builder.setMessage(getString(R.string.bluetooth_turning_on));
|
|
} break;
|
|
|
|
default: {
|
|
builder.setMessage(getString(R.string.bluetooth_turning_off));
|
|
} break;
|
|
}
|
|
builder.setCancelable(false);
|
|
} else {
|
|
// Ask the user whether to turn on discovery mode or not
|
|
// For lasting discoverable mode there is a different message
|
|
if (mTimeout == BluetoothDiscoverableEnabler.DISCOVERABLE_TIMEOUT_NEVER) {
|
|
CharSequence message = mAppLabel != null
|
|
? getString(R.string.bluetooth_ask_lasting_discovery, mAppLabel)
|
|
: getString(R.string.bluetooth_ask_lasting_discovery_no_name);
|
|
builder.setMessage(message);
|
|
} else {
|
|
CharSequence message = mAppLabel != null
|
|
? getString(R.string.bluetooth_ask_discovery, mAppLabel, mTimeout)
|
|
: getString(R.string.bluetooth_ask_discovery_no_name, mTimeout);
|
|
builder.setMessage(message);
|
|
}
|
|
builder.setPositiveButton(getString(R.string.allow), this);
|
|
builder.setNegativeButton(getString(R.string.deny), this);
|
|
}
|
|
|
|
mDialog = builder.create();
|
|
mDialog.show();
|
|
}
|
|
|
|
@Override
|
|
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
|
|
if (resultCode != Activity.RESULT_OK) {
|
|
cancelAndFinish();
|
|
return;
|
|
}
|
|
|
|
switch (mRequest) {
|
|
case REQUEST_ENABLE:
|
|
case REQUEST_ENABLE_DISCOVERABLE: {
|
|
if (mLocalAdapter.getBluetoothState() == BluetoothAdapter.STATE_ON) {
|
|
proceedAndFinish();
|
|
} else {
|
|
// If BT is not up yet, show "Turning on Bluetooth..."
|
|
mReceiver = new StateChangeReceiver();
|
|
registerReceiver(mReceiver, new IntentFilter(
|
|
BluetoothAdapter.ACTION_STATE_CHANGED));
|
|
createDialog();
|
|
}
|
|
} break;
|
|
|
|
case REQUEST_DISABLE: {
|
|
if (mLocalAdapter.getBluetoothState() == BluetoothAdapter.STATE_OFF) {
|
|
proceedAndFinish();
|
|
} else {
|
|
// If BT is not up yet, show "Turning off Bluetooth..."
|
|
mReceiver = new StateChangeReceiver();
|
|
registerReceiver(mReceiver, new IntentFilter(
|
|
BluetoothAdapter.ACTION_STATE_CHANGED));
|
|
createDialog();
|
|
}
|
|
} break;
|
|
|
|
default: {
|
|
cancelAndFinish();
|
|
} break;
|
|
}
|
|
}
|
|
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
switch (which) {
|
|
case DialogInterface.BUTTON_POSITIVE:
|
|
proceedAndFinish();
|
|
break;
|
|
|
|
case DialogInterface.BUTTON_NEGATIVE:
|
|
setResult(RESULT_CANCELED);
|
|
finish();
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void proceedAndFinish() {
|
|
int returnCode;
|
|
|
|
if (mRequest == REQUEST_ENABLE || mRequest == REQUEST_DISABLE) {
|
|
// BT toggled. Done
|
|
returnCode = RESULT_OK;
|
|
} else if (mLocalAdapter.setScanMode(
|
|
BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE, mTimeout)) {
|
|
// If already in discoverable mode, this will extend the timeout.
|
|
long endTime = System.currentTimeMillis() + (long) mTimeout * 1000;
|
|
LocalBluetoothPreferences.persistDiscoverableEndTimestamp(
|
|
this, endTime);
|
|
if (0 < mTimeout) {
|
|
BluetoothDiscoverableTimeoutReceiver.setDiscoverableAlarm(this, endTime);
|
|
}
|
|
returnCode = mTimeout;
|
|
// Activity.RESULT_FIRST_USER should be 1
|
|
if (returnCode < RESULT_FIRST_USER) {
|
|
returnCode = RESULT_FIRST_USER;
|
|
}
|
|
} else {
|
|
returnCode = RESULT_CANCELED;
|
|
}
|
|
|
|
if (mDialog != null) {
|
|
mDialog.dismiss();
|
|
}
|
|
|
|
setResult(returnCode);
|
|
finish();
|
|
}
|
|
|
|
private void cancelAndFinish() {
|
|
setResult(Activity.RESULT_CANCELED);
|
|
finish();
|
|
}
|
|
|
|
/**
|
|
* Parse the received Intent and initialize mLocalBluetoothAdapter.
|
|
* @return true if an error occurred; false otherwise
|
|
*/
|
|
private boolean parseIntent() {
|
|
Intent intent = getIntent();
|
|
if (intent == null) {
|
|
return true;
|
|
}
|
|
if (intent.getAction().equals(BluetoothAdapter.ACTION_REQUEST_ENABLE)) {
|
|
mRequest = REQUEST_ENABLE;
|
|
} else if (intent.getAction().equals(BluetoothAdapter.ACTION_REQUEST_DISABLE)) {
|
|
mRequest = REQUEST_DISABLE;
|
|
} else if (intent.getAction().equals(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE)) {
|
|
mRequest = REQUEST_ENABLE_DISCOVERABLE;
|
|
mTimeout = intent.getIntExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,
|
|
BluetoothDiscoverableEnabler.DEFAULT_DISCOVERABLE_TIMEOUT);
|
|
|
|
Log.d(TAG, "Setting Bluetooth Discoverable Timeout = " + mTimeout);
|
|
|
|
if (mTimeout < 1 || mTimeout > MAX_DISCOVERABLE_TIMEOUT) {
|
|
mTimeout = BluetoothDiscoverableEnabler.DEFAULT_DISCOVERABLE_TIMEOUT;
|
|
}
|
|
} else {
|
|
Log.e(TAG, "Error: this activity may be started only with intent "
|
|
+ BluetoothAdapter.ACTION_REQUEST_ENABLE + " or "
|
|
+ BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
|
|
setResult(RESULT_CANCELED);
|
|
return true;
|
|
}
|
|
|
|
LocalBluetoothManager manager = Utils.getLocalBtManager(this);
|
|
if (manager == null) {
|
|
Log.e(TAG, "Error: there's a problem starting Bluetooth");
|
|
setResult(RESULT_CANCELED);
|
|
return true;
|
|
}
|
|
|
|
String packageName = getCallingPackage();
|
|
if (TextUtils.isEmpty(packageName)) {
|
|
packageName = getIntent().getStringExtra(Intent.EXTRA_PACKAGE_NAME);
|
|
}
|
|
if (!TextUtils.isEmpty(packageName)) {
|
|
try {
|
|
ApplicationInfo applicationInfo = getPackageManager().getApplicationInfo(
|
|
packageName, 0);
|
|
mAppLabel = applicationInfo.loadSafeLabel(getPackageManager(),
|
|
PackageItemInfo.DEFAULT_MAX_LABEL_SIZE_PX,
|
|
PackageItemInfo.SAFE_LABEL_FLAG_TRIM
|
|
| PackageItemInfo.SAFE_LABEL_FLAG_FIRST_LINE);
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
Log.e(TAG, "Couldn't find app with package name " + packageName);
|
|
setResult(RESULT_CANCELED);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
mLocalAdapter = manager.getBluetoothAdapter();
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
protected void onDestroy() {
|
|
super.onDestroy();
|
|
if (mReceiver != null) {
|
|
unregisterReceiver(mReceiver);
|
|
mReceiver = null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onBackPressed() {
|
|
setResult(RESULT_CANCELED);
|
|
super.onBackPressed();
|
|
}
|
|
|
|
private final class StateChangeReceiver extends BroadcastReceiver {
|
|
private static final long TOGGLE_TIMEOUT_MILLIS = 10000; // 10 sec
|
|
|
|
public StateChangeReceiver() {
|
|
getWindow().getDecorView().postDelayed(() -> {
|
|
if (!isFinishing() && !isDestroyed()) {
|
|
cancelAndFinish();
|
|
}
|
|
}, TOGGLE_TIMEOUT_MILLIS);
|
|
}
|
|
|
|
public void onReceive(Context context, Intent intent) {
|
|
if (intent == null) {
|
|
return;
|
|
}
|
|
final int currentState = intent.getIntExtra(
|
|
BluetoothAdapter.EXTRA_STATE, BluetoothDevice.ERROR);
|
|
switch (mRequest) {
|
|
case REQUEST_ENABLE:
|
|
case REQUEST_ENABLE_DISCOVERABLE: {
|
|
if (currentState == BluetoothAdapter.STATE_ON) {
|
|
proceedAndFinish();
|
|
}
|
|
} break;
|
|
|
|
case REQUEST_DISABLE: {
|
|
if (currentState == BluetoothAdapter.STATE_OFF) {
|
|
proceedAndFinish();
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
}
|