path: root/libraries/BluetoothServices/src/com/google/android/tv/btservices/BluetoothDeviceService.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;

import android.app.ActivityManager;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.app.Service;
import android.bluetooth.BluetoothA2dp;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.provider.Settings;
import android.util.Log;
import android.widget.Toast;
import com.android.settingslib.bluetooth.CachedBluetoothDevice;
import com.google.android.tv.btservices.remote.DefaultProxy;
import com.google.android.tv.btservices.remote.DfuBinary;
import com.google.android.tv.btservices.remote.DfuManager;
import com.google.android.tv.btservices.remote.DfuProvider;
import com.google.android.tv.btservices.remote.RemoteProxy;
import com.google.android.tv.btservices.remote.RemoteProxy.BatteryResult;
import com.google.android.tv.btservices.remote.RemoteProxy.DfuResult;
import com.google.android.tv.btservices.remote.Version;
import com.google.android.tv.btservices.settings.BluetoothDeviceProvider;
import com.google.common.base.Stopwatch;
import com.google.common.base.Ticker;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;

public abstract class BluetoothDeviceService
        extends Service implements DfuManager.Listener, DfuProvider.Listener {
    private static final String TAG = "Atv.BtDeviceService";
    private static final boolean DEBUG = false;
    private static final String USER_SETUP_COMPLETE = "user_setup_complete";
    private static final String TV_USER_SETUP_COMPLETE = "tv_user_setup_complete";
    private static final String FASTPAIR_PROCESS = "com.google.android.gms.ui";

    private static final long BATTERY_VALIDITY_PERIOD_MS =
            TimeUnit.MILLISECONDS.convert(5, TimeUnit.MINUTES);

    private static final long NOTIFY_FIRMWARE_UPDATE_DELAY_MS = 7000;
    private static final long PERIODIC_DFU_CHECK_MS =
            TimeUnit.MILLISECONDS.convert(5, TimeUnit.MINUTES);
    private static final long INITIATE_DFU_CHECK_DELAY_MS =
            TimeUnit.MILLISECONDS.convert(5, TimeUnit.MINUTES);
    // Following list is describes the set of intents to try in case we need to pair a remote. The
    // list should be traversed in order.
    private static final List<Intent> ORDERED_PAIRING_INTENTS = Collections.unmodifiableList(
            Arrays.asList(new Intent("com.google.android.tvsetup.app.REPAIR_REMOTE"),
                    new Intent("com.google.android.intent.action.CONNECT_INPUT")));
    protected final Handler mHandler = new Handler(Looper.getMainLooper());
    private final List<BluetoothDeviceProvider.Listener> mListeners = new ArrayList<>();
    private final List<DfuManager.Listener> mDfuListeners = new ArrayList<>();
    private final Binder mBinder = new LocalBinder();
    // Maps a MAC address to the last time battery level was refreshed. This is
    // used only by devices that uses polling for battery level.
    private final Map<BluetoothDevice, Stopwatch> mLastBatteryRefreshWatch = new HashMap<>();
    private final Map<BluetoothDevice, RemoteProxy> mProxies = new HashMap<>();
    private final Ticker ticker = new Ticker() {
        public long read() {
            return android.os.SystemClock.elapsedRealtimeNanos();
        }
    };
    private final Runnable mCheckDfu = this::checkDfu;
    BroadcastReceiver mBluetoothReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            final String action = intent.getAction();
            final BluetoothDevice device = getDeviceHelper(intent);
            // The sequence of a typical connection is: acl connected, bonding, bonded, profile
            // connecting, profile connected.
            if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)) {
                final int state = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, -1);
                switch (state) {
                    case BluetoothDevice.BOND_BONDED:
                        mHandler.post(() -> addDevice(device));
                        break;
                    case BluetoothDevice.BOND_NONE:
                        mHandler.post(() -> onDeviceUnbonded(device));
                        break;
                    case BluetoothDevice.BOND_BONDING:
                        break;
                    default:
                        if (DEBUG) Log.e(TAG, "unknown state " + state + " " + device);
                }
            } else {
                switch (action) {
                    case BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED:
                        int state = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, -1);
                        mHandler.post(() -> onA2dpConnectionStateChanged(device.getName(), state));
                        break;
                    case BluetoothDevice.ACTION_ACL_CONNECTED:
                        Log.i(TAG, "acl connected " + device);
                        if (device.getBondState() == BluetoothDevice.BOND_BONDED) {
                            mHandler.post(() -> addDevice(device));
                            mHandler.post(() -> onDeviceUpdated(device));
                        }
                        break;
                    case BluetoothDevice.ACTION_ACL_DISCONNECTED:
                        Log.i(TAG, "acl disconnected " + device);
                        mHandler.post(() -> removeDevice(device));
                        mHandler.post(() -> onDeviceUpdated(device));
                        break;
                    case BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED:
                        Log.i(TAG, "acl disconnect requested: " + device);
                        break;
                }
            }
        }
    };

    protected boolean isRemote(BluetoothDevice device) {
        boolean res = BluetoothUtils.isRemote(this, device);
        if (DEBUG) {
            Log.d(TAG, "Device " + device.getName() + " isRemote(): " + res);
        }
        return res;
    }

    protected static List<Intent> getPairingIntents() {
        return ORDERED_PAIRING_INTENTS;
    }

    public static void startPairingRemoteActivity(Context context) {
        PackageManager pm = context.getPackageManager();
        if (pm == null) {
            return;
        }
        Intent candidateIntent = null;
        intentLoop:
        for (Intent intent : getPairingIntents()) {
            for (ResolveInfo info : pm.queryIntentActivities(intent, 0)) {
                if (info.activityInfo == null || info.activityInfo.applicationInfo == null) {
                    continue;
                }
                boolean isSystemApp = ((info.activityInfo.applicationInfo.flags &
                        ApplicationInfo.FLAG_SYSTEM) != 0) ||
                        ((info.activityInfo.applicationInfo.flags &
                                ApplicationInfo.PRIVATE_FLAG_OEM) != 0);
                Log.i(TAG, "Found activity: " + info.activityInfo + " for intent: " + intent +
                        " is System/OEM app: " + isSystemApp);
                if (!isSystemApp) {
                    continue;
                }
                candidateIntent = intent;
                break intentLoop;
            }
        }
        if (candidateIntent != null) {
            Intent intent = new Intent(candidateIntent).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            context.startActivity(intent);
        } else {
            Log.w(TAG, "Did not find suitable intents for remote pairing.");
        }
    }

    private static BluetoothDevice getDeviceHelper(Intent intent) {
        if (intent == null) {
            return null;
        }
        return intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
    }

    protected static List<BluetoothDevice> getDevices() {
        final BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
        if (btAdapter != null) {
            Set<BluetoothDevice> devices = btAdapter.getBondedDevices();
            if (devices != null) {
                return new ArrayList<>(devices);
            }
        }
        return Collections.emptyList();
    }

    public static BluetoothDevice findDevice(String address) {
        List<BluetoothDevice> devices = getDevices();
        BluetoothDevice curDevice = null;
        for (BluetoothDevice device : devices) {
            if (address.equals(device.getAddress())) {
                curDevice = device;
                break;
            }
        }
        return curDevice;
    }

    private static void forgetDevice(BluetoothDevice device) {
        if (device == null || !device.removeBond()) {
            Log.w(TAG, "failed to remove bond: " + device);
        }
    }

    public static void forgetAndRepair(Context context, BluetoothDevice device) {
        if (device == null) {
            Log.w(TAG, "null device");
            return;
        }
        if (!device.removeBond()) {
            Log.w(TAG, "failed to remove bond");
        }
        startPairingRemoteActivity(context);
    }

    private static boolean isSetupComplete(Context context) {
        return Settings.Secure.getInt(context.getContentResolver(), USER_SETUP_COMPLETE, 0) > 0
                && Settings.Secure.getInt(context.getContentResolver(), TV_USER_SETUP_COMPLETE, 0)
                > 0;
    }

    protected abstract DfuProvider getDfuProvider();

    protected abstract RemoteProxy createRemoteProxy(BluetoothDevice device);

    private RemoteProxy createDefaultProxy(BluetoothDevice device){
        return new DefaultProxy(this, device);
    }

    private void checkDfu() {
        List<BluetoothDevice> devices = getDevices();
        for (BluetoothDevice device : devices) {
            if (!isRemote(device)) {
                continue;
            }
            deviceCheckDfu(device);
        }
        mHandler.removeCallbacks(mCheckDfu);
        mHandler.postDelayed(mCheckDfu, PERIODIC_DFU_CHECK_MS);
    }

    private void onDeviceUpdated(BluetoothDevice device) {
        mListeners.forEach(listener -> listener.onDeviceUpdated(device));
    }

    private void onDfuUpdated(BluetoothDevice device, DfuResult res) {
        mDfuListeners.forEach(listener -> listener.onDfuProgress(device, res));
    }

    private void addDevice(BluetoothDevice device) {
        if (device == null || !device.isConnected()) {
            return;
        }

        final RemoteProxy proxy;
        if (!isRemote(device)) {
            proxy = createDefaultProxy(device);
        } else {
            proxy = createRemoteProxy(device);
        }
        mProxies.put(device, proxy);

        if (!proxy.initialize(this)) {
            removeDevice(device);
            return;
        }

        // Initiate version read.
        refreshRemoteVersion(device, result -> {
            onDeviceUpdated(device);
        });

        // Initiate battery level read.
        initializeDeviceBatteryLevelRead(device);

        mHandler.postDelayed(() ->
                deviceCheckDfu(device), NOTIFY_FIRMWARE_UPDATE_DELAY_MS);
    }

    private void removeDevice(BluetoothDevice device) {
        RemoteProxy proxy = getRemoteProxy(device);
        if (proxy == null) {
            return;
        }
        // Clean up info for the disconnected device.
        mHandler.post(() -> {
            NotificationCenter.dismissUpdateNotification(device);
            mLastBatteryRefreshWatch.remove(device);
            mProxies.remove(device);
        });
    }

    private void onDeviceUnbonded(BluetoothDevice device) {
        NotificationCenter.dismissUpdateNotification(device);
        onDeviceUpdated(device);
    }

    private void deviceCheckDfu(BluetoothDevice device) {
        if (device == null || !device.isConnected() || !isRemote(device)) {
            NotificationCenter.dismissUpdateNotification(device);
            return;
        }

        RemoteProxy proxy = getRemoteProxy(device);
        if (proxy == null) {
            Log.e(TAG, "deviceCheckDfu: no proxy");
            NotificationCenter.dismissUpdateNotification(device);
            return;
        }

        if (proxy.getDfuState() != null) {
            Log.e(TAG, "deviceCheckDfu: already doing DFU for: " + device);
            NotificationCenter.dismissUpdateNotification(device);
            return;
        }

        if (proxy.supportsBackgroundDfu()) {
            // `startRemoteDfu` checks if all criteria for dfu are met.
            startRemoteDfu(device, true);
        } else {
            if (hasRemoteUpgrade(device) && !isRemoteLowBattery(device)) {
                NotificationCenter.sendDfuNotification(device);
            } else {
                NotificationCenter.dismissUpdateNotification(device);
            }
        }

        onDeviceUpdated(device);
    }

    private void connectDevice(BluetoothDevice device) {
        if (device != null) {
            CachedBluetoothDevice cachedDevice =
                    BluetoothUtils.getCachedBluetoothDevice(this, device);
            if (cachedDevice != null) {
                cachedDevice.connect();
            }
        }
    }

    private void disconnectDevice(BluetoothDevice device) {
        if (device != null) {
            CachedBluetoothDevice cachedDevice =
                    BluetoothUtils.getCachedBluetoothDevice(this, device);
            if (cachedDevice != null) {
                cachedDevice.disconnect();
            }
        }
    }

    private void renameDevice(BluetoothDevice device, String newName) {
        if (device != null) {
            device.setAlias(newName);
            mHandler.post(() -> onDeviceUpdated(device));
        }
    }

    private void refreshLowBatteryNotification(BluetoothDevice device, boolean forceNotification) {
        if (!isRemote(device)){
            return;
        }

        RemoteProxy proxy = getRemoteProxy(device);
        if (proxy == null) {
            return;
        }

        if (isRemoteCriticalBattery(device)) {
            NotificationCenter.refreshLowBatteryNotification(
                    device, NotificationCenter.BatteryState.CRITICAL, forceNotification);
        } else if (isRemoteLowBattery(device)) {
            NotificationCenter.refreshLowBatteryNotification(
                    device, NotificationCenter.BatteryState.LOW, forceNotification);
        } else {
            NotificationCenter.refreshLowBatteryNotification(
                    device, NotificationCenter.BatteryState.GOOD, forceNotification);
        }
    }

    private int getLowBatteryLevel(BluetoothDevice device) {
        RemoteProxy proxy = getRemoteProxy(device);
        if (proxy == null) {
            return RemoteProxy.DEFAULT_LOW_BATTERY_LEVEL;
        }
        return proxy.lowBatteryLevel();
    }

    private int getCriticalBatteryLevel(BluetoothDevice device) {
        return RemoteProxy.DEFAULT_CRITICAL_BATTERY_LEVEL;
    }

    protected boolean isRemoteLowBattery(BluetoothDevice device) {
        if (device == null) {
            return false;
        }
        if (!BluetoothUtils.isConnected(device)) {
            return false;
        }
        if (!isRemote(device)) {
            return false;
        }

        final int battery = getBatteryLevel(device);
        if (battery == BluetoothDevice.BATTERY_LEVEL_UNKNOWN) {
            return false;
        }
        return battery <= getLowBatteryLevel(device);
    }

    protected boolean isRemoteCriticalBattery(BluetoothDevice device) {
        if (device == null) {
            return false;
        }
        if (!BluetoothUtils.isConnected(device)) {
            return false;
        }
        if (!isRemote(device)) {
            return false;
        }

        final int battery = getBatteryLevel(device);
        if (battery == BluetoothDevice.BATTERY_LEVEL_UNKNOWN) {
            return false;
        }
        return battery <= getCriticalBatteryLevel(device);
    }

    protected boolean hasRemoteUpgrade(BluetoothDevice device) {
        if (device == null) {
            return false;
        }
        if (!BluetoothUtils.isConnected(device)) {
            return false;
        }
        if (!isRemote(device)) {
            return false;
        }

        final DfuProvider provider = getDfuProvider();
        if (provider == null) {
            return false;
        }

        Version version = getRemoteVersion(device);
        if (version == null || version.equals(Version.BAD_VERSION)) {
            return false;
        }
        final String name = BluetoothUtils.getOriginalName(device);
        return provider.getDfu(name, version) != null;
    }

    // DfuManager.Listener implementation.
    @Override
    public void onDfuProgress(BluetoothDevice device, RemoteProxy.DfuResult result) {
        mHandler.post(() -> onDfuUpdated(device, result));
    }

    private DfuResult getRemoteDfuState(BluetoothDevice device) {
        if (device == null) {
            Log.e(TAG, "getRemoteDfuState: no device");
            return null;
        }
        if (!BluetoothUtils.isConnected(device)) {
            return null;
        }
        if (!isRemote(device)) {
            Log.e(TAG, "getRemoteDfuState: not a remote " + device);
            return null;
        }

        RemoteProxy proxy = getRemoteProxy(device);
        return proxy != null ? proxy.getDfuState() : null;
    }

    protected void startRemoteDfu(String address) {
        BluetoothDevice device = findDevice(address);
        startRemoteDfu(device, false);
    }

    protected void startRemoteDfu(BluetoothDevice device, boolean background) {
        if (device == null) {
            Log.e(TAG, "startRemoteDfu: ");
            return;
        }
        if (!isRemote(device)) {
            Log.e(TAG, "startRemoteDfu: not a remote " + device);
            return;
        }

        if (!hasRemoteUpgrade(device)) {
            Log.e(TAG, "startRemoteDfu: not eligible for upgrade " + device);
            return;
        }

        if (isRemoteLowBattery(device)) {
            Log.e(TAG, "startRemoteDfu: cannot update due to low battery " + device);
            return;
        }

        if (!isSetupComplete(this)) {
            Log.e(TAG, "startRemoteDfu: oobe must be completed before updating " + device);
            return;
        }

        final DfuProvider provider = getDfuProvider();
        if (provider == null) {
            Log.e(TAG, "startRemoteDfu: no remote dfu provider");
            return;
        }

        RemoteProxy proxy = getRemoteProxy(device);
        if (proxy == null) {
            Log.e(TAG, "startRemoteDfu: proxy is null");
            return;
        }

        proxy.refreshVersion().thenAccept(status -> {
            if (!status) {
                return;
            }

            Version currentVersion = proxy.getLastKnownVersion();
            final String name = BluetoothUtils.getOriginalName(device);
            final DfuBinary dfu = provider.getDfu(name, currentVersion);

            if (dfu == null) {
                Log.e(TAG, "Unexpected null dfu binary");
                return;
            }

            Set<Version> versionsNeedRepairing = provider.getManualReconnectionVersions();

            final boolean needsRepair = versionsNeedRepairing.contains(currentVersion);

            Log.i(TAG, "current: " + currentVersion + " new version: " + dfu.getVersion() +
                    " repair: " + needsRepair);

            NotificationCenter.dismissUpdateNotification(device);
            proxy.requestDfu(dfu, this, background).thenAccept(result -> {
                DfuResult newResult = result;
                if (result == DfuResult.RESULT_DEVICE_BUSY) {
                    Log.i(TAG, "Device busy, skipping remote update request for " + device);
                    return;
                }

                if (result == DfuResult.RESULT_SUCCESS && needsRepair) {
                    newResult = DfuResult.RESULT_SUCCESS_NEEDS_PAIRING;
                }
                onDfuUpdated(device, newResult);
            });
        });
    }

    private void onA2dpConnectionStateChanged(String deviceName, int connectionStatus) {
        // Avoiding showing Toast while Fastpair is in Foreground.
        if (fastPairInForeground()) {
            return;
        }
        String resStr;
        String text;
        switch (connectionStatus) {
            case BluetoothProfile.STATE_CONNECTED:
                resStr = getResources().getString(R.string.settings_bt_pair_toast_connected);
                text = String.format(resStr, deviceName);
                Toast.makeText(BluetoothDeviceService.this.getApplicationContext(),
                        text, Toast.LENGTH_SHORT).show();
                break;
            case BluetoothProfile.STATE_DISCONNECTED:
                resStr = getResources().getString(R.string.settings_bt_pair_toast_disconnected);
                text = String.format(resStr, deviceName);
                Toast.makeText(BluetoothDeviceService.this.getApplicationContext(),
                        text, Toast.LENGTH_SHORT).show();
                break;
            case BluetoothProfile.STATE_CONNECTING:
            case BluetoothProfile.STATE_DISCONNECTING:
            default:
                break;
        }
    }

    private boolean fastPairInForeground() {
        ActivityManager activityManager = getSystemService(ActivityManager.class);
        if (activityManager == null) {
            return false;
        }
        List<RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
        if (appProcesses == null) {
            return false;
        }
        for (RunningAppProcessInfo appProcess : appProcesses) {
            if (FASTPAIR_PROCESS.equals(appProcess.processName) &&
                appProcess.importance  == RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                return true;
            }
        }
        return false;
    }

    private RemoteProxy getRemoteProxy(BluetoothDevice device) {
        if (device == null) {
            return null;
        }
        return mProxies.get(device);
    }

    /**
     * Synchronous remote version read from RemoteProxy.
     *
     * This should only be called by UI thread that needs result immediately.
     */
    protected Version getRemoteVersion(BluetoothDevice device) {
        RemoteProxy proxy = getRemoteProxy(device);

        if (proxy != null) {
            return proxy.getLastKnownVersion();
        } else {
            return Version.BAD_VERSION;
        }
    }

    protected Version getRemoteVersion(String address) {
        BluetoothDevice device = findDevice(address);
        return getRemoteVersion(device);
    }

    /** Asynchronous remote version refresh. */
    private void refreshRemoteVersion(BluetoothDevice device, Consumer<Version> callback) {
        RemoteProxy proxy = getRemoteProxy(device);

        if (proxy != null) {
            proxy.refreshVersion().thenAccept(status -> {
                if (status) {
                    Version version = proxy.getLastKnownVersion();
                    callback.accept(version);
                } else {
                    Log.w(TAG, "Failed to refresh remote version.");
                }
            });
        }
    }

    private int getBatteryLevel(BluetoothDevice device) {
        if (device == null) {
            return BluetoothDevice.BATTERY_LEVEL_UNKNOWN;
        }
        if (!BluetoothUtils.isConnected(device)) {
            return BluetoothDevice.BATTERY_LEVEL_UNKNOWN;
        }

        RemoteProxy proxy = getRemoteProxy(device);
        if (proxy != null) {
            BatteryResult result = proxy.getLastKnownBatteryLevel();

            if (result.code() == BatteryResult.SUCCESS) {
                Stopwatch stopwatch = mLastBatteryRefreshWatch.get(device);
                if (stopwatch != null &&
                    stopwatch.elapsed(TimeUnit.MILLISECONDS) > BATTERY_VALIDITY_PERIOD_MS) {
                    stopwatch.reset();
                    stopwatch.start();

                    proxy.refreshBatteryLevel().thenAccept(status -> {
                        if (status) {
                            refreshLowBatteryNotification(device, false);
                            onDeviceUpdated(device);
                        }
                    });
                }

                return result.battery();
            }
        }

        return BluetoothDevice.BATTERY_LEVEL_UNKNOWN;
    }

    private String mapBatteryLevel(Context context, BluetoothDevice device, int level) {
        RemoteProxy proxy = getRemoteProxy(device);

        if (proxy == null) {
            return context.getString(
                    R.string.settings_remote_battery_level_percentage_label, level);
        }

        return proxy.mapBatteryLevel(context, level);
    }

    private void initializeDeviceBatteryLevelRead(BluetoothDevice device) {
        if (device == null) {
            Log.w(TAG, "initializeDeviceBatteryLevelRead for null device");
            return;
        }

        RemoteProxy proxy = getRemoteProxy(device);
        if (proxy != null) {
            proxy.registerBatteryLevelCallback(() -> {
                refreshLowBatteryNotification(device, false);
                onDeviceUpdated(device);
            }).thenAccept(callbackRegistered -> {
                proxy.refreshBatteryLevel().thenAccept(result -> {
                    if (result) {
                        if (!callbackRegistered) {
                            // Callback is not registered. Enable polling.
                            Stopwatch stopwatch = Stopwatch.createStarted(ticker);
                            mLastBatteryRefreshWatch.put(device, stopwatch);
                        } else {
                            mLastBatteryRefreshWatch.remove(device);
                        }

                        refreshLowBatteryNotification(device, true);
                        onDeviceUpdated(device);
                    }
                });
            });
        }
    }

    private void initiateDfuCheck() {
        NotificationCenter.resetUpdateNotification();
        checkDfu();
    }

    // Implements DfuProvider.Listener
    @Override
    public void onDfuFileAdd() {
        initiateDfuCheck();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        if (DEBUG) Log.e(TAG, "onCreate");

        IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_ACL_CONNECTED);
        filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED);
        filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);
        filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
        filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED); // Headset connection
        registerReceiver(mBluetoothReceiver, filter);
        for (BluetoothDevice device : getDevices()) {
            if (device.isConnected()) {
                addDevice(device);
            }
        }

        mHandler.postDelayed(this::initiateDfuCheck, INITIATE_DFU_CHECK_DELAY_MS);

        NotificationCenter.initialize(this);
    }

    @Override
    public void onDestroy() {
        if (DEBUG) Log.e(TAG, "onDestroy");
        unregisterReceiver(mBluetoothReceiver);

        mHandler.removeCallbacksAndMessages(null);
        super.onDestroy();
    }

    @Override
    protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
        for (BluetoothDevice device : getDevices()) {
            if (!device.isConnected()) {
                continue;
            }

            RemoteProxy proxy = getRemoteProxy(device);

            if (proxy == null) {
                continue;
            }

            writer.printf("%s (%s):%n", device.getName(), device.getAddress());

            Version version = proxy.getLastKnownVersion();
            writer.printf("  Firmware Version: %s%n", version.toString());

            int battLevel = proxy.getLastKnownBatteryLevel().battery();
            writer.printf("  Battery Level: %d%n", battLevel);
        }
    }

    public class LocalBinder extends Binder implements BluetoothDeviceProvider {

        public List<BluetoothDevice> getDevices() {
            return BluetoothDeviceService.getDevices();
        }

        @Override
        public void connectDevice(BluetoothDevice device) {
            BluetoothDeviceService.this.connectDevice(device);
        }

        @Override
        public void disconnectDevice(BluetoothDevice device) {
            BluetoothDeviceService.this.disconnectDevice(device);
        }

        @Override
        public void forgetDevice(BluetoothDevice device) {
            BluetoothDeviceService.forgetDevice(device);
        }

        @Override
        public void renameDevice(BluetoothDevice device, String newName) {
            BluetoothDeviceService.this.renameDevice(device, newName);
        }

        @Override
        public int getBatteryLevel(BluetoothDevice device) {
            return BluetoothDeviceService.this.getBatteryLevel(device);
        }

        @Override
        public String mapBatteryLevel(Context context, BluetoothDevice device, int level) {
            return BluetoothDeviceService.this.mapBatteryLevel(context, device, level);
        }

        @Override
        public Version getVersion(BluetoothDevice device) {
            return BluetoothDeviceService.this.getRemoteVersion(device);
        }

        @Override
        public boolean hasUpgrade(BluetoothDevice device) {
            return BluetoothDeviceService.this.hasRemoteUpgrade(device);
        }

        @Override
        public boolean isBatteryLow(BluetoothDevice device) {
            return BluetoothDeviceService.this.isRemoteLowBattery(device);
        }

        @Override
        public DfuResult getDfuState(BluetoothDevice device) {
            return BluetoothDeviceService.this.getRemoteDfuState(device);
        }

        @Override
        public void startDfu(BluetoothDevice device) {
            BluetoothDeviceService.this.startRemoteDfu(device, false);
        }

        @Override
        public void addListener(BluetoothDeviceProvider.Listener listener) {
            mHandler.post(() -> {
                mListeners.add(listener);

                // Trigger first update after listener callback is registered.
                for (BluetoothDevice device : getDevices()) {
                    if (device.isConnected()) {
                        listener.onDeviceUpdated(device);
                    }
                }
            });
        }

        @Override
        public void removeListener(BluetoothDeviceProvider.Listener listener) {
            mHandler.post(() -> mListeners.remove(listener));
        }

        @Override
        public void addListener(DfuManager.Listener listener) {
            mHandler.post(() -> mDfuListeners.add(listener));
        }

        @Override
        public void removeListener(DfuManager.Listener listener) {
            mHandler.post(() -> mDfuListeners.remove(listener));
        }

        public void dismissDfuNotification(String address) {
            BluetoothDevice device = BluetoothDeviceService.findDevice(address);
            NotificationCenter.dismissUpdateNotification(device);
        }
    }
}