Bluetooth.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 ACSDKBLUETOOTH_BLUETOOTH_H_
#define ACSDKBLUETOOTH_BLUETOOTH_H_

#include <atomic>
#include <deque>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <queue>
#include <unordered_set>

#include <acsdkApplicationAudioPipelineFactoryInterfaces/ApplicationAudioPipelineFactoryInterface.h>
#include <acsdkBluetoothInterfaces/BluetoothNotifierInterface.h>
#include <acsdkBluetoothInterfaces/BluetoothDeviceConnectionRulesProviderInterface.h>
#include <acsdkBluetoothInterfaces/BluetoothDeviceObserverInterface.h>
#include <acsdkBluetoothInterfaces/BluetoothStorageInterface.h>
#include <acsdkManufactory/Annotated.h>
#include <acsdkShutdownManagerInterfaces/ShutdownNotifierInterface.h>
#include <AVSCommon/AVS/Attachment/InProcessAttachment.h>
#include <AVSCommon/AVS/AVSDirective.h>
#include <AVSCommon/AVS/CapabilityAgent.h>
#include <AVSCommon/AVS/CapabilityConfiguration.h>
#include <AVSCommon/AVS/ExceptionErrorType.h>
#include <AVSCommon/AVS/FocusState.h>
#include <AVSCommon/AVS/Requester.h>
#include <AVSCommon/SDKInterfaces/AudioFocusAnnotation.h>
#include <AVSCommon/SDKInterfaces/CapabilityConfigurationInterface.h>
#include <AVSCommon/SDKInterfaces/ChannelVolumeInterface.h>
#include <AVSCommon/SDKInterfaces/ContextManagerInterface.h>
#include <AVSCommon/SDKInterfaces/ContextRequesterInterface.h>
#include <AVSCommon/SDKInterfaces/FocusManagerInterface.h>
#include <AVSCommon/SDKInterfaces/MessageSenderInterface.h>
#include <AVSCommon/SDKInterfaces/Bluetooth/BluetoothDeviceConnectionRuleInterface.h>
#include <AVSCommon/SDKInterfaces/Bluetooth/BluetoothDeviceInterface.h>
#include <AVSCommon/SDKInterfaces/Bluetooth/BluetoothDeviceManagerInterface.h>
#include <AVSCommon/SDKInterfaces/Bluetooth/Services/AVRCPTargetInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/DefaultEndpointAnnotation.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointCapabilitiesRegistrarInterface.h>
#include <AVSCommon/Utils/Bluetooth/BluetoothEventBus.h>
#include <AVSCommon/Utils/Bluetooth/BluetoothEvents.h>
#include <AVSCommon/Utils/Bluetooth/DeviceCategory.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerObserverInterface.h>
#include <AVSCommon/Utils/Optional.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Bluetooth/FormattedAudioStreamAdapter.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <RegistrationManager/CustomerDataHandler.h>
#include <RegistrationManager/CustomerDataManagerInterface.h>

#include "acsdkBluetooth/BluetoothEventState.h"
#include "acsdkBluetooth/BluetoothMediaInputTransformer.h"
#include "acsdkBluetoothInterfaces/BluetoothLocalInterface.h"

namespace alexaClientSDK {
namespace acsdkBluetooth {

static const constexpr char* BLUETOOTH_MEDIA_PLAYER_NAME = "BluetoothMediaPlayer";

class Bluetooth
        : public std::enable_shared_from_this<Bluetooth>
        , public acsdkBluetoothInterfaces::BluetoothLocalInterface
        , public avsCommon::avs::CapabilityAgent
        , public avsCommon::utils::bluetooth::BluetoothEventListenerInterface
        , public avsCommon::utils::bluetooth::FormattedAudioStreamAdapterListener
        , public avsCommon::sdkInterfaces::CapabilityConfigurationInterface
        , public avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface
        , public avsCommon::utils::RequiresShutdown
        , public registrationManager::CustomerDataHandler {
public:
    using ObserverInterface = acsdkBluetoothInterfaces::BluetoothDeviceObserverInterface;

    enum class StreamingState {
        INACTIVE,

        PAUSED,

        PENDING_PAUSED,

        PENDING_ACTIVE,

        ACTIVE
    };

    enum class FocusTransitionState {
        NONE,

        INTERNAL,

        PENDING_INTERNAL,

        EXTERNAL
    };

    enum class ScanningTransitionState {
        ACTIVE,

        PENDING_INACTIVE,

        INACTIVE
    };

    static std::shared_ptr<Bluetooth> createBluetoothCapabilityAgent(
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionEncounteredSender,
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothStorageInterface> bluetoothStorage,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceManagerInterface> deviceManager,
        std::shared_ptr<avsCommon::utils::bluetooth::BluetoothEventBus> eventBus,
        std::shared_ptr<registrationManager::CustomerDataManagerInterface> customerDataManager,
        std::shared_ptr<acsdkApplicationAudioPipelineFactoryInterfaces::ApplicationAudioPipelineFactoryInterface>
            audioPipelineFactory,
        acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::AudioFocusAnnotation,
            avsCommon::sdkInterfaces::FocusManagerInterface> audioFocusManager,
        std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface> shutdownNotifier,
        acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::endpoints::DefaultEndpointAnnotation,
            avsCommon::sdkInterfaces::endpoints::EndpointCapabilitiesRegistrarInterface> endpointCapabilitiesRegistrar,
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothDeviceConnectionRulesProviderInterface>
            connectionRulesProvider,
        std::shared_ptr<BluetoothMediaInputTransformer> mediaInputTransformer,
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothNotifierInterface> bluetoothNotifier);

    avsCommon::avs::DirectiveHandlerConfiguration getConfiguration() const override;
    void handleDirectiveImmediately(std::shared_ptr<avsCommon::avs::AVSDirective> directive) override;
    void preHandleDirective(std::shared_ptr<avsCommon::avs::CapabilityAgent::DirectiveInfo> info) override;
    void handleDirective(std::shared_ptr<avsCommon::avs::CapabilityAgent::DirectiveInfo> info) override;
    void cancelDirective(std::shared_ptr<avsCommon::avs::CapabilityAgent::DirectiveInfo> info) override;
    void onFocusChanged(avsCommon::avs::FocusState newFocus, avsCommon::avs::MixingBehavior behavior) override;

    void setDiscoverableMode(bool discoverable) override;
    void setScanMode(bool scanning) override;
    void pair(const std::string& addr) override;
    void unpair(const std::string& addr) override;
    void connect(const std::string& addr) override;
    void disconnect(const std::string& addr) override;
    void setPairingPin(const std::string& addr, const std::string& pin) override;

    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> getCapabilityConfigurations() override;

    // @name ContextRequester Functions
    void onContextAvailable(const std::string& jsonContext) override;
    void onContextFailure(const avsCommon::sdkInterfaces::ContextRequestError error) override;

    // @name RequiresShutdown Functions
    void doShutdown() override;

    void onFirstByteRead(
        avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface::SourceId id,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackStarted(
        avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface::SourceId id,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackStopped(
        avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface::SourceId id,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackFinished(
        avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface::SourceId id,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackError(
        avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface::SourceId id,
        const avsCommon::utils::mediaPlayer::ErrorType& type,
        std::string error,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;

    void clearData() override;
protected:
    void onEventFired(const avsCommon::utils::bluetooth::BluetoothEvent& event) override;

private:
    Bluetooth(
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionEncounteredSender,
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothStorageInterface> bluetoothStorage,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceManagerInterface> deviceManager,
        std::shared_ptr<avsCommon::utils::bluetooth::BluetoothEventBus> eventBus,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> mediaPlayer,
        std::shared_ptr<registrationManager::CustomerDataManagerInterface> customerDataManager,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceConnectionRuleInterface>>
            enabledConnectionRules,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface> bluetoothChannelVolumeInterface,
        std::shared_ptr<BluetoothMediaInputTransformer> mediaInputTransformer,
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothNotifierInterface> bluetoothNotifier);

    bool init();

    void syncWithDeviceManager();

    // TODO ACSDK-1392: Optimize by updating the context only when there is a delta.
    void executeUpdateContext();

    bool extractAvsProfiles(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device,
        rapidjson::Document::AllocatorType& allocator,
        rapidjson::Value* supportedProfiles);

    void executeSetHandlingCompleted(std::shared_ptr<DirectiveInfo> info);

    void removeDirective(std::shared_ptr<DirectiveInfo> info);

    void sendExceptionEncountered(
        std::shared_ptr<CapabilityAgent::DirectiveInfo> info,
        const std::string& message,
        avsCommon::avs::ExceptionErrorType type);

    void executeEnterForeground();

    void executeEnterBackground(avsCommon::avs::MixingBehavior behavior);

    void executeEnterNone();

    void executeHandleEnterDiscoverableMode();

    void executeHandleExitDiscoverableMode();

    void executeHandleScanDevices();

    bool executeHandlePairDevices(const std::unordered_set<std::string>& uuids);

    bool executeHandleUnpairDevices(const std::unordered_set<std::string>& uuids);

    bool executeHandleConnectByDeviceIds(const std::unordered_set<std::string>& uuids);

    bool executeHandleDisconnectDevices(const std::unordered_set<std::string>& uuids);

    bool executeSetDiscoverableMode(bool discoverable);

    bool executeSetScanMode(bool scanning, bool shouldReport = true);

    bool executePairDevices(const std::unordered_set<std::string>& uuids);

    bool executeUnpairDevices(const std::unordered_set<std::string>& uuids);

    std::map<std::string, std::string> executeSetDeviceCategories(
        const std::map<std::string, std::string>& uuidCategoryMap);

    void executeConnectByDeviceIds(const std::unordered_set<std::string>& uuids);

    void executeConnectByProfile(const std::string& profileName, const std::string& profileVersion);

    void executeDisconnectDevices(const std::unordered_set<std::string>& uuids);

    void executeSetPairingPin(const std::string& addr, const std::string& pin);

    void executeOnDeviceDisconnect(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device,
        avsCommon::avs::Requester requester);

    void executeOnDeviceConnect(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device,
        bool shouldNotifyConnection = true);

    bool executeFunctionOnDevice(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>& device,
        std::function<std::future<bool>(
            std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>&)> function);

    void executePlay(std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeStop(std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeNext(std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executePrevious(std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeInitializeMediaSource();

    void cleanupMediaSource();

    void executeAbortMediaPlayback();

    void setCurrentStream(std::shared_ptr<avsCommon::utils::bluetooth::FormattedAudioStreamAdapter> stream);


    void onFormattedAudioStreamAdapterData(
        avsCommon::utils::AudioFormat audioFormat,
        const unsigned char* buffer,
        size_t size) override;


    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> retrieveDeviceByMac(
        const std::string& mac);

    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> retrieveDeviceByUuid(
        const std::string& uuid);

    bool retrieveDeviceCategoryByUuid(const std::string& uuid, DeviceCategory* category);

    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceConnectionRuleInterface>
    retrieveConnectionRuleByUuid(const std::string& uuid);

    bool retrieveUuid(const std::string& mac, std::string* uuid);

    std::unordered_set<std::string> retrieveUuidsFromConnectionPayload(const rapidjson::Document& payload);

    void clearUnusedUuids();

    void executeSendEvent(const std::string& eventName, const std::string& eventPayload);

    void executeQueueEventAndRequestContext(const std::string& eventName, const std::string& eventPayload);

    void executeSendScanDevicesReport(
        const std::list<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>>& devices,
        bool hasMore);

    void executeSendScanDevicesFailed();

    void executeSendEnterDiscoverableModeSucceeded();

    void executeSendEnterDiscoverableModeFailed();

    void executeSendPairDevicesSucceeded(
        const std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>>&
            devices);

    void executeSendPairFailedEvent(const std::string& eventName, const std::unordered_set<std::string>& uuids);

    void executeSendPairDevicesFailed(const std::unordered_set<std::string>& uuids);

    void executeSendUnpairDevicesSucceeded(
        const std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>>&
            devices);

    void executeSendUnpairDevicesFailed(const std::unordered_set<std::string>& uuids);

    void executeSetDeviceCategoriesSucceeded(const std::map<std::string, std::string>& uuidCategoryMap);

    void executeSetDeviceCategoriesFailed(const std::map<std::string, std::string>& uuidCategoryMap);

    void executeSendConnectByDeviceIdsSucceeded(
        const std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>>&
            devices,
        avsCommon::avs::Requester requester);

    void executeSendConnectByDeviceIdsFailed(
        const std::unordered_set<std::string>& uuids,
        avsCommon::avs::Requester requester);

    void executeSendConnectByProfileSucceeded(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device,
        const std::string& profileName,
        avsCommon::avs::Requester requester);

    void executeSendConnectByProfileFailed(const std::string& profileName, avsCommon::avs::Requester requester);

    void executeSendDisconnectDevicesSucceeded(
        const std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>>&
            devices,
        avsCommon::avs::Requester requester);

    void executeSendConnectFailedEvent(
        const std::string& eventName,
        const std::unordered_set<std::string>& uuids,
        avsCommon::avs::Requester requester);

    void executeSendDisconnectDevicesFailed(
        const std::unordered_set<std::string>& uuids,
        avsCommon::avs::Requester requester);

    void executeSendMediaControlEvent(
        const std::string& eventName,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendMediaControlPlaySucceeded(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendMediaControlPlayFailed(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendMediaControlStopSucceeded(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendMediaControlStopFailed(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendMediaControlNextSucceeded(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendMediaControlNextFailed(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendMediaControlPreviousSucceeded(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendMediaControlPreviousFailed(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendStreamingEvent(
        const std::string& eventName,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendStreamingStarted(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeSendStreamingEnded(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    ObserverInterface::DeviceAttributes generateDeviceAttributes(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    template <typename ServiceType>
    std::shared_ptr<ServiceType> getService(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device);

    void executeInsertBluetoothEventState(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device,
        avsCommon::sdkInterfaces::bluetooth::DeviceState state,
        avsCommon::utils::Optional<avsCommon::avs::Requester> requester,
        avsCommon::utils::Optional<std::string> profileName);

    std::shared_ptr<BluetoothEventState> executeRemoveBluetoothEventState(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface> device,
        avsCommon::sdkInterfaces::bluetooth::DeviceState state);

    void executeRestrictA2DPDevices();

    void executeUnrestrictA2DPDevices();

    void executeAcquireFocus(const std::string& callingMethodName = "");

    void executeReleaseFocus(const std::string& callingMethodName = "");

    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> m_capabilityConfigurations;

    std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> m_messageSender;

    std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> m_contextManager;

    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> m_focusManager;

    // TODO 1396: Combine @c m_streamingState and @c m_focusState into a single state machine if possible.
    StreamingState m_streamingState;

    FocusTransitionState m_focusTransitionState;

    ScanningTransitionState m_scanningTransitionState;

    avsCommon::avs::FocusState m_focusState;

    avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface::SourceId m_sourceId;

    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceManagerInterface> m_deviceManager;

    std::queue<std::pair<std::string, std::string>> m_eventQueue;

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

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

    std::vector<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>> m_restrictedDevices;

    std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> m_mediaPlayer;

    std::shared_ptr<acsdkBluetoothInterfaces::BluetoothStorageInterface> m_db;

    std::shared_ptr<avsCommon::utils::bluetooth::BluetoothEventBus> m_eventBus;

    std::shared_ptr<BluetoothMediaInputTransformer> m_mediaInputTransformer;

    std::shared_ptr<avsCommon::utils::bluetooth::FormattedAudioStreamAdapter> m_mediaStream;

    std::shared_ptr<avsCommon::avs::attachment::InProcessAttachment> m_mediaAttachment;

    std::shared_ptr<avsCommon::avs::attachment::AttachmentWriter> m_mediaAttachmentWriter;

    std::shared_ptr<avsCommon::avs::attachment::AttachmentReader> m_mediaAttachmentReader;

    std::map<
        DeviceCategory,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceConnectionRuleInterface>>
        m_enabledConnectionRules;

    std::map<DeviceCategory, std::set<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>>>
        m_connectedDevices;

    std::map<std::string, std::unordered_set<std::shared_ptr<BluetoothEventState>>> m_bluetoothEventStates;

    std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface> m_bluetoothChannelVolumeInterface;

    std::shared_ptr<acsdkBluetoothInterfaces::BluetoothNotifierInterface> m_bluetoothNotifier;

    std::atomic<uint8_t> m_pendingFocusTransitions;

    avsCommon::utils::threading::Executor m_executor;
};

inline std::string streamingStateToString(Bluetooth::StreamingState state) {
    switch (state) {
        case Bluetooth::StreamingState::INACTIVE:
            return "INACTIVE";
        case Bluetooth::StreamingState::PAUSED:
            return "PAUSED";
        case Bluetooth::StreamingState::PENDING_PAUSED:
            return "PENDING_PAUSED";
        case Bluetooth::StreamingState::PENDING_ACTIVE:
            return "PENDING_ACTIVE";
        case Bluetooth::StreamingState::ACTIVE:
            return "ACTIVE";
    }

    return "UNKNOWN";
}

inline std::ostream& operator<<(std::ostream& stream, const Bluetooth::StreamingState state) {
    return stream << streamingStateToString(state);
}

inline std::string focusTransitionStateToString(Bluetooth::FocusTransitionState state) {
    switch (state) {
        case Bluetooth::FocusTransitionState::NONE:
            return "NONE";
        case Bluetooth::FocusTransitionState::INTERNAL:
            return "INTERNAL";
        case Bluetooth::FocusTransitionState::PENDING_INTERNAL:
            return "PENDING_INTERNAL";
        case Bluetooth::FocusTransitionState::EXTERNAL:
            return "EXTERNAL";
    }

    return "UNKNOWN";
}

inline std::ostream& operator<<(std::ostream& stream, const Bluetooth::FocusTransitionState state) {
    return stream << focusTransitionStateToString(state);
}

inline std::string scanningStateToString(Bluetooth::ScanningTransitionState state) {
    switch (state) {
        case Bluetooth::ScanningTransitionState::ACTIVE:
            return "ACTIVE";
        case Bluetooth::ScanningTransitionState::PENDING_INACTIVE:
            return "PENDING_ACTIVE";
        case Bluetooth::ScanningTransitionState::INACTIVE:
            return "INACTIVE";
    }

    return "UNKNWON";
}

inline std::ostream& operator<<(std::ostream& stream, const Bluetooth::ScanningTransitionState state) {
    return stream << scanningStateToString(state);
}

}  // namespace acsdkBluetooth
}  // namespace alexaClientSDK

#endif  // ACSDKBLUETOOTH_BLUETOOTH_H_