/*
 * Copyright (C) 2016 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 android.bluetooth;

import android.util.Log;

/**
 * The template class that applications use to call callback functions on events from the HID host.
 * Callback functions are wrapped in this class and registered to the Android system during app
 * registration.
 *
 * <p>{@see BluetoothHidDevice}
 */
public abstract class BluetoothHidDeviceCallback {

    private static final String TAG = "BluetoothHidDevCallback";

    /**
     * Callback called when application registration state changes. Usually it's called due to
     * either {@link BluetoothHidDevice#registerApp (String, String, String, byte, byte[],
     * BluetoothHidDeviceCallback)} or {@link BluetoothHidDevice#unregisterApp()} , but can be also
     * unsolicited in case e.g. Bluetooth was turned off in which case application is unregistered
     * automatically.
     *
     * @param pluggedDevice {@link BluetoothDevice} object which represents host that currently has
     *     Virtual Cable established with device. Only valid when application is registered, can be
     *     <code>null</code>.
     * @param registered <code>true</code> if application is registered, <code>false</code>
     *     otherwise.
     */
    public void onAppStatusChanged(BluetoothDevice pluggedDevice, boolean registered) {
        Log.d(TAG,
                "onAppStatusChanged: pluggedDevice=" + pluggedDevice + " registered=" + registered);
    }

    /**
     * Callback called when connection state with remote host was changed. Application can assume
     * than Virtual Cable is established when called with {@link BluetoothProfile#STATE_CONNECTED}
     * <code>state</code>.
     *
     * @param device {@link BluetoothDevice} object representing host device which connection state
     *     was changed.
     * @param state Connection state as defined in {@link BluetoothProfile}.
     */
    public void onConnectionStateChanged(BluetoothDevice device, int state) {
        Log.d(TAG, "onConnectionStateChanged: device=" + device + " state=" + state);
    }

    /**
     * Callback called when GET_REPORT is received from remote host. Should be replied by
     * application using {@link BluetoothHidDevice#replyReport(BluetoothDevice, byte, byte,
     * byte[])}.
     *
     * @param type Requested Report Type.
     * @param id Requested Report Id, can be 0 if no Report Id are defined in descriptor.
     * @param bufferSize Requested buffer size, application shall respond with at least given number
     *     of bytes.
     */
    public void onGetReport(BluetoothDevice device, byte type, byte id, int bufferSize) {
        Log.d(TAG, "onGetReport: device=" + device + " type=" + type + " id=" + id + " bufferSize="
                + bufferSize);
    }

    /**
     * Callback called when SET_REPORT is received from remote host. In case received data are
     * invalid, application shall respond with {@link
     * BluetoothHidDevice#reportError(BluetoothDevice, byte)}.
     *
     * @param type Report Type.
     * @param id Report Id.
     * @param data Report data.
     */
    public void onSetReport(BluetoothDevice device, byte type, byte id, byte[] data) {
        Log.d(TAG, "onSetReport: device=" + device + " type=" + type + " id=" + id);
    }

    /**
     * Callback called when SET_PROTOCOL is received from remote host. Application shall use this
     * information to send only reports valid for given protocol mode. By default, {@link
     * BluetoothHidDevice#PROTOCOL_REPORT_MODE} shall be assumed.
     *
     * @param protocol Protocol Mode.
     */
    public void onSetProtocol(BluetoothDevice device, byte protocol) {
        Log.d(TAG, "onSetProtocol: device=" + device + " protocol=" + protocol);
    }

    /**
     * Callback called when report data is received over interrupt channel. Report Type is assumed
     * to be {@link BluetoothHidDevice#REPORT_TYPE_OUTPUT}.
     *
     * @param reportId Report Id.
     * @param data Report data.
     */
    public void onInterruptData(BluetoothDevice device, byte reportId, byte[] data) {
        Log.d(TAG, "onInterruptData: device=" + device + " reportId=" + reportId);
    }

    /**
     * Callback called when Virtual Cable is removed. After this callback is
     * received connection will be disconnected automatically.
     */
    public void onVirtualCableUnplug(BluetoothDevice device) {
        Log.d(TAG, "onVirtualCableUnplug: device=" + device);
    }
}