blob: c38e340d35f0188976e35a1c3201b18a1e1bdf50 [file] [log] [blame]
/*
* Copyright (C) 2019 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.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffColorFilter;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.util.Log;
import android.util.Pair;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.annotation.VisibleForTesting;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.BasePreferenceController;
import com.android.settings.fuelgauge.BatteryMeterView;
import com.android.settingslib.bluetooth.BluetoothUtils;
import com.android.settingslib.bluetooth.CachedBluetoothDevice;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnDestroy;
import com.android.settingslib.core.lifecycle.events.OnStart;
import com.android.settingslib.core.lifecycle.events.OnStop;
import com.android.settingslib.utils.StringUtil;
import com.android.settingslib.utils.ThreadUtils;
import com.android.settingslib.widget.LayoutPreference;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* This class adds a header with device name and status (connected/disconnected, etc.).
*/
public class AdvancedBluetoothDetailsHeaderController extends BasePreferenceController implements
LifecycleObserver, OnStart, OnStop, OnDestroy, CachedBluetoothDevice.Callback {
private static final String TAG = "AdvancedBtHeaderCtrl";
private static final int LOW_BATTERY_LEVEL = 15;
private static final int CASE_LOW_BATTERY_LEVEL = 19;
private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
private static final String PATH = "time_remaining";
private static final String QUERY_PARAMETER_ADDRESS = "address";
private static final String QUERY_PARAMETER_BATTERY_ID = "battery_id";
private static final String QUERY_PARAMETER_BATTERY_LEVEL = "battery_level";
private static final String QUERY_PARAMETER_TIMESTAMP = "timestamp";
private static final String BATTERY_ESTIMATE = "battery_estimate";
private static final String ESTIMATE_READY = "estimate_ready";
private static final String DATABASE_ID = "id";
private static final String DATABASE_BLUETOOTH = "Bluetooth";
private static final long TIME_OF_HOUR = TimeUnit.SECONDS.toMillis(3600);
private static final long TIME_OF_MINUTE = TimeUnit.SECONDS.toMillis(60);
private static final int LEFT_DEVICE_ID = 1;
private static final int RIGHT_DEVICE_ID = 2;
private static final int CASE_DEVICE_ID = 3;
private static final int MAIN_DEVICE_ID = 4;
private static final float HALF_ALPHA = 0.5f;
@VisibleForTesting
LayoutPreference mLayoutPreference;
@VisibleForTesting
final Map<String, Bitmap> mIconCache;
private CachedBluetoothDevice mCachedDevice;
private Set<BluetoothDevice> mBluetoothDevices;
@VisibleForTesting
BluetoothAdapter mBluetoothAdapter;
@VisibleForTesting
Handler mHandler = new Handler(Looper.getMainLooper());
@VisibleForTesting
boolean mIsLeftDeviceEstimateReady;
@VisibleForTesting
boolean mIsRightDeviceEstimateReady;
@VisibleForTesting
final BluetoothAdapter.OnMetadataChangedListener mMetadataListener =
new BluetoothAdapter.OnMetadataChangedListener() {
@Override
public void onMetadataChanged(BluetoothDevice device, int key, byte[] value) {
Log.d(TAG, String.format("Metadata updated in Device %s: %d = %s.",
device.getAnonymizedAddress(),
key, value == null ? null : new String(value)));
refresh();
}
};
public AdvancedBluetoothDetailsHeaderController(Context context, String prefKey) {
super(context, prefKey);
mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
mIconCache = new HashMap<>();
}
@Override
public int getAvailabilityStatus() {
if (mCachedDevice == null) {
return CONDITIONALLY_UNAVAILABLE;
}
return BluetoothUtils.isAdvancedDetailsHeader(mCachedDevice.getDevice())
? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mLayoutPreference = screen.findPreference(getPreferenceKey());
mLayoutPreference.setVisible(isAvailable());
}
@Override
public void onStart() {
if (!isAvailable()) {
return;
}
registerBluetoothDevice();
refresh();
}
@Override
public void onStop() {
unRegisterBluetoothDevice();
}
@Override
public void onDestroy() {
// Destroy icon bitmap associated with this header
for (Bitmap bitmap : mIconCache.values()) {
if (bitmap != null) {
bitmap.recycle();
}
}
mIconCache.clear();
}
public void init(CachedBluetoothDevice cachedBluetoothDevice) {
mCachedDevice = cachedBluetoothDevice;
}
private void registerBluetoothDevice() {
if (mBluetoothAdapter == null) {
Log.d(TAG, "No mBluetoothAdapter");
return;
}
if (mBluetoothDevices == null) {
mBluetoothDevices = new HashSet<>();
}
mBluetoothDevices.clear();
if (mCachedDevice.getDevice() != null) {
mBluetoothDevices.add(mCachedDevice.getDevice());
}
mCachedDevice.getMemberDevice().forEach(cbd -> {
if (cbd != null) {
mBluetoothDevices.add(cbd.getDevice());
}
});
if (mBluetoothDevices.isEmpty()) {
Log.d(TAG, "No BT device to register.");
return;
}
mCachedDevice.registerCallback(this);
Set<BluetoothDevice> errorDevices = new HashSet<>();
mBluetoothDevices.forEach(bd -> {
try {
boolean isSuccess = mBluetoothAdapter.addOnMetadataChangedListener(bd,
mContext.getMainExecutor(), mMetadataListener);
if (!isSuccess) {
Log.e(TAG, bd.getAnonymizedAddress() + ": add into Listener failed");
errorDevices.add(bd);
}
} catch (NullPointerException e) {
errorDevices.add(bd);
Log.e(TAG, bd.getAnonymizedAddress() + ":" + e.toString());
} catch (IllegalArgumentException e) {
errorDevices.add(bd);
Log.e(TAG, bd.getAnonymizedAddress() + ":" + e.toString());
}
});
for (BluetoothDevice errorDevice : errorDevices) {
mBluetoothDevices.remove(errorDevice);
Log.d(TAG, "mBluetoothDevices remove " + errorDevice.getAnonymizedAddress());
}
}
private void unRegisterBluetoothDevice() {
if (mBluetoothAdapter == null) {
Log.d(TAG, "No mBluetoothAdapter");
return;
}
if (mBluetoothDevices == null || mBluetoothDevices.isEmpty()) {
Log.d(TAG, "No BT device to unregister.");
return;
}
mCachedDevice.unregisterCallback(this);
mBluetoothDevices.forEach(bd -> {
try {
mBluetoothAdapter.removeOnMetadataChangedListener(bd, mMetadataListener);
} catch (NullPointerException e) {
Log.e(TAG, bd.getAnonymizedAddress() + ":" + e.toString());
} catch (IllegalArgumentException e) {
Log.e(TAG, bd.getAnonymizedAddress() + ":" + e.toString());
}
});
mBluetoothDevices.clear();
}
@VisibleForTesting
void refresh() {
if (mLayoutPreference != null && mCachedDevice != null) {
final TextView title = mLayoutPreference.findViewById(R.id.entity_header_title);
title.setText(mCachedDevice.getName());
final TextView summary = mLayoutPreference.findViewById(R.id.entity_header_summary);
if (!mCachedDevice.isConnected() || mCachedDevice.isBusy()) {
summary.setText(mCachedDevice.getConnectionSummary(true /* shortSummary */));
updateDisconnectLayout();
return;
}
final BluetoothDevice device = mCachedDevice.getDevice();
final String deviceType = BluetoothUtils.getStringMetaData(device,
BluetoothDevice.METADATA_DEVICE_TYPE);
if (TextUtils.equals(deviceType,
BluetoothDevice.DEVICE_TYPE_UNTETHERED_HEADSET)
|| BluetoothUtils.getBooleanMetaData(device,
BluetoothDevice.METADATA_IS_UNTETHERED_HEADSET)) {
summary.setText(mCachedDevice.getConnectionSummary(true /* shortSummary */));
updateSubLayout(mLayoutPreference.findViewById(R.id.layout_left),
BluetoothDevice.METADATA_UNTETHERED_LEFT_ICON,
BluetoothDevice.METADATA_UNTETHERED_LEFT_BATTERY,
BluetoothDevice.METADATA_UNTETHERED_LEFT_LOW_BATTERY_THRESHOLD,
BluetoothDevice.METADATA_UNTETHERED_LEFT_CHARGING,
R.string.bluetooth_left_name,
LEFT_DEVICE_ID);
updateSubLayout(mLayoutPreference.findViewById(R.id.layout_middle),
BluetoothDevice.METADATA_UNTETHERED_CASE_ICON,
BluetoothDevice.METADATA_UNTETHERED_CASE_BATTERY,
BluetoothDevice.METADATA_UNTETHERED_CASE_LOW_BATTERY_THRESHOLD,
BluetoothDevice.METADATA_UNTETHERED_CASE_CHARGING,
R.string.bluetooth_middle_name,
CASE_DEVICE_ID);
updateSubLayout(mLayoutPreference.findViewById(R.id.layout_right),
BluetoothDevice.METADATA_UNTETHERED_RIGHT_ICON,
BluetoothDevice.METADATA_UNTETHERED_RIGHT_BATTERY,
BluetoothDevice.METADATA_UNTETHERED_RIGHT_LOW_BATTERY_THRESHOLD,
BluetoothDevice.METADATA_UNTETHERED_RIGHT_CHARGING,
R.string.bluetooth_right_name,
RIGHT_DEVICE_ID);
showBothDevicesBatteryPredictionIfNecessary();
} else {
mLayoutPreference.findViewById(R.id.layout_left).setVisibility(View.GONE);
mLayoutPreference.findViewById(R.id.layout_right).setVisibility(View.GONE);
summary.setText(mCachedDevice.getConnectionSummary(
BluetoothUtils.getIntMetaData(device, BluetoothDevice.METADATA_MAIN_BATTERY)
!= BluetoothUtils.META_INT_ERROR));
updateSubLayout(mLayoutPreference.findViewById(R.id.layout_middle),
BluetoothDevice.METADATA_MAIN_ICON,
BluetoothDevice.METADATA_MAIN_BATTERY,
BluetoothDevice.METADATA_MAIN_LOW_BATTERY_THRESHOLD,
BluetoothDevice.METADATA_MAIN_CHARGING,
/* titleResId */ 0,
MAIN_DEVICE_ID);
}
}
}
@VisibleForTesting
Drawable createBtBatteryIcon(Context context, int level, boolean charging) {
final BatteryMeterView.BatteryMeterDrawable drawable =
new BatteryMeterView.BatteryMeterDrawable(context,
context.getColor(com.android.settingslib.R.color.meter_background_color),
context.getResources().getDimensionPixelSize(
R.dimen.advanced_bluetooth_battery_meter_width),
context.getResources().getDimensionPixelSize(
R.dimen.advanced_bluetooth_battery_meter_height));
drawable.setBatteryLevel(level);
drawable.setColorFilter(new PorterDuffColorFilter(
com.android.settings.Utils.getColorAttrDefaultColor(context,
android.R.attr.colorControlNormal),
PorterDuff.Mode.SRC));
drawable.setCharging(charging);
return drawable;
}
private void updateSubLayout(LinearLayout linearLayout, int iconMetaKey, int batteryMetaKey,
int lowBatteryMetaKey, int chargeMetaKey, int titleResId, int deviceId) {
if (linearLayout == null) {
return;
}
final BluetoothDevice bluetoothDevice = mCachedDevice.getDevice();
final String iconUri = BluetoothUtils.getStringMetaData(bluetoothDevice, iconMetaKey);
final ImageView imageView = linearLayout.findViewById(R.id.header_icon);
if (iconUri != null) {
updateIcon(imageView, iconUri);
} else {
final Pair<Drawable, String> pair =
BluetoothUtils.getBtRainbowDrawableWithDescription(mContext, mCachedDevice);
imageView.setImageDrawable(pair.first);
imageView.setContentDescription(pair.second);
}
final int batteryLevel = BluetoothUtils.getIntMetaData(bluetoothDevice, batteryMetaKey);
final boolean charging = BluetoothUtils.getBooleanMetaData(bluetoothDevice, chargeMetaKey);
int lowBatteryLevel = BluetoothUtils.getIntMetaData(bluetoothDevice,
lowBatteryMetaKey);
if (lowBatteryLevel == BluetoothUtils.META_INT_ERROR) {
if (batteryMetaKey == BluetoothDevice.METADATA_UNTETHERED_CASE_BATTERY) {
lowBatteryLevel = CASE_LOW_BATTERY_LEVEL;
} else {
lowBatteryLevel = LOW_BATTERY_LEVEL;
}
}
Log.d(TAG, "buletoothDevice: " + bluetoothDevice.getAnonymizedAddress()
+ ", updateSubLayout() icon : " + iconMetaKey + ", battery : " + batteryMetaKey
+ ", charge : " + chargeMetaKey + ", batteryLevel : " + batteryLevel
+ ", charging : " + charging + ", iconUri : " + iconUri
+ ", lowBatteryLevel : " + lowBatteryLevel);
if (deviceId == LEFT_DEVICE_ID || deviceId == RIGHT_DEVICE_ID) {
showBatteryPredictionIfNecessary(linearLayout, deviceId, batteryLevel);
}
final TextView batterySummaryView = linearLayout.findViewById(R.id.bt_battery_summary);
if (isUntetheredHeadset(bluetoothDevice)) {
if (batteryLevel != BluetoothUtils.META_INT_ERROR) {
linearLayout.setVisibility(View.VISIBLE);
batterySummaryView.setText(
com.android.settings.Utils.formatPercentage(batteryLevel));
batterySummaryView.setVisibility(View.VISIBLE);
showBatteryIcon(linearLayout, batteryLevel, lowBatteryLevel, charging);
} else {
if (deviceId == MAIN_DEVICE_ID) {
linearLayout.setVisibility(View.VISIBLE);
linearLayout.findViewById(R.id.bt_battery_icon).setVisibility(View.GONE);
int level = bluetoothDevice.getBatteryLevel();
if (level != BluetoothDevice.BATTERY_LEVEL_UNKNOWN
&& level != BluetoothDevice.BATTERY_LEVEL_BLUETOOTH_OFF) {
batterySummaryView.setText(
com.android.settings.Utils.formatPercentage(level));
batterySummaryView.setVisibility(View.VISIBLE);
} else {
batterySummaryView.setVisibility(View.GONE);
}
} else {
// Hide it if it doesn't have battery information
linearLayout.setVisibility(View.GONE);
}
}
} else {
if (batteryLevel != BluetoothUtils.META_INT_ERROR) {
linearLayout.setVisibility(View.VISIBLE);
batterySummaryView.setText(
com.android.settings.Utils.formatPercentage(batteryLevel));
batterySummaryView.setVisibility(View.VISIBLE);
showBatteryIcon(linearLayout, batteryLevel, lowBatteryLevel, charging);
} else {
batterySummaryView.setVisibility(View.GONE);
}
}
final TextView textView = linearLayout.findViewById(R.id.header_title);
if (deviceId == MAIN_DEVICE_ID) {
textView.setVisibility(View.GONE);
} else {
textView.setText(titleResId);
textView.setVisibility(View.VISIBLE);
}
}
private boolean isUntetheredHeadset(BluetoothDevice bluetoothDevice) {
return BluetoothUtils.getBooleanMetaData(bluetoothDevice,
BluetoothDevice.METADATA_IS_UNTETHERED_HEADSET)
|| TextUtils.equals(BluetoothUtils.getStringMetaData(bluetoothDevice,
BluetoothDevice.METADATA_DEVICE_TYPE),
BluetoothDevice.DEVICE_TYPE_UNTETHERED_HEADSET);
}
private void showBatteryPredictionIfNecessary(LinearLayout linearLayout, int batteryId,
int batteryLevel) {
ThreadUtils.postOnBackgroundThread(() -> {
final Uri contentUri = new Uri.Builder()
.scheme(ContentResolver.SCHEME_CONTENT)
.authority(mContext.getString(R.string.config_battery_prediction_authority))
.appendPath(PATH)
.appendPath(DATABASE_ID)
.appendPath(DATABASE_BLUETOOTH)
.appendQueryParameter(QUERY_PARAMETER_ADDRESS, mCachedDevice.getAddress())
.appendQueryParameter(QUERY_PARAMETER_BATTERY_ID, String.valueOf(batteryId))
.appendQueryParameter(QUERY_PARAMETER_BATTERY_LEVEL,
String.valueOf(batteryLevel))
.appendQueryParameter(QUERY_PARAMETER_TIMESTAMP,
String.valueOf(System.currentTimeMillis()))
.build();
final String[] columns = new String[] {BATTERY_ESTIMATE, ESTIMATE_READY};
final Cursor cursor =
mContext.getContentResolver().query(contentUri, columns, null, null, null);
if (cursor == null) {
Log.w(TAG, "showBatteryPredictionIfNecessary() cursor is null!");
return;
}
try {
for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
final int estimateReady =
cursor.getInt(cursor.getColumnIndex(ESTIMATE_READY));
final long batteryEstimate =
cursor.getLong(cursor.getColumnIndex(BATTERY_ESTIMATE));
if (DEBUG) {
Log.d(TAG, "showBatteryTimeIfNecessary() batteryId : " + batteryId
+ ", ESTIMATE_READY : " + estimateReady
+ ", BATTERY_ESTIMATE : " + batteryEstimate);
}
showBatteryPredictionIfNecessary(estimateReady, batteryEstimate, linearLayout);
if (batteryId == LEFT_DEVICE_ID) {
mIsLeftDeviceEstimateReady = estimateReady == 1;
} else if (batteryId == RIGHT_DEVICE_ID) {
mIsRightDeviceEstimateReady = estimateReady == 1;
}
}
} finally {
cursor.close();
}
});
}
@VisibleForTesting
void showBatteryPredictionIfNecessary(int estimateReady, long batteryEstimate,
LinearLayout linearLayout) {
ThreadUtils.postOnMainThread(() -> {
final TextView textView = linearLayout.findViewById(R.id.bt_battery_prediction);
if (estimateReady == 1) {
textView.setText(
StringUtil.formatElapsedTime(
mContext,
batteryEstimate,
/* withSeconds */ false,
/* collapseTimeUnit */ false));
} else {
textView.setVisibility(View.GONE);
}
});
}
@VisibleForTesting
void showBothDevicesBatteryPredictionIfNecessary() {
TextView leftDeviceTextView =
mLayoutPreference.findViewById(R.id.layout_left)
.findViewById(R.id.bt_battery_prediction);
TextView rightDeviceTextView =
mLayoutPreference.findViewById(R.id.layout_right)
.findViewById(R.id.bt_battery_prediction);
boolean isBothDevicesEstimateReady =
mIsLeftDeviceEstimateReady && mIsRightDeviceEstimateReady;
int visibility = isBothDevicesEstimateReady ? View.VISIBLE : View.GONE;
ThreadUtils.postOnMainThread(() -> {
leftDeviceTextView.setVisibility(visibility);
rightDeviceTextView.setVisibility(visibility);
});
}
private void showBatteryIcon(LinearLayout linearLayout, int level, int lowBatteryLevel,
boolean charging) {
final boolean enableLowBattery = level <= lowBatteryLevel && !charging;
final ImageView imageView = linearLayout.findViewById(R.id.bt_battery_icon);
if (enableLowBattery) {
imageView.setImageDrawable(mContext.getDrawable(R.drawable.ic_battery_alert_24dp));
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(
mContext.getResources().getDimensionPixelSize(
R.dimen.advanced_bluetooth_battery_width),
mContext.getResources().getDimensionPixelSize(
R.dimen.advanced_bluetooth_battery_height));
layoutParams.rightMargin = mContext.getResources().getDimensionPixelSize(
R.dimen.advanced_bluetooth_battery_right_margin);
imageView.setLayoutParams(layoutParams);
} else {
imageView.setImageDrawable(createBtBatteryIcon(mContext, level, charging));
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(
ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
imageView.setLayoutParams(layoutParams);
}
imageView.setVisibility(View.VISIBLE);
}
private void updateDisconnectLayout() {
mLayoutPreference.findViewById(R.id.layout_left).setVisibility(View.GONE);
mLayoutPreference.findViewById(R.id.layout_right).setVisibility(View.GONE);
// Hide title, battery icon and battery summary
final LinearLayout linearLayout = mLayoutPreference.findViewById(R.id.layout_middle);
linearLayout.setVisibility(View.VISIBLE);
linearLayout.findViewById(R.id.header_title).setVisibility(View.GONE);
linearLayout.findViewById(R.id.bt_battery_summary).setVisibility(View.GONE);
linearLayout.findViewById(R.id.bt_battery_icon).setVisibility(View.GONE);
// Only show bluetooth icon
final BluetoothDevice bluetoothDevice = mCachedDevice.getDevice();
final String iconUri = BluetoothUtils.getStringMetaData(bluetoothDevice,
BluetoothDevice.METADATA_MAIN_ICON);
if (DEBUG) {
Log.d(TAG, "updateDisconnectLayout() iconUri : " + iconUri);
}
if (iconUri != null) {
final ImageView imageView = linearLayout.findViewById(R.id.header_icon);
updateIcon(imageView, iconUri);
}
}
/**
* Update icon by {@code iconUri}. If icon exists in cache, use it; otherwise extract it
* from uri in background thread and update it in main thread.
*/
@VisibleForTesting
void updateIcon(ImageView imageView, String iconUri) {
if (mIconCache.containsKey(iconUri)) {
imageView.setAlpha(1f);
imageView.setImageBitmap(mIconCache.get(iconUri));
return;
}
imageView.setAlpha(HALF_ALPHA);
ThreadUtils.postOnBackgroundThread(() -> {
final Uri uri = Uri.parse(iconUri);
try {
mContext.getContentResolver().takePersistableUriPermission(uri,
Intent.FLAG_GRANT_READ_URI_PERMISSION);
final Bitmap bitmap = MediaStore.Images.Media.getBitmap(
mContext.getContentResolver(), uri);
ThreadUtils.postOnMainThread(() -> {
mIconCache.put(iconUri, bitmap);
imageView.setAlpha(1f);
imageView.setImageBitmap(bitmap);
});
} catch (IOException e) {
Log.e(TAG, "Failed to get bitmap for: " + iconUri, e);
} catch (SecurityException e) {
Log.e(TAG, "Failed to take persistable permission for: " + uri, e);
}
});
}
@Override
public void onDeviceAttributesChanged() {
if (mCachedDevice != null) {
refresh();
}
}
}