BlueZDeviceManager.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_BLUETOOTHIMPLEMENTATIONS_BLUEZ_INCLUDE_BLUEZ_BLUEZDEVICEMANAGER_H_
#define ALEXA_CLIENT_SDK_BLUETOOTHIMPLEMENTATIONS_BLUEZ_INCLUDE_BLUEZ_BLUEZDEVICEMANAGER_H_

#include <list>
#include <map>
#include <mutex>

#include <AVSCommon/SDKInterfaces/Bluetooth/BluetoothDeviceInterface.h>
#include <AVSCommon/SDKInterfaces/Bluetooth/BluetoothDeviceManagerInterface.h>
#include <AVSCommon/SDKInterfaces/Bluetooth/BluetoothHostControllerInterface.h>
#include <AVSCommon/SDKInterfaces/Bluetooth/Services/A2DPSourceInterface.h>
#include <AVSCommon/Utils/Bluetooth/BluetoothEventBus.h>
#include <AVSCommon/Utils/Bluetooth/BluetoothEvents.h>
#include <AVSCommon/Utils/RequiresShutdown.h>

#include "BlueZ/BlueZHostController.h"
#include "BlueZ/BlueZUtils.h"
#include "BlueZ/MPRISPlayer.h"
#include "BlueZ/PairingAgent.h"

#include <gio/gio.h>

namespace alexaClientSDK {
namespace bluetoothImplementations {
namespace blueZ {

class MediaEndpoint;
class BlueZBluetoothDevice;

class BlueZDeviceManager
        : public avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceManagerInterface
        , public avsCommon::utils::RequiresShutdown
        , public std::enable_shared_from_this<BlueZDeviceManager> {
public:
    static std::shared_ptr<BlueZDeviceManager> create(
        std::shared_ptr<avsCommon::utils::bluetooth::BluetoothEventBus> eventBus);

    virtual ~BlueZDeviceManager() override;


    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothHostControllerInterface> getHostController() override;
    std::list<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface>> getDiscoveredDevices()
        override;
    std::shared_ptr<avsCommon::utils::bluetooth::BluetoothEventBus> getEventBus() override;

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

    std::shared_ptr<MediaEndpoint> getMediaEndpoint();

    std::string getAdapterPath() const;

    avsCommon::utils::bluetooth::MediaStreamingState getMediaStreamingState();

private:
    explicit BlueZDeviceManager(const std::shared_ptr<avsCommon::utils::bluetooth::BluetoothEventBus>& eventBus);

    bool init();

    bool initializeMedia();

    bool finalizeMedia();

    std::shared_ptr<BlueZBluetoothDevice> addDeviceFromDBusObject(const char* objectPath, GVariant* dbusObject);

    static void interfacesAddedCallback(
        GDBusConnection* conn,
        const gchar* sender_name,
        const gchar* object_path,
        const gchar* interface_name,
        const gchar* signal_name,
        GVariant* parameters,
        gpointer data);

    static void interfacesRemovedCallback(
        GDBusConnection* conn,
        const gchar* sender_name,
        const gchar* object_path,
        const gchar* interface_name,
        const gchar* signal_name,
        GVariant* parameters,
        gpointer data);

    static void propertiesChangedCallback(
        GDBusConnection* conn,
        const gchar* sender_name,
        const gchar* object_path,
        const gchar* interface_name,
        const gchar* signal_name,
        GVariant* parameters,
        gpointer data);

    void addDevice(const char* devicePath, std::shared_ptr<BlueZBluetoothDevice> device);

    void removeDevice(const char* devicePath);

    void notifyDeviceAdded(std::shared_ptr<BlueZBluetoothDevice> device);

    void onInterfaceAdded(const char* objectPath, ManagedGVariant& interfacesChangedMap);

    void onInterfaceRemoved(const char* objectPath);

    void onAdapterPropertyChanged(const std::string& path, const GVariantMapReader& changesMap);

    void onDevicePropertyChanged(const std::string& path, const GVariantMapReader& changesMap);

    void onMediaStreamPropertyChanged(const std::string& path, const GVariantMapReader& changesMap);

    std::shared_ptr<BlueZHostController> initializeHostController();

    void onPropertiesChanged(
        const std::string& propertyOwner,
        const std::string& objectPath,
        const GVariantMapReader& changesMap);

    bool getStateFromBlueZ();

    std::shared_ptr<BlueZBluetoothDevice> getDeviceByPath(const std::string& path) const;

    void mainLoopThread();

    std::string m_adapterPath;

    std::shared_ptr<DBusProxy> m_objectManagerProxy;

    std::shared_ptr<DBusProxy> m_mediaProxy;

    std::map<std::string, std::shared_ptr<BlueZBluetoothDevice>> m_devices;

    std::shared_ptr<MediaEndpoint> m_mediaEndpoint;

    std::shared_ptr<PairingAgent> m_pairingAgent;

    std::shared_ptr<MPRISPlayer> m_mediaPlayer;

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

    // TODO Having a separate thread for event listening is wasteful. Can optimize with a BlueZ bus listener.
    GMainLoop* m_eventLoop;

    GMainContext* m_workerContext;

    std::shared_ptr<DBusConnection> m_connection;

    avsCommon::utils::bluetooth::MediaStreamingState m_streamingState;

    mutable std::mutex m_devicesMutex;

    std::shared_ptr<BlueZHostController> m_hostController;

    std::promise<bool> m_mainLoopInitPromise;

    std::thread m_eventThread;
};

}  // namespace blueZ
}  // namespace bluetoothImplementations
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_BLUETOOTHIMPLEMENTATIONS_BLUEZ_INCLUDE_BLUEZ_BLUEZDEVICEMANAGER_H_