BluetoothEvents.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_UTILS_INCLUDE_AVSCOMMON_UTILS_BLUETOOTH_BLUETOOTHEVENTS_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_BLUETOOTH_BLUETOOTHEVENTS_H_

#include "AVSCommon/SDKInterfaces/Bluetooth/BluetoothDeviceInterface.h"
#include "AVSCommon/SDKInterfaces/Bluetooth/Services/A2DPSourceInterface.h"
#include "AVSCommon/SDKInterfaces/Bluetooth/Services/AVRCPTargetInterface.h"
#include "AVSCommon/Utils/Bluetooth/A2DPRole.h"
#include "AVSCommon/Utils/Bluetooth/MediaStreamingState.h"

namespace alexaClientSDK {
namespace avsCommon {
namespace utils {
namespace bluetooth {

enum class BluetoothEventType {
    DEVICE_DISCOVERED,

    DEVICE_REMOVED,

    DEVICE_STATE_CHANGED,

    STREAMING_STATE_CHANGED,

    MEDIA_COMMAND_RECEIVED,

    BLUETOOTH_DEVICE_MANAGER_INITIALIZED,

    SCANNING_STATE_CHANGED,

    TOGGLE_A2DP_PROFILE_STATE_CHANGED
};

struct BluetoothEventTypeHash {
    template <typename T>
    std::size_t operator()(T t) const {
        return static_cast<std::size_t>(t);
    }
};

class BluetoothEvent {
public:
    virtual ~BluetoothEvent() = default;

    BluetoothEventType getType() const;

    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> getDevice() const;

    avsCommon::sdkInterfaces::bluetooth::DeviceState getDeviceState() const;

    MediaStreamingState getMediaStreamingState() const;

    std::shared_ptr<A2DPRole> getA2DPRole() const;

    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::MediaCommand> getMediaCommand() const;

    bool isScanning() const;

    bool isA2DPEnabled() const;

protected:
    BluetoothEvent(
        BluetoothEventType type,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device = nullptr,
        avsCommon::sdkInterfaces::bluetooth::DeviceState deviceState =
            avsCommon::sdkInterfaces::bluetooth::DeviceState::IDLE,
        MediaStreamingState mediaStreamingState = MediaStreamingState::IDLE,
        std::shared_ptr<A2DPRole> role = nullptr,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::MediaCommand> mediaCommand = nullptr,
        bool scanningState = false,
        bool a2dpEnable = false);

private:
    BluetoothEventType m_type;

    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> m_device;

    avsCommon::sdkInterfaces::bluetooth::DeviceState m_deviceState;

    MediaStreamingState m_mediaStreamingState;

    std::shared_ptr<A2DPRole> m_a2dpRole;

    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::MediaCommand> m_mediaCommand;

    bool m_scanningState;

    bool m_a2dpEnable;
};

inline BluetoothEvent::BluetoothEvent(
    BluetoothEventType type,
    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device,
    avsCommon::sdkInterfaces::bluetooth::DeviceState deviceState,
    MediaStreamingState mediaStreamingState,
    std::shared_ptr<A2DPRole> a2dpRole,
    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::MediaCommand> mediaCommand,
    bool scanningState,
    bool a2dpEnable) :
        m_type{type},
        m_device{device},
        m_deviceState{deviceState},
        m_mediaStreamingState{mediaStreamingState},
        m_a2dpRole{a2dpRole},
        m_mediaCommand{mediaCommand},
        m_scanningState{scanningState},
        m_a2dpEnable{a2dpEnable} {
}

inline BluetoothEventType BluetoothEvent::getType() const {
    return m_type;
}

inline std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> BluetoothEvent::getDevice()
    const {
    return m_device;
}

inline avsCommon::sdkInterfaces::bluetooth::DeviceState BluetoothEvent::getDeviceState() const {
    return m_deviceState;
}

inline MediaStreamingState BluetoothEvent::getMediaStreamingState() const {
    return m_mediaStreamingState;
}

inline std::shared_ptr<A2DPRole> BluetoothEvent::getA2DPRole() const {
    return m_a2dpRole;
}

inline std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::MediaCommand> BluetoothEvent::getMediaCommand()
    const {
    return m_mediaCommand;
}

inline bool BluetoothEvent::isScanning() const {
    return m_scanningState;
}

inline bool BluetoothEvent::isA2DPEnabled() const {
    return m_a2dpEnable;
}

class DeviceDiscoveredEvent : public BluetoothEvent {
public:
    explicit DeviceDiscoveredEvent(
        const std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>& device);
};

inline DeviceDiscoveredEvent::DeviceDiscoveredEvent(
    const std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>& device) :
        BluetoothEvent(
            BluetoothEventType::DEVICE_DISCOVERED,
            device,
            avsCommon::sdkInterfaces::bluetooth::DeviceState::IDLE,
            MediaStreamingState::IDLE) {
}

class DeviceRemovedEvent : public BluetoothEvent {
public:
    explicit DeviceRemovedEvent(
        const std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>& device);
};

inline DeviceRemovedEvent::DeviceRemovedEvent(
    const std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>& device) :
        BluetoothEvent(
            BluetoothEventType::DEVICE_REMOVED,
            device,
            avsCommon::sdkInterfaces::bluetooth::DeviceState::IDLE,
            MediaStreamingState::IDLE) {
}

class DeviceStateChangedEvent : public BluetoothEvent {
public:
    DeviceStateChangedEvent(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device,
        avsCommon::sdkInterfaces::bluetooth::DeviceState newState);
};

inline DeviceStateChangedEvent::DeviceStateChangedEvent(
    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device,
    avsCommon::sdkInterfaces::bluetooth::DeviceState newState) :
        BluetoothEvent(BluetoothEventType::DEVICE_STATE_CHANGED, device, newState, MediaStreamingState::IDLE) {
}

class MediaStreamingStateChangedEvent : public BluetoothEvent {
public:
    explicit MediaStreamingStateChangedEvent(
        MediaStreamingState newState,
        A2DPRole role,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);
};

inline MediaStreamingStateChangedEvent::MediaStreamingStateChangedEvent(
    MediaStreamingState newState,
    A2DPRole role,
    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device) :
        BluetoothEvent(
            BluetoothEventType::STREAMING_STATE_CHANGED,
            device,
            avsCommon::sdkInterfaces::bluetooth::DeviceState::IDLE,
            newState,
            std::make_shared<A2DPRole>(role)){};

class MediaCommandReceivedEvent : public BluetoothEvent {
public:
    explicit MediaCommandReceivedEvent(avsCommon::sdkInterfaces::bluetooth::services::MediaCommand command);
};

inline MediaCommandReceivedEvent::MediaCommandReceivedEvent(
    avsCommon::sdkInterfaces::bluetooth::services::MediaCommand command) :
        BluetoothEvent(
            BluetoothEventType::MEDIA_COMMAND_RECEIVED,
            nullptr,
            avsCommon::sdkInterfaces::bluetooth::DeviceState::IDLE,
            MediaStreamingState::IDLE,
            nullptr,
            std::make_shared<avsCommon::sdkInterfaces::bluetooth::services::MediaCommand>(command)) {
}

class BluetoothDeviceManagerInitializedEvent : public BluetoothEvent {
public:
    explicit BluetoothDeviceManagerInitializedEvent();
};

inline BluetoothDeviceManagerInitializedEvent::BluetoothDeviceManagerInitializedEvent() :
        BluetoothEvent(BluetoothEventType::BLUETOOTH_DEVICE_MANAGER_INITIALIZED) {
}

class ScanningStateChangedEvent : public BluetoothEvent {
public:
    explicit ScanningStateChangedEvent(bool isScanning);
};

inline ScanningStateChangedEvent::ScanningStateChangedEvent(bool isScanning) :
        BluetoothEvent(
            BluetoothEventType::SCANNING_STATE_CHANGED,
            nullptr,
            avsCommon::sdkInterfaces::bluetooth::DeviceState::IDLE,
            MediaStreamingState::IDLE,
            nullptr,
            nullptr,
            isScanning) {
}

class ToggleA2DPProfileStateChangedEvent : public BluetoothEvent {
public:
    explicit ToggleA2DPProfileStateChangedEvent(bool a2dpEnable);
};

inline ToggleA2DPProfileStateChangedEvent::ToggleA2DPProfileStateChangedEvent(bool a2dpEnable) :
        BluetoothEvent(
            BluetoothEventType::TOGGLE_A2DP_PROFILE_STATE_CHANGED,
            nullptr,
            avsCommon::sdkInterfaces::bluetooth::DeviceState::IDLE,
            MediaStreamingState::IDLE,
            nullptr,
            nullptr,
            false,
            a2dpEnable) {
}

}  // namespace bluetooth
}  // namespace utils
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_BLUETOOTH_BLUETOOTHEVENTS_H_