xref: /packages/modules/Bluetooth/android/app/src/com/android/bluetooth/avrcpcontroller/AvrcpCoverArtManager.java

/*
 * 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.bluetooth.avrcpcontroller;

import static android.bluetooth.BluetoothProfile.STATE_CONNECTED;
import static android.bluetooth.BluetoothProfile.STATE_DISCONNECTED;

import android.bluetooth.BluetoothDevice;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.SystemProperties;
import android.util.Log;

import com.android.obex.ResponseCodes;

import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Manager of all AVRCP Controller connections to remote devices' BIP servers for retrieving cover
 * art.
 *
 * <p>When given an image handle and device, this manager will negotiate the downloaded image
 * properties, download the image, and place it into a Content Provider for others to retrieve from
 */
class AvrcpCoverArtManager {
    private static final String TAG = AvrcpCoverArtManager.class.getSimpleName();

    // Image Download Schemes for cover art
    private static final String AVRCP_CONTROLLER_COVER_ART_SCHEME =
            "persist.bluetooth.avrcpcontroller.BIP_DOWNLOAD_SCHEME";
    private static final String SCHEME_NATIVE = "native";
    private static final String SCHEME_THUMBNAIL = "thumbnail";

    private final Map<BluetoothDevice, AvrcpBipClient> mClients = new ConcurrentHashMap<>(1);
    private final Map<BluetoothDevice, AvrcpBipSession> mBipSessions = new ConcurrentHashMap<>(1);
    private final AvrcpControllerService mService;
    private final AvrcpCoverArtStorage mCoverArtStorage;
    private final Callback mCallback;
    private final String mDownloadScheme;

    AvrcpCoverArtManager(AvrcpControllerService service, Callback callback) {
        mService = service;
        mCoverArtStorage = new AvrcpCoverArtStorage(mService);
        mCallback = callback;
        mDownloadScheme = SystemProperties.get(AVRCP_CONTROLLER_COVER_ART_SCHEME, SCHEME_THUMBNAIL);
        mCoverArtStorage.clear();
    }

    /**
     * An object representing an image download event. Contains the information necessary to
     * retrieve the image from storage.
     */
    record DownloadEvent(String uuid, Uri uri) {}

    interface Callback {
        /**
         * Notify of a get image download completing
         *
         * @param device The device the image handle belongs to
         * @param event The download event, containing the downloaded image's information
         */
        void onImageDownloadComplete(BluetoothDevice device, DownloadEvent event);
    }

    /**
     * A thread-safe collection of BIP connection specific information meant to be cleared each time
     * a client disconnects from the Target's BIP OBEX server.
     *
     * <p>Currently contains the mapping of image handles seen to assigned UUIDs.
     */
    private static class AvrcpBipSession {
        private final Map<String, String> mUuids = new ConcurrentHashMap<>(1); // handle -> UUID
        private final Map<String, String> mHandles = new ConcurrentHashMap<>(1); // UUID -> handle

        private String getHandleUuid(String handle) {
            if (!isValidImageHandle(handle)) return null;
            String newUuid = UUID.randomUUID().toString();
            String existingUuid = mUuids.putIfAbsent(handle, newUuid);
            if (existingUuid != null) return existingUuid;
            mHandles.put(newUuid, handle);
            return newUuid;
        }

        private String getUuidHandle(String uuid) {
            return mHandles.get(uuid);
        }

        private void clearHandleUuids() {
            mUuids.clear();
            mHandles.clear();
        }

        private Set<String> getSessionHandles() {
            return mUuids.keySet();
        }
    }

    /**
     * Validate an image handle meets the AVRCP and BIP specifications
     *
     * <p>By the BIP specification that AVRCP uses, "Image handles are 7 character long strings
     * containing only the digits 0 to 9."
     *
     * @return True if the input string is a valid image handle
     */
    static boolean isValidImageHandle(String handle) {
        if (handle == null || handle.length() != 7) return false;
        for (int i = 0; i < handle.length(); i++) {
            char c = handle.charAt(i);
            if (!Character.isDigit(c)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Create a client and connect to a remote device's BIP Image Pull Server
     *
     * @param device The remote Bluetooth device you wish to connect to
     * @param psm The Protocol Service Multiplexer that the remote device is hosting the server on
     * @return True if the connection is successfully queued, False otherwise.
     */
    synchronized boolean connect(BluetoothDevice device, int psm) {
        debug("Connect " + device + ", psm: " + psm);
        if (mClients.containsKey(device)) return false;
        AvrcpBipClient client = new AvrcpBipClient(device, psm, new BipClientCallback(device));
        client.connectAsync();
        mClients.put(device, client);
        mBipSessions.put(device, new AvrcpBipSession());
        return true;
    }

    /**
     * Refresh the OBEX session of a connected client
     *
     * @param device The remote Bluetooth device you wish to refresh
     * @return True if the refresh is successfully queued, False otherwise.
     */
    synchronized boolean refreshSession(BluetoothDevice device) {
        debug("Refresh OBEX session for " + device);
        AvrcpBipClient client = getClient(device);
        if (client == null) {
            warn("No client for " + device);
            return false;
        }
        client.refreshSession();
        return true;
    }

    /**
     * Disconnect from a remote device's BIP Image Pull Server
     *
     * @param device The remote Bluetooth device you wish to disconnect from
     * @return True if the disconnection is successfully queued, False otherwise.
     */
    synchronized boolean disconnect(BluetoothDevice device) {
        debug("Disconnect " + device);
        AvrcpBipClient client = getClient(device);
        if (client == null) {
            warn("No client for " + device);
            return false;
        }
        client.shutdown();
        mClients.remove(device);
        mBipSessions.remove(device);
        mCoverArtStorage.removeImagesForDevice(device);
        return true;
    }

    /**
     * Cleanup all cover art related resources
     *
     * <p>Please call when you've committed to shutting down the service.
     */
    synchronized void cleanup() {
        debug("Clean up and shutdown");
        for (BluetoothDevice device : mClients.keySet()) {
            disconnect(device);
        }
    }

    /**
     * Get the client connection state for a particular device's BIP Client
     *
     * @param device The Bluetooth device you want connection status for
     * @return Connection status, based on STATE_* constants
     */
    int getState(BluetoothDevice device) {
        AvrcpBipClient client = getClient(device);
        if (client == null) return STATE_DISCONNECTED;
        return client.getState();
    }

    /**
     * Get the UUID for an image handle coming from a particular device.
     *
     * <p>This UUID is used to request and track downloads.
     *
     * <p>Image handles are only good for the life of the BIP client. Since this connection is torn
     * down frequently by specification, we have a layer of indirection to the images in the form of
     * an UUID. This UUID will allow images to be identified outside the connection lifecycle. It
     * also allows handles to be reused by the target in ways that won't impact image consumer's
     * cache schemes.
     *
     * @param device The Bluetooth device you want a handle from
     * @param handle The image handle you want a UUID for
     * @return A string UUID by which the handle can be identified during the life of the BIP
     *     connection.
     */
    String getUuidForHandle(BluetoothDevice device, String handle) {
        AvrcpBipSession session = getSession(device);
        if (session == null || !isValidImageHandle(handle)) return null;
        return session.getHandleUuid(handle);
    }

    /**
     * Get the handle thats associated with a particular UUID.
     *
     * <p>The handle must have been seen during this connection.
     *
     * @param device The Bluetooth device you want a handle from
     * @param uuid The UUID you want the associated handle for
     * @return The image handle associated with this UUID if it exists, null otherwise.
     */
    String getHandleForUuid(BluetoothDevice device, String uuid) {
        AvrcpBipSession session = getSession(device);
        if (session == null || uuid == null) return null;
        return session.getUuidHandle(uuid);
    }

    void clearHandleUuids(BluetoothDevice device) {
        AvrcpBipSession session = getSession(device);
        if (session == null) return;
        session.clearHandleUuids();
    }

    /**
     * Get the Uri of an image if it has already been downloaded.
     *
     * @param device The remote Bluetooth device you wish to get an image for
     * @param imageUuid The UUID associated with the image you want
     * @return A Uri the image can be found at, null if it does not exist
     */
    Uri getImageUri(BluetoothDevice device, String imageUuid) {
        if (mCoverArtStorage.doesImageExist(device, imageUuid)) {
            return AvrcpCoverArtProvider.getImageUri(device, imageUuid);
        }
        return null;
    }

    /**
     * Download an image from a remote device and make it findable via the given uri
     *
     * <p>Downloading happens in three steps: 1) Get the available image formats by requesting the
     * Image Properties 2) Determine the specific format we want the image in and turn it into an
     * image descriptor 3) Get the image using the chosen descriptor
     *
     * <p>Getting image properties and the image are both asynchronous in nature.
     *
     * @param device The remote Bluetooth device you wish to download from
     * @param imageUuid The UUID associated with the image you wish to download. This will be
     *     translated into an image handle.
     * @return A Uri that will be assign to the image once the download is complete
     */
    Uri downloadImage(BluetoothDevice device, String imageUuid) {
        debug("Download Image - device: " + device + ", Handle: " + imageUuid);
        AvrcpBipClient client = getClient(device);
        if (client == null) {
            error("Cannot download an image. No client is available.");
            return null;
        }

        // Check to see if we have the image already. No need to download it if we do have it.
        if (mCoverArtStorage.doesImageExist(device, imageUuid)) {
            debug("Image is already downloaded");
            return AvrcpCoverArtProvider.getImageUri(device, imageUuid);
        }

        // Getting image properties will return via the callback created when connecting, which
        // invokes the download image function after we're returned the properties. If we already
        // have the image, GetImageProperties returns true but does not start a download.
        String imageHandle = getHandleForUuid(device, imageUuid);
        if (imageHandle == null) {
            warn("No handle for UUID");
            return null;
        }
        boolean status = client.getImageProperties(imageHandle);
        if (!status) return null;

        // Return the Uri that the caller should use to retrieve the image
        return AvrcpCoverArtProvider.getImageUri(device, imageUuid);
    }

    /**
     * Get a specific downloaded image if it exists
     *
     * @param device The remote Bluetooth device associated with the image
     * @param imageUuid The UUID associated with the image you wish to retrieve
     */
    Bitmap getImage(BluetoothDevice device, String imageUuid) {
        return mCoverArtStorage.getImage(device, imageUuid);
    }

    /**
     * Remove a specific downloaded image if it exists
     *
     * @param device The remote Bluetooth device associated with the image
     * @param imageUuid The UUID associated with the image you wish to remove
     */
    void removeImage(BluetoothDevice device, String imageUuid) {
        mCoverArtStorage.removeImage(device, imageUuid);
    }

    /**
     * Get a device's BIP client if it exists
     *
     * @param device The device you want the client for
     * @return The AvrcpBipClient object associated with the device, or null if it doesn't exist
     */
    private AvrcpBipClient getClient(BluetoothDevice device) {
        return mClients.get(device);
    }

    /**
     * Get a device's BIP session information, if it exists
     *
     * @param device The device you want the client for
     * @return The AvrcpBipSession object associated with the device, or null if it doesn't exist
     */
    private AvrcpBipSession getSession(BluetoothDevice device) {
        return mBipSessions.get(device);
    }

    /**
     * Determines our preferred download descriptor from the list of available image download
     * formats presented in the image properties object.
     *
     * <p>Our goal is ensure the image arrives in a format Android can consume and to minimize
     * transfer size if possible.
     *
     * @param properties The set of available formats and image is downloadable in
     * @return A descriptor containing the desirable download format
     */
    private BipImageDescriptor determineImageDescriptor(BipImageProperties properties) {
        if (properties == null || !properties.isValid()) {
            warn("Provided properties don't meet the spec. Requesting thumbnail format anyway.");
        }
        BipImageDescriptor.Builder builder = new BipImageDescriptor.Builder();
        switch (mDownloadScheme) {
                // BIP Specification says a blank/null descriptor signals to pull the native format
            case SCHEME_NATIVE:
                return null;
                // AVRCP 1.6.2 defined "thumbnail" size is guaranteed so we'll do that for now
            case SCHEME_THUMBNAIL:
            default:
                builder.setEncoding(BipEncoding.JPEG);
                builder.setFixedDimensions(200, 200);
                break;
        }
        return builder.build();
    }

    /** Callback for facilitating image download */
    class BipClientCallback implements AvrcpBipClient.Callback {
        private final BluetoothDevice mDevice;

        BipClientCallback(BluetoothDevice device) {
            mDevice = device;
        }

        @Override
        public void onConnectionStateChanged(int oldState, int newState) {
            debug(mDevice + ": " + oldState + " -> " + newState);
            if (newState == STATE_CONNECTED) {
                // Ensure the handle map is cleared since old ones are invalid on a new connection
                clearHandleUuids(mDevice);

                // Once we're connected fetch the current metadata again in case the target has an
                // image handle they can now give us. Only do this if we don't already have one.
                mService.getCurrentMetadataIfNoCoverArt(mDevice);
            } else if (newState == STATE_DISCONNECTED) {
                AvrcpBipClient client = getClient(mDevice);
                boolean shouldReconnect = (client != null);
                disconnect(mDevice);
                if (shouldReconnect) {
                    debug("Disconnect was not expected by us. Attempt to reconnect.");
                    connect(mDevice, client.getL2capPsm());
                }
            }
        }

        @Override
        public void onGetImagePropertiesComplete(
                int status, String imageHandle, BipImageProperties properties) {
            if (status != ResponseCodes.OBEX_HTTP_OK || properties == null) {
                warn(
                        mDevice
                                + ": GetImageProperties() failed - Handle: "
                                + imageHandle
                                + ", Code: "
                                + status);
                return;
            }
            BipImageDescriptor descriptor = determineImageDescriptor(properties);
            debug(mDevice + ": Download image - handle='" + imageHandle + "'");

            AvrcpBipClient client = getClient(mDevice);
            if (client == null) {
                warn(
                        mDevice
                                + ": Could not getImage() for "
                                + imageHandle
                                + " because client has disconnected.");
                return;
            }
            client.getImage(imageHandle, descriptor);
        }

        @Override
        public void onGetImageComplete(int status, String imageHandle, BipImage image) {
            if (status != ResponseCodes.OBEX_HTTP_OK) {
                warn(
                        mDevice
                                + ": GetImage() failed - Handle: "
                                + imageHandle
                                + ", Code: "
                                + status);
                return;
            }
            String imageUuid = getUuidForHandle(mDevice, imageHandle);
            debug(
                    mDevice
                            + ": Received image data for handle: "
                            + imageHandle
                            + ", uuid: "
                            + imageUuid
                            + ", image: "
                            + image);
            Uri uri = mCoverArtStorage.addImage(mDevice, imageUuid, image.getImage());
            if (uri == null) {
                error("Could not store downloaded image");
                return;
            }
            DownloadEvent event = new DownloadEvent(imageUuid, uri);
            if (mCallback != null) mCallback.onImageDownloadComplete(mDevice, event);
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("CoverArtManager:\n");
        sb.append("    Download Scheme: ").append(mDownloadScheme).append("\n");
        for (BluetoothDevice device : mClients.keySet()) {
            AvrcpBipClient client = getClient(device);
            AvrcpBipSession session = getSession(device);
            sb.append("    ").append(device).append(":").append("\n");
            sb.append("      Client: ").append(client.toString()).append("\n");
            sb.append("      Handles: ").append("\n");
            for (String handle : session.getSessionHandles()) {
                sb.append("        ")
                        .append(handle)
                        .append(" -> ")
                        .append(session.getHandleUuid(handle))
                        .append("\n");
            }
        }
        sb.append("  ").append(mCoverArtStorage.toString());
        return sb.toString();
    }

    /** Print to debug if debug is enabled for this class */
    private static void debug(String msg) {
        Log.d(TAG, msg);
    }

    /** Print to warn */
    private static void warn(String msg) {
        Log.w(TAG, msg);
    }

    /** Print to error */
    private static void error(String msg) {
        Log.e(TAG, msg);
    }
}