path: root/libraries/BluetoothServices/src/com/google/android/tv/btservices/settings/ConnectedDevicesSliceProvider.java

/*
 * Copyright (C) 2021 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.google.android.tv.btservices.settings;

import static com.android.tv.twopanelsettings.slices.SlicesConstants.EXTRA_SLICE_FOLLOWUP;

import static com.google.android.tv.btservices.settings.BluetoothDevicePreferenceFragment.CONT_CANCEL_ARGS;
import static com.google.android.tv.btservices.settings.BluetoothDevicePreferenceFragment.KEY_CONNECT;
import static com.google.android.tv.btservices.settings.BluetoothDevicePreferenceFragment.KEY_DISCONNECT;
import static com.google.android.tv.btservices.settings.BluetoothDevicePreferenceFragment.KEY_FORGET;
import static com.google.android.tv.btservices.settings.BluetoothDevicePreferenceFragment.KEY_RENAME;
import static com.google.android.tv.btservices.settings.BluetoothDevicePreferenceFragment.KEY_UPDATE;
import static com.google.android.tv.btservices.settings.BluetoothDevicePreferenceFragment.YES_NO_ARGS;
import static com.google.android.tv.btservices.settings.ConnectedDevicesPreferenceFragment.KEY_ACCESSORIES;
import static com.google.android.tv.btservices.settings.ConnectedDevicesPreferenceFragment.KEY_AXEL_TOGGLE;
import static com.google.android.tv.btservices.settings.ConnectedDevicesPreferenceFragment.KEY_CEC_TOGGLE;
import static com.google.android.tv.btservices.settings.ConnectedDevicesPreferenceFragment.KEY_DEVICE_CONTROL;
import static com.google.android.tv.btservices.settings.ConnectedDevicesPreferenceFragment.KEY_OFFICIAL_REMOTES;
import static com.google.android.tv.btservices.settings.ConnectedDevicesPreferenceFragment.KEY_PAIR_REMOTE;
import static com.google.android.tv.btservices.settings.SliceBroadcastReceiver.CEC;
import static com.google.android.tv.btservices.settings.SliceBroadcastReceiver.TOGGLE_STATE;
import static com.google.android.tv.btservices.settings.SliceBroadcastReceiver.TOGGLE_TYPE;
import static com.google.android.tv.btservices.settings.SliceBroadcastReceiver.backAndUpdateSliceIntent;
import static com.google.android.tv.btservices.settings.SliceBroadcastReceiver.updateSliceIntent;
import static com.google.android.tv.btservices.settings.SlicesUtil.GENERAL_SLICE_URI;

import android.app.PendingIntent;
import android.app.admin.DevicePolicyManager;
import android.bluetooth.BluetoothDevice;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Settings;
import android.util.ArrayMap;
import android.util.Log;

import androidx.core.graphics.drawable.IconCompat;
import androidx.slice.Slice;
import androidx.slice.SliceProvider;

import com.android.settingslib.RestrictedLockUtils;
import com.android.settingslib.RestrictedLockUtilsInternal;
import com.android.settingslib.bluetooth.CachedBluetoothDevice;
import com.android.tv.twopanelsettings.slices.builders.PreferenceSliceBuilder;
import com.android.tv.twopanelsettings.slices.builders.PreferenceSliceBuilder.RowBuilder;

import com.google.android.tv.btservices.BluetoothDeviceService;
import com.google.android.tv.btservices.BluetoothUtils;
import com.google.android.tv.btservices.Configuration;
import com.google.android.tv.btservices.PowerUtils;
import com.google.android.tv.btservices.R;
import com.google.android.tv.btservices.SettingsUtils;
import com.google.android.tv.btservices.remote.Version;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Use slice to provide TvSettings "connected devices" information.
 */
public class ConnectedDevicesSliceProvider extends SliceProvider implements
        BluetoothDeviceProvider.Listener, ConnectedDevicesPreferenceFragment.Provider {
    public static final String ACTION_TOGGLE_CHANGED =
            "com.google.android.settings.usage.TOGGLE_CHANGED";
    private static final String TAG = "Atv.ConDevsSliceProvider";
    private static final boolean DEBUG = false;
    private boolean mBtDeviceServiceBound;
    private final Map<String, Version> mVersionsMap = new ConcurrentHashMap<>();
    private BluetoothDeviceService.LocalBinder mBtDeviceServiceBinder;
    private final Map<Uri, Integer> pinnedUris = new ArrayMap<>();

    static final String KEY_EXTRAS_DEVICE = "key_extras_device";
    private static final String SCHEME_CONTENT = "content://";
    private final Handler mHandler = new Handler(Looper.getMainLooper());

    private final ServiceConnection mBtDeviceServiceConnection =
            new com.google.android.tv.btservices.SimplifiedConnection() {
                @Override
                protected void cleanUp() {
                    if (mBtDeviceServiceBinder != null) {
                        mBtDeviceServiceBinder.removeListener(ConnectedDevicesSliceProvider.this);
                    }
                    mBtDeviceServiceBinder = null;
                }

                @Override
                public void onServiceConnected(ComponentName className, IBinder service) {
                    mBtDeviceServiceBinder = (BluetoothDeviceService.LocalBinder) service;
                    mBtDeviceServiceBinder.addListener(ConnectedDevicesSliceProvider.this);
                    getContext().getContentResolver().notifyChange(SlicesUtil.GENERAL_SLICE_URI,
                            null);
                }
            };

    // BluetoothDeviceProvider.Listener implementation
    @Override
    public void onDeviceUpdated(BluetoothDevice device) {
        getContext().getContentResolver().notifyChange(SlicesUtil.GENERAL_SLICE_URI, null);
        getContext().getContentResolver().notifyChange(
                SlicesUtil.getDeviceUri(device.getAddress()), null);
        updateVersionAndNotify(device);
    }

    private void updateVersionAndNotify(BluetoothDevice device) {
        String addr = device.getAddress();
        mHandler.post(() -> {
            mVersionsMap.put(addr, getLocalBluetoothDeviceProvider().getVersion(device));
            if (device != null) {
                getContext().getContentResolver().notifyChange(
                        SlicesUtil.getDeviceUri(addr), null);
            }
        });
    }

    @Override
    public boolean isCecEnabled() {
        return PowerUtils.isCecControlEnabled(getContext());
    }

    public List<BluetoothDevice> getBluetoothDevices() {
        if (mBtDeviceServiceBinder != null) {
            return mBtDeviceServiceBinder.getDevices();
        }
        return new ArrayList<>();
    }

    @Override
    public BluetoothDeviceProvider getBluetoothDeviceProvider() {
        return mBtDeviceServiceBinder;
    }

    public BluetoothDeviceProvider getLocalBluetoothDeviceProvider() {
        return mLocalBluetoothDeviceProvider;
    }

    @Override
    public void onSlicePinned(Uri sliceUri) {
        mHandler.post(() -> {
            if (DEBUG) {
                Log.d(TAG, "Slice pinned: " + sliceUri);
            }
            Context context = getContext();
            if (!mBtDeviceServiceBound && context.bindService(
                    new Intent(context, BluetoothUtils.getBluetoothDeviceServiceClass(context)),
                    mBtDeviceServiceConnection, Context.BIND_AUTO_CREATE)) {
                mBtDeviceServiceBound = true;
            }
            if (!pinnedUris.containsKey(sliceUri)) {
                pinnedUris.put(sliceUri, 0);
            }
            pinnedUris.put(sliceUri, pinnedUris.get(sliceUri) + 1);
        });
    }

    @Override
    public void onSliceUnpinned(Uri sliceUri) {
        mHandler.post(() -> {
            if (DEBUG) {
                Log.d(TAG, "Slice unpinned: " + sliceUri);
            }
            Context context = getContext();
            // If at this point there is only one slice pinned, we need to unbind the service as
            // there won't be any slice pinned after handleSliceUnpinned is called.
            if (pinnedUris.containsKey(sliceUri)) {
                int newCount = pinnedUris.get(sliceUri) - 1;
                pinnedUris.put(sliceUri, newCount);
                if (newCount == 0) {
                    pinnedUris.remove(sliceUri);
                }
            }
            if (pinnedUris.isEmpty() && mBtDeviceServiceBound) {
                context.unbindService(mBtDeviceServiceConnection);
                mBtDeviceServiceBound = false;
            }
        });
    }

    @Override
    public boolean onCreateSliceProvider() {
        return true;
    }

    private String getString(int id) {
        return getContext().getString(id);
    }

    @Override
    public Slice onBindSlice(Uri sliceUri) {
        if (DEBUG) {
            Log.d(TAG, "onBindSlice: " + sliceUri);
        }
        if (SlicesUtil.isGeneralPath(sliceUri)) {
            return createGeneralSlice(sliceUri);
        } else if (SlicesUtil.isBluetoothDevicePath(sliceUri)) {
            return createBluetoothDeviceSlice(sliceUri);
        } else if (SlicesUtil.isCecPath(sliceUri)) {
            return createCecSlice(sliceUri);
        }
        return null;
    }

    @Override
    public PendingIntent onCreatePermissionRequest(Uri sliceUri, String callingPackage) {
        final Intent settingsIntent = new Intent(Settings.ACTION_SETTINGS);
        final PendingIntent noOpIntent = PendingIntent.getActivity(getContext(), 0,
                settingsIntent, PendingIntent.FLAG_IMMUTABLE);
        return noOpIntent;
    }

    // The initial slice in the Connected Device flow.
    private Slice createGeneralSlice(Uri sliceUri) {
        PreferenceSliceBuilder psb = new PreferenceSliceBuilder(getContext(), sliceUri);
        psb.addScreenTitle(
                new RowBuilder()
                        .setTitle(getString(R.string.connected_devices_slice_pref_title))
                        .setPageId(0x18000000)); // TvSettingsEnums.CONNECTED_SLICE

        RestrictedLockUtils.EnforcedAdmin admin =
                RestrictedLockUtilsInternal.checkIfRestrictionEnforced(getContext(),
                        UserManager.DISALLOW_CONFIG_BLUETOOTH, UserHandle.myUserId());
        PendingIntent pendingIntent;
        List<String> updatedUris = Arrays.asList(GENERAL_SLICE_URI.toString());
        PendingIntent updateGeneralSliceIntent = updateSliceIntent(getContext(), 0,
                new ArrayList<>(updatedUris), GENERAL_SLICE_URI.toString());
        if (admin == null) {
            Intent i = SettingsUtils.getPairingIntent();
            i.putExtra(EXTRA_SLICE_FOLLOWUP, updateGeneralSliceIntent);
            pendingIntent = PendingIntent.getActivity(getContext(), 0, i,
                    PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
        } else {
            Intent intent = RestrictedLockUtils.getShowAdminSupportDetailsIntent(getContext(),
                    admin);
            intent.putExtra(DevicePolicyManager.EXTRA_RESTRICTION,
                    UserManager.DISALLOW_CONFIG_BLUETOOTH)
                    .putExtra(EXTRA_SLICE_FOLLOWUP, updateGeneralSliceIntent);
            pendingIntent = PendingIntent.getActivity(getContext(), 0, intent,
                    PendingIntent.FLAG_IMMUTABLE);
        }
        psb.addPreference(new RowBuilder()
                .setKey(KEY_PAIR_REMOTE)
                .setTitle(getString(R.string.settings_pair_remote))
                .setActionId(0x18100000) // TvSettingsEnums.CONNECTED_SLICE_CONNECT_NEW_DEVICES
                .setIcon(IconCompat.createWithResource(getContext(),
                        R.drawable.ic_baseline_add_24dp))
                .setIconNeedsToBeProcessed(true)
                .setPendingIntent(pendingIntent)
        );

        // Visually, the connected devices concept covers two categories:
        // 1. Any connected devices except the official remote controls. Actively connected devices
        //    are ranked higher.
        // 2. Official remote controls (if present) and their button settings.
        updateConnectedDevices(psb);
        updateDeviceControl(psb);
        return psb.build();
    }

    private void updateConnectedDevices(PreferenceSliceBuilder psb) {
        // Overall BT devices maps
        HashMap<String, BluetoothDevice> addressToDevice = new HashMap<>();
        // Sets for BT devices that are not official remotes:
        // - activeAccessories: they are considered connected from both BluetoothDevice and
        //       CachedBluetoothDevice's perceptive.
        // - inactiveAccessories: they are considered connected from BluetoothDevice's perceptive
        //       but disconnected from CachedBluetoothDevice's perceptive. They can be easily
        //       reconnected.
        // - bondedAccessories: they are considered merely bonded but not connected from
        //       BluetoothDevice's perceptive.
        Set<String> activeAccessories = new HashSet<>();
        Set<String> inactiveAccessories = new HashSet<>();
        Set<String> bondedAccessories = new HashSet<>();
        // Sets for official BT remotes
        // - activeOfficialRemotes: they are considered connected from both BluetoothDevice and
        //       CachedBluetoothDevice's perceptive.
        // - inactiveOfficialRemotes: they are official remotes in states corresponding to the union
        //       of inactiveAccessories and bondedAccessories.
        Set<String> activeOfficialRemotes = new HashSet<>();
        Set<String> inactiveOfficialRemotes = new HashSet<>();

        // Bucketing all BT devices
        for (BluetoothDevice device : getBluetoothDevices()) {
            CachedBluetoothDevice cachedDevice =
                    BluetoothUtils.getCachedBluetoothDevice(getContext(), device);
            if (BluetoothUtils.isConnected(device)) {
                addressToDevice.put(device.getAddress(), device);
                if (cachedDevice != null && cachedDevice.isConnected()) {
                    if (BluetoothUtils.isOfficialRemote(getContext(), device)) {
                        activeOfficialRemotes.add(device.getAddress());
                    } else {
                        activeAccessories.add(device.getAddress());
                    }
                } else {
                    if (BluetoothUtils.isOfficialRemote(getContext(), device)) {
                        inactiveOfficialRemotes.add(device.getAddress());
                    } else {
                        inactiveAccessories.add(device.getAddress());
                    }
                }
            } else if (BluetoothUtils.isBonded(device)) {
                addressToDevice.put(device.getAddress(), device);
                if (BluetoothUtils.isOfficialRemote(getContext(), device)) {
                    inactiveOfficialRemotes.add(device.getAddress());
                } else {
                    bondedAccessories.add(device.getAddress());
                }
            }
        }

        // "Accessories" category
        if (activeAccessories.size() + inactiveAccessories.size() + bondedAccessories.size()
                > 0) {
            psb.addPreferenceCategory(new RowBuilder()
                    .setTitle(getContext().getString(R.string.settings_known_devices_category))
                    .setKey(KEY_ACCESSORIES));
            // Add accessories following the ranking of: active, inactive, bonded.
            createAndAddBtDeviceSlicePreferenceFromSet(psb, activeAccessories, addressToDevice);
            createAndAddBtDeviceSlicePreferenceFromSet(psb, inactiveAccessories, addressToDevice);
            createAndAddBtDeviceSlicePreferenceFromSet(psb, bondedAccessories, addressToDevice);
        }

        // "Official remote" category
        if (activeOfficialRemotes.size() + inactiveOfficialRemotes.size() > 0) {
            psb.addPreferenceCategory(new RowBuilder()
                    .setTitle(getContext().getString(R.string.settings_official_remote_category))
                    .setKey(KEY_OFFICIAL_REMOTES));
            createAndAddBtDeviceSlicePreferenceFromSet(psb, activeOfficialRemotes, addressToDevice);
            createAndAddBtDeviceSlicePreferenceFromSet(
                    psb, inactiveOfficialRemotes, addressToDevice);
        }

        // Adding the remote buttons settings at the bottom
        updateAxel(psb);
    }

    private void updateDeviceControl(PreferenceSliceBuilder psb) {
        // Currently, HDMI-CEC settings is the only entry within the device control category so we
        // should hide the whole category including the header if HDMI-CEC settings is not visible.
        if (!ConnectedDevicesPreferenceFragment.isCecSettingsEnabled(getContext())
                || !showCecInConnectedSettings()) {
            return;
        }
        RowBuilder category = new RowBuilder().setKey(KEY_DEVICE_CONTROL)
                .setTitle(getString(R.string.settings_devices_control));
        psb.addPreferenceCategory(category);
        updateCecSettings(psb);
    }

    private void updateAxel(PreferenceSliceBuilder psb) {
        if (!ConnectedDevicesPreferenceFragment.isAxelSettingsEnabled(getContext())) {
            return;
        }
        RowBuilder axelPref = new RowBuilder()
                .setKey(KEY_AXEL_TOGGLE)
                .setTitle(getString(R.string.settings_axel))
                .setSubtitle(getString(R.string.settings_axel_description))
                .setTargetSliceUri(SlicesUtil.AXEL_SLICE_URI.toString());
        psb.addPreference(axelPref);
    }

    private void updateCecSettings(PreferenceSliceBuilder psb) {
        if (!ConnectedDevicesPreferenceFragment.isCecSettingsEnabled(getContext())
                || !showCecInConnectedSettings()) {
            return;
        }
        RowBuilder cecPref = new RowBuilder()
                .setKey(KEY_CEC_TOGGLE)
                .setTitle(getString(R.string.settings_hdmi_cec))
                .setSubtitle(isCecEnabled() ? getString(R.string.settings_enabled)
                        : getString(R.string.settings_disabled))
                .setTargetSliceUri(SlicesUtil.CEC_SLICE_URI.toString());
        psb.addPreference(cecPref);
    }

    // The slice page that shows detail information of a particular device.
    private Slice createBluetoothDeviceSlice(Uri sliceUri) {
        Context context = getContext();
        String deviceAddr = SlicesUtil.getDeviceAddr(sliceUri);
        BluetoothDevice device = BluetoothDeviceService
                .findDevice(SlicesUtil.getDeviceAddr(sliceUri));
        CachedBluetoothDevice cachedDevice =
                BluetoothUtils.getCachedBluetoothDevice(getContext(), device);
        String deviceName = "";
        if (device != null) {
            deviceName = BluetoothUtils.getName(device);
        }

        PreferenceSliceBuilder psb = new PreferenceSliceBuilder(getContext(), sliceUri);
        psb.addScreenTitle(
                new RowBuilder()
                        .setTitle(deviceName)
                        .setPageId(0x18200000)); // TvSettingsEnums.CONNECTED_SLICE_DEVICE_ENTRY

        Bundle extras = new Bundle();
        Intent i = null;
        // Update "update preference".
        if (BluetoothUtils.isRemote(context, device)) {
            i = new Intent(context, ResponseActivity.class);
            RowBuilder updatePref = new RowBuilder().setKey(KEY_UPDATE);
            ResponseFragment.prepareArgs(
                    extras,
                    KEY_UPDATE,
                    R.string.settings_bt_update,
                    R.string.settings_bt_update_summary,
                    0,
                    CONT_CANCEL_ARGS,
                    null,
                    ResponseFragment.DEFAULT_CHOICE_UNDEFINED
            );
            i.putExtras(extras).putExtra(KEY_EXTRAS_DEVICE, device)
                    .setData(Uri.parse(SCHEME_CONTENT + device.getAddress()));
            List<String> updatedUris = Arrays.asList(GENERAL_SLICE_URI.toString(),
                    sliceUri.toString());
            PendingIntent updateSliceIntent = updateSliceIntent(getContext(), 0,
                    new ArrayList<>(updatedUris), sliceUri.toString());
            i.putExtra(EXTRA_SLICE_FOLLOWUP, updateSliceIntent);
            PendingIntent updatePendingIntent =
                    PendingIntent.getActivity(context, 0, i,
                            PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
            updatePref.setPendingIntent(updatePendingIntent);

            BluetoothDeviceProvider btDeviceProvider = getLocalBluetoothDeviceProvider();

            if (btDeviceProvider.hasUpgrade(device)) {
                updatePref.setTitle(getString(R.string.settings_bt_update));
                updatePref.setEnabled(true);
                updatePref.setSelectable(true);
                // TvSettingsEnums.CONNECTED_SLICE_DEVICE_ENTRY_UPDATE
                updatePref.setActionId(0x18210000);
                if (btDeviceProvider.isBatteryLow(device)) {
                    updatePref.setSubtitle(getString(R.string.settings_bt_battery_low));
                    updatePref.setEnabled(false);
                    updatePref.setSelectable(false);
                } else {
                    updatePref.setSubtitle(
                            getString(R.string.settings_bt_update_software_available));
                }
            } else {
                updatePref.setTitle(getString(R.string.settings_bt_update_not_necessary));
                updatePref.setSubtitle(null);
                updatePref.setEnabled(false);
                updatePref.setSelectable(false);
            }
            psb.addPreference(updatePref);
        }

        // Update "connect/disconnect preference"
        if (showConnectDisconnectButtons(device) && cachedDevice != null
                && !cachedDevice.isBusy()) {
            // Whether the device is actually connected from CachedBluetoothDevice's perceptive.
            boolean isConnected = BluetoothUtils.isConnected(device) && cachedDevice.isConnected();
            RowBuilder disconnectPref = new RowBuilder()
                    .setKey(isConnected ? KEY_DISCONNECT : KEY_CONNECT)
                    .setTitle(getString(isConnected
                            ? R.string.bluetooth_disconnect : R.string.bluetooth_connect));
            extras = new Bundle();
            i = new Intent(context, ResponseActivity.class);
            ResponseFragment.prepareArgs(
                    extras,
                    isConnected ? KEY_DISCONNECT : KEY_CONNECT,
                    isConnected ? R.string.settings_bt_disconnect : R.string.settings_bt_connect,
                    0,
                    R.drawable.ic_baseline_bluetooth_searching_large,
                    YES_NO_ARGS,
                    deviceName,
                    isConnected ? 1 /* default to NO (index 1) */ : 0 /* default to YES */
            );
            i.putExtras(extras)
                    .putExtra(KEY_EXTRAS_DEVICE, device)
                    .setData(Uri.parse(SCHEME_CONTENT + device.getAddress()));
            List<String> updatedUris = Arrays.asList(GENERAL_SLICE_URI.toString(),
                    sliceUri.toString());
            PendingIntent updateSliceIntent = backAndUpdateSliceIntent(getContext(), 1,
                    new ArrayList<>(updatedUris), sliceUri.toString());
            i.putExtra(EXTRA_SLICE_FOLLOWUP, updateSliceIntent);
            PendingIntent pendingIntent = PendingIntent
                    .getActivity(context, 1, i,
                            PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
            disconnectPref.setPendingIntent(pendingIntent);
            psb.addPreference(disconnectPref);
        }

        // Update "rename preference".
        RowBuilder renamePref = new RowBuilder()
                .setKey(KEY_RENAME)
                .setTitle(getString(R.string.bluetooth_rename))
                .setActionId(0x18220000); // TvSettingsEnums.CONNECTED_SLICE_DEVICE_ENTRY_RENAME
        extras = new Bundle();
        ResponseFragment.prepareArgs(
                extras,
                KEY_RENAME,
                R.string.settings_bt_rename,
                0,
                R.drawable.ic_baseline_bluetooth_searching_large,
                null,
                deviceName,
                ResponseFragment.DEFAULT_CHOICE_UNDEFINED
        );
        i = new Intent(context, ResponseActivity.class)
                .putExtra(KEY_EXTRAS_DEVICE, device)
                .putExtras(extras)
                .setData(Uri.parse(SCHEME_CONTENT + device.getAddress()));
        List<String> updatedUris = Arrays.asList(GENERAL_SLICE_URI.toString(), sliceUri.toString());
        PendingIntent updateSliceIntent = updateSliceIntent(getContext(), 2,
                new ArrayList<>(updatedUris), sliceUri.toString());
        i.putExtra(EXTRA_SLICE_FOLLOWUP, updateSliceIntent);
        PendingIntent renamePendingIntent = PendingIntent
                .getActivity(context, 2, i,
                        PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
        renamePref.setPendingIntent(renamePendingIntent);
        psb.addPreference(renamePref);

        // Update "forget preference".
        RowBuilder forgetPref = new RowBuilder()
                .setKey(KEY_FORGET)
                .setTitle(getString(R.string.bluetooth_forget))
                .setActionId(0x18230000); // TvSettingsEnums.CONNECTED_SLICE_DEVICE_ENTRY_FORGET
        extras = new Bundle();
        i = new Intent(context, ResponseActivity.class);
        ResponseFragment.prepareArgs(
                extras,
                KEY_FORGET,
                R.string.settings_bt_forget,
                0,
                R.drawable.ic_baseline_bluetooth_searching_large,
                YES_NO_ARGS,
                deviceName,
                1 /* default to NO (index 1) */
        );
        i.putExtras(extras).putExtra(KEY_EXTRAS_DEVICE, device)
                .setData(Uri.parse(SCHEME_CONTENT + device.getAddress()));
        updatedUris = Arrays.asList(GENERAL_SLICE_URI.toString(), sliceUri.toString());
        updateSliceIntent = backAndUpdateSliceIntent(getContext(), 3,
                new ArrayList<>(updatedUris), sliceUri.toString());
        i.putExtra(EXTRA_SLICE_FOLLOWUP, updateSliceIntent);
        PendingIntent disconnectPendingIntent = PendingIntent
                .getActivity(context, 3, i,
                        PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
        forgetPref.setPendingIntent(disconnectPendingIntent);
        psb.addPreference(forgetPref);

        // Update "bluetooth device info preference".
        RowBuilder infoPref = new RowBuilder()
                .setIcon(IconCompat.createWithResource(context, R.drawable.ic_baseline_info_24dp));

        BluetoothDeviceProvider provider = getLocalBluetoothDeviceProvider();
        int battery = provider.getBatteryLevel(device);
        if (battery != BluetoothDevice.BATTERY_LEVEL_UNKNOWN) {
            String batteryText = provider.mapBatteryLevel(context, device, battery);
            final String warning = getString(R.string.settings_bt_battery_low);

            if (provider.isBatteryLow(device) && !provider.hasUpgrade(device)) {
                batteryText = context.getString(
                        R.string.settings_remote_battery_level_with_warning_label, batteryText,
                        warning);
            }
            infoPref.addInfoItem(getString(R.string.settings_remote_battery_level_label),
                    batteryText);
        }

        if (mVersionsMap.containsKey(deviceAddr)) {
            Version version = mVersionsMap.get(deviceAddr);
            if (!Version.BAD_VERSION.equals(version)) {
                infoPref.addInfoItem(getString(R.string.settings_remote_firmware_label),
                        version.toVersionString());
            }
            infoPref.addInfoItem(getString(R.string.settings_remote_serial_number_label),
                    deviceAddr);
            psb.addPreference(infoPref);
        }
        return psb.build();
    }

    // The slice that shows CEC control related information
    private Slice createCecSlice(Uri sliceUri) {
        Context context = getContext();
        PreferenceSliceBuilder psb = new PreferenceSliceBuilder(context, sliceUri);
        psb.addScreenTitle(
                new RowBuilder()
                        .setTitle(getString(R.string.settings_hdmi_cec))
                        .setPageId(0x18300000)); // TvSettingsEnums.CONNECTED_SLICE_HDMICEC
        final boolean isEnabled = PowerUtils.isCecControlEnabled(getContext());
        Intent intent = new Intent(ACTION_TOGGLE_CHANGED);
        intent.putExtra(TOGGLE_TYPE, CEC);
        intent.putExtra(TOGGLE_STATE, !isEnabled);
        intent.setClass(context, SliceBroadcastReceiver.class);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(getContext(), 0, intent,
                PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
        psb.addPreference(new RowBuilder()
                .setTitle(getString(R.string.settings_enable_hdmi_cec))
                .setActionId(0x18310000) // TvSettingsEnums.CONNECTED_SLICE_HDMICEC_ON_OFF
                .addSwitch(pendingIntent, null, isEnabled));
        psb.addPreference(new RowBuilder()
                .setTitle(getString(R.string.settings_cec_explain))
                .setEnabled(false));
        psb.addPreference(new RowBuilder()
                .setTitle(getString(R.string.settings_cec_feature_names))
                .setEnabled(false));
        return psb.build();
    }

    private void createAndAddBtDeviceSlicePreferenceFromSet(
            PreferenceSliceBuilder psb,
            Set<String> addresses,
            HashMap<String, BluetoothDevice> addressesToBtDeviceMap) {
        if (psb == null || addresses == null || addresses.isEmpty()
                || addressesToBtDeviceMap == null || addressesToBtDeviceMap.isEmpty()) {
            return;
        }
        final List<String> devicesAddressesList = new ArrayList<>(addresses);
        Collections.sort(devicesAddressesList);
        for (String deviceAddr : devicesAddressesList) {
            psb.addPreference(
                    createBtDeviceSlicePreference(
                            getContext(),
                            getBluetoothDeviceProvider(),
                            addressesToBtDeviceMap.get(deviceAddr)));
        }
    }

    private static PreferenceSliceBuilder.RowBuilder createBtDeviceSlicePreference(
            Context context, BluetoothDeviceProvider provider, BluetoothDevice device) {
        PreferenceSliceBuilder.RowBuilder pref = new PreferenceSliceBuilder.RowBuilder();
        pref.setKey(device.getAddress());
        updateBtDevicePreference(context, provider, device, pref);

        RestrictedLockUtils.EnforcedAdmin admin =
                RestrictedLockUtilsInternal.checkIfRestrictionEnforced(context,
                        UserManager.DISALLOW_CONFIG_BLUETOOTH, UserHandle.myUserId());
        if (admin == null) {
            Uri targetSliceUri = SlicesUtil.getDeviceUri(device.getAddress());
            pref.setTargetSliceUri(targetSliceUri.toString());
        } else {
            Intent intent = RestrictedLockUtils.getShowAdminSupportDetailsIntent(context, admin);
            intent.putExtra(DevicePolicyManager.EXTRA_RESTRICTION,
                    UserManager.DISALLOW_CONFIG_BLUETOOTH);
            pref.setPendingIntent(PendingIntent.getActivity(context, 0, intent,
                    PendingIntent.FLAG_IMMUTABLE));
        }
        return pref;
    }

    private static void updateBtDevicePreference(Context context, BluetoothDeviceProvider provider,
            BluetoothDevice device, PreferenceSliceBuilder.RowBuilder pref) {
        int batteryLevel = provider.getBatteryLevel(device);
        pref.setKey(device.getAddress());
        pref.setTitle(BluetoothUtils.getName(device));
        if (provider.hasUpgrade(device)) {
            pref.setSubtitle(context.getString(R.string.settings_bt_update_available));
        } else {
            if (batteryLevel != BluetoothDevice.BATTERY_LEVEL_UNKNOWN) {
                if (provider.isBatteryLow(device)) {
                    pref.setSubtitle(context.getString(R.string.settings_bt_battery_low_warning));
                } else {
                    String batteryText = provider.mapBatteryLevel(context, device, batteryLevel);
                    pref.setSubtitle(context.getString(R.string.settings_remote_battery_level,
                            batteryText));
                }
            } else {
                boolean isConnected = BluetoothUtils.isConnected(device)
                        && BluetoothUtils.getCachedBluetoothDevice(context, device) != null
                        && BluetoothUtils.getCachedBluetoothDevice(context, device).isConnected();
                pref.setSubtitle(isConnected
                        ? context.getString(R.string.bluetooth_connected_status)
                        : context.getString(R.string.bluetooth_disconnected_status));
            }
        }
        pref.setIcon(IconCompat.createWithResource(
                context, BluetoothUtils.getIcon(context, device)));
        pref.setIconNeedsToBeProcessed(true);
    }

    private final BluetoothDeviceProvider mLocalBluetoothDeviceProvider =
            new LocalBluetoothDeviceProvider() {
                final BluetoothDeviceProvider getHostBluetoothDeviceProvider() {
                    return getBluetoothDeviceProvider();
                }
            };

    private boolean showCecInConnectedSettings() {
        return Configuration.get(getContext()).isEnabled(R.bool.show_cec_in_connected_settings);
    }

    private boolean showConnectDisconnectButtons(BluetoothDevice device) {
        return !BluetoothUtils.isBluetoothDeviceMetadataInList(
                getContext(),
                device,
                BluetoothDevice.METADATA_MODEL_NAME,
                R.array.disconnect_button_hidden_device_model_names);
    }
}