BluetoothDeviceInterface.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file 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.
 */

#ifndef ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_BLUETOOTH_BLUETOOTHDEVICEINTERFACE_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_BLUETOOTH_BLUETOOTHDEVICEINTERFACE_H_

#include <future>
#include <memory>
#include <ostream>
#include <string>
#include <vector>

#include <AVSCommon/SDKInterfaces/Bluetooth/Services/BluetoothServiceInterface.h>
#include <AVSCommon/SDKInterfaces/Bluetooth/Services/SDPRecordInterface.h>
#include <AVSCommon/Utils/Bluetooth/MediaStreamingState.h>
#include <AVSCommon/Utils/Optional.h>

namespace alexaClientSDK {
namespace avsCommon {
namespace sdkInterfaces {
namespace bluetooth {

enum class DeviceState {
    // A device has been discovered.
    FOUND,
    // [Transitional] The device has been unpaired.
    UNPAIRED,
    // [Transitional] The device has successfully paired.
    PAIRED,
    // A paired device.
    IDLE,
    // [Transitional] A device has successfully disconnected.
    DISCONNECTED,
    // A device that has successfully connected.
    CONNECTED
};

inline std::string deviceStateToString(DeviceState state) {
    switch (state) {
        case DeviceState::FOUND:
            return "FOUND";
        case DeviceState::UNPAIRED:
            return "UNPAIRED";
        case DeviceState::PAIRED:
            return "PAIRED";
        case DeviceState::IDLE:
            return "IDLE";
        case DeviceState::DISCONNECTED:
            return "DISCONNECTED";
        case DeviceState::CONNECTED:
            return "CONNECTED";
    }

    return "UNKNOWN";
}

inline std::ostream& operator<<(std::ostream& stream, const DeviceState state) {
    return stream << deviceStateToString(state);
}

class BluetoothDeviceInterface {
public:
    struct MetaData {
        static const int UNDEFINED_CLASS_VALUE = 0;

        utils::Optional<int> vendorId;
        utils::Optional<int> productId;
        int classOfDevice;
        utils::Optional<int> vendorDeviceSigId;
        utils::Optional<std::string> vendorDeviceId;

        MetaData(
            utils::Optional<int> vendorId,
            utils::Optional<int> productId,
            int classOfDevice,
            utils::Optional<int> vendorDeviceSigId,
            utils::Optional<std::string> vendorDeviceId) :
                vendorId(vendorId),
                productId(productId),
                classOfDevice(classOfDevice),
                vendorDeviceSigId(vendorDeviceSigId),
                vendorDeviceId(vendorDeviceId) {
        }
    };

    virtual ~BluetoothDeviceInterface() = default;

    virtual std::string getMac() const = 0;

    virtual std::string getFriendlyName() const = 0;

    virtual DeviceState getDeviceState() = 0;

    virtual MetaData getDeviceMetaData() = 0;

    virtual bool isPaired() = 0;

    virtual std::future<bool> pair() = 0;

    virtual std::future<bool> unpair() = 0;

    virtual bool isConnected() = 0;

    virtual std::future<bool> connect() = 0;

    virtual std::future<bool> disconnect() = 0;

    virtual bool setPairingPin(const std::string& pin) = 0;

    virtual std::vector<std::shared_ptr<services::SDPRecordInterface>> getSupportedServices() = 0;

    virtual std::shared_ptr<services::BluetoothServiceInterface> getService(std::string uuid) = 0;

    virtual utils::bluetooth::MediaStreamingState getStreamingState() = 0;

    virtual bool toggleServiceConnection(
        bool enabled,
        std::shared_ptr<services::BluetoothServiceInterface> service) = 0;
};

}  // namespace bluetooth
}  // namespace sdkInterfaces
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_BLUETOOTH_BLUETOOTHDEVICEINTERFACE_H_