ChannelVolumeInterface.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_CHANNELVOLUMEINTERFACE_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_CHANNELVOLUMEINTERFACE_H_

#include <functional>
#include <AVSCommon/AVS/SpeakerConstants/SpeakerConstants.h>
#include <AVSCommon/SDKInterfaces/SpeakerInterface.h>

namespace alexaClientSDK {
namespace avsCommon {
namespace sdkInterfaces {

class ChannelVolumeInterface {
public:
    enum class Type {
        AVS_SPEAKER_VOLUME,
        AVS_ALERTS_VOLUME
    };

    virtual bool startDucking() = 0;

    virtual bool stopDucking() = 0;

    virtual bool setUnduckedVolume(int8_t volume) = 0;

    virtual bool adjustUnduckedVolume(int8_t delta);

    virtual bool setMute(bool mute) = 0;

    virtual bool getSpeakerSettings(avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings* settings) const = 0;

    virtual Type getSpeakerType() const = 0;

    virtual std::size_t getId() const {
        return std::size_t(this);
    };

    virtual ~ChannelVolumeInterface() = default;
};

inline std::ostream& operator<<(std::ostream& stream, ChannelVolumeInterface::Type type) {
    switch (type) {
        case ChannelVolumeInterface::Type::AVS_SPEAKER_VOLUME:
            stream << "AVS_SPEAKER_VOLUME";
            return stream;
        case ChannelVolumeInterface::Type::AVS_ALERTS_VOLUME:
            stream << "AVS_ALERTS_VOLUME";
            return stream;
    }
    stream << "UNKNOWN_CHANNEL_VOLUME_TYPE";
    return stream;
}

inline bool ChannelVolumeInterface::adjustUnduckedVolume(int8_t delta) {
    if ((delta > avsCommon::avs::speakerConstants::AVS_ADJUST_VOLUME_MAX) ||
        (delta < avsCommon::avs::speakerConstants::AVS_ADJUST_VOLUME_MIN)) {
        return false;
    }
    if (0 == delta) {
        return true;
    }
    avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings settings;
    if (!getSpeakerSettings(&settings)) {
        return false;
    }
    int volume = static_cast<int>(settings.volume) + static_cast<int>(delta);
    if (volume > avsCommon::avs::speakerConstants::AVS_SET_VOLUME_MAX) {
        return setUnduckedVolume(avsCommon::avs::speakerConstants::AVS_SET_VOLUME_MAX);
    } else if (volume < avsCommon::avs::speakerConstants::AVS_SET_VOLUME_MIN) {
        return setUnduckedVolume(avsCommon::avs::speakerConstants::AVS_SET_VOLUME_MIN);
    }
    return setUnduckedVolume(static_cast<int8_t>(volume));
}

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

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_CHANNELVOLUMEINTERFACE_H_