BlueZBluetoothDevice.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_BLUEZBLUETOOTHDEVICE_H_
#define ALEXA_CLIENT_SDK_BLUETOOTHIMPLEMENTATIONS_BLUEZ_INCLUDE_BLUEZ_BLUEZBLUETOOTHDEVICE_H_

#include <future>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>

#include <gio/gio.h>

#include <AVSCommon/SDKInterfaces/Bluetooth/BluetoothDeviceInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/Bluetooth/SDPRecords.h>
#include "BlueZ/DBusPropertiesProxy.h"

namespace alexaClientSDK {
namespace bluetoothImplementations {
namespace blueZ {

class BlueZDeviceManager;

class BlueZBluetoothDevice
        : public avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface
        , public std::enable_shared_from_this<BlueZBluetoothDevice> {
public:
    enum class BlueZDeviceState {
        FOUND,
        UNPAIRED,
        PAIRED,
        IDLE,
        DISCONNECTED,
        CONNECTED,
        CONNECTION_FAILED
    };

    ~BlueZBluetoothDevice() override;

    std::string getMac() const override;
    std::string getFriendlyName() const override;
    avsCommon::sdkInterfaces::bluetooth::DeviceState getDeviceState() override;
    MetaData getDeviceMetaData() override;

    bool isPaired() override;
    std::future<bool> pair() override;
    std::future<bool> unpair() override;

    bool isConnected() override;
    std::future<bool> connect() override;
    std::future<bool> disconnect() override;

    bool setPairingPin(const std::string& pin) override;

    std::vector<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::SDPRecordInterface>>
    getSupportedServices() override;
    std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::BluetoothServiceInterface> getService(
        std::string uuid) override;
    avsCommon::utils::bluetooth::MediaStreamingState getStreamingState() override;
    bool toggleServiceConnection(
        bool enabled,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::BluetoothServiceInterface> service) override;

    static std::shared_ptr<BlueZBluetoothDevice> create(
        const std::string& mac,
        const std::string& objectPath,
        std::shared_ptr<BlueZDeviceManager> deviceManager);

    std::string getObjectPath() const;

    void onPropertyChanged(const GVariantMapReader& changesMap);

private:
    BlueZBluetoothDevice(
        const std::string& mac,
        const std::string& objectPath,
        std::shared_ptr<BlueZDeviceManager> deviceManager);

    bool init();

    bool updateFriendlyName();

    std::unordered_set<std::string> getServiceUuids();

    std::unordered_set<std::string> getServiceUuids(GVariant* array);

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

    bool executePair();

    bool executeUnpair();

    bool executeConnect();

    bool executeDisconnect();

    bool executeIsPaired();

    bool executeIsConnected();

    bool executeToggleServiceConnection(
        bool enabled,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::BluetoothServiceInterface> service);

    bool queryDeviceProperty(const std::string& name, bool* value);

    avsCommon::sdkInterfaces::bluetooth::DeviceState convertToDeviceState(BlueZDeviceState bluezDeviceState);

    void transitionToState(BlueZDeviceState newState, bool sendEvent);

    /*
     * Querying BlueZ for whether the Connect property is set to true does not guarantee
     * that a device has established a connection with its services.
     * The Connect property can be set to true when pairing:
     *
     * 1) Pairing (BlueZ sends Connect = true).
     * 2) Pair Successful.
     * 3) Connect multimedia services.
     * 4) Connect multimedia services successful (BlueZ sends Paired = true, UUIDs = [array of
     * uuids]).
     *
     * Use a combination of Connect, Paired, and the availability of certain UUIDs to
     * determine if a service has been connected to. A relevant service currently encompasses the set of
     * A2DP services that AVS uses to understand connectedness. This should be done in the executor.
     *
     * @return Whether the device has established a connection with at least one service of interest.
     */
    bool executeIsConnectedToRelevantServices();

    bool serviceExists(const std::string& uuid);

    bool insertService(
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::BluetoothServiceInterface> service);

    template <typename ServiceType>
    std::shared_ptr<ServiceType> getService();

    template <typename BlueZServiceType>
    bool initializeService();

    std::shared_ptr<DBusProxy> m_deviceProxy;

    std::shared_ptr<DBusPropertiesProxy> m_propertiesProxy;

    const std::string m_mac;

    const std::string m_objectPath;

    std::string m_friendlyName;

    std::mutex m_servicesMapMutex;

    std::unordered_map<
        std::string,
        std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::services::BluetoothServiceInterface>>
        m_servicesMap;

    BlueZDeviceState m_deviceState;

    std::unique_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceInterface::MetaData> m_metaData;

    std::shared_ptr<BlueZDeviceManager> m_deviceManager;

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

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

    return "UNKNOWN";
}

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

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

#endif  // ALEXA_CLIENT_SDK_BLUETOOTHIMPLEMENTATIONS_BLUEZ_INCLUDE_BLUEZ_BLUEZBLUETOOTHDEVICE_H_