EqualizerTypes.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 ACSDKEQUALIZERINTERFACES_EQUALIZERTYPES_H_
#define ACSDKEQUALIZERINTERFACES_EQUALIZERTYPES_H_

#include <array>
#include <string>
#include <unordered_map>

#include <AVSCommon/Utils/functional/hash.h>
#include <AVSCommon/Utils/Error/SuccessResult.h>

namespace alexaClientSDK {
namespace acsdkEqualizerInterfaces {

enum class EqualizerBand {
    BASS,
    MIDRANGE,
    TREBLE
};

const std::array<EqualizerBand, 3> EqualizerBandValues = {
    {EqualizerBand::BASS, EqualizerBand::MIDRANGE, EqualizerBand::TREBLE}};

enum class EqualizerMode {
    NONE,
    MOVIE,
    MUSIC,
    NIGHT,
    SPORT,
    TV
};

const std::array<EqualizerMode, 6> EqualizerModeValues = {{EqualizerMode::NONE,
                                                           EqualizerMode::MOVIE,
                                                           EqualizerMode::MUSIC,
                                                           EqualizerMode::NIGHT,
                                                           EqualizerMode::SPORT,
                                                           EqualizerMode::TV}};

using EqualizerBandLevelMap = std::unordered_map<EqualizerBand, int, avsCommon::utils::functional::EnumClassHash>;

struct EqualizerState {
    EqualizerMode mode;
    EqualizerBandLevelMap bandLevels;
};

inline bool operator==(const EqualizerState& state1, const EqualizerState& state2) {
    return state1.mode == state2.mode && state1.bandLevels == state2.bandLevels;
}

inline std::string equalizerBandToString(EqualizerBand band) {
    switch (band) {
        case EqualizerBand::BASS:
            return "BASS";
        case EqualizerBand::MIDRANGE:
            return "MIDRANGE";
        case EqualizerBand::TREBLE:
            return "TREBLE";
    }

    return "UNKNOWN";
}

inline std::ostream& operator<<(std::ostream& stream, EqualizerBand band) {
    return stream << equalizerBandToString(band);
}

inline std::string equalizerModeToString(EqualizerMode mode) {
    switch (mode) {
        case EqualizerMode::NONE:
            return "NONE";
        case EqualizerMode::MOVIE:
            return "MOVIE";
        case EqualizerMode::MUSIC:
            return "MUSIC";
        case EqualizerMode::NIGHT:
            return "NIGHT";
        case EqualizerMode::SPORT:
            return "SPORT";
        case EqualizerMode::TV:
            return "TV";
    }

    return "UNKNOWN";
}

inline std::ostream& operator<<(std::ostream& stream, EqualizerMode mode) {
    return stream << equalizerModeToString(mode);
}

inline avsCommon::utils::error::SuccessResult<EqualizerBand> stringToEqualizerBand(const std::string& stringValue) {
    if (stringValue == "BASS") {
        return avsCommon::utils::error::SuccessResult<EqualizerBand>::success(EqualizerBand::BASS);
    }
    if (stringValue == "MIDRANGE") {
        return avsCommon::utils::error::SuccessResult<EqualizerBand>::success(EqualizerBand::MIDRANGE);
    }
    if (stringValue == "TREBLE") {
        return avsCommon::utils::error::SuccessResult<EqualizerBand>::success(EqualizerBand::TREBLE);
    }

    return avsCommon::utils::error::SuccessResult<EqualizerBand>::failure();
}

inline avsCommon::utils::error::SuccessResult<EqualizerMode> stringToEqualizerMode(const std::string& stringValue) {
    if (stringValue == "NONE") {
        return avsCommon::utils::error::SuccessResult<EqualizerMode>::success(EqualizerMode::NONE);
    }
    if (stringValue == "MOVIE") {
        return avsCommon::utils::error::SuccessResult<EqualizerMode>::success(EqualizerMode::MOVIE);
    }
    if (stringValue == "MUSIC") {
        return avsCommon::utils::error::SuccessResult<EqualizerMode>::success(EqualizerMode::MUSIC);
    }
    if (stringValue == "NIGHT") {
        return avsCommon::utils::error::SuccessResult<EqualizerMode>::success(EqualizerMode::NIGHT);
    }
    if (stringValue == "SPORT") {
        return avsCommon::utils::error::SuccessResult<EqualizerMode>::success(EqualizerMode::SPORT);
    }
    if (stringValue == "TV") {
        return avsCommon::utils::error::SuccessResult<EqualizerMode>::success(EqualizerMode::TV);
    }

    return avsCommon::utils::error::SuccessResult<EqualizerMode>::failure();
}

}  // namespace acsdkEqualizerInterfaces
}  // namespace alexaClientSDK

#endif  // ACSDKEQUALIZERINTERFACES_EQUALIZERTYPES_H_