AbstractKeywordDetector.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 ACSDKKWDIMPLEMENTATIONS_ABSTRACTKEYWORDDETECTOR_H_
#define ACSDKKWDIMPLEMENTATIONS_ABSTRACTKEYWORDDETECTOR_H_

#include <mutex>
#include <unordered_set>

#include <acsdkKWDInterfaces/KeywordDetectorStateNotifierInterface.h>
#include <acsdkKWDInterfaces/KeywordNotifierInterface.h>
#include <AVSCommon/AVS/AudioInputStream.h>
#include <AVSCommon/SDKInterfaces/KeyWordDetectorStateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/KeyWordObserverInterface.h>
#include <AVSCommon/Utils/AudioFormat.h>

namespace alexaClientSDK {
namespace acsdkKWDImplementations {

class AbstractKeywordDetector {
public:
    void addKeyWordObserver(std::shared_ptr<avsCommon::sdkInterfaces::KeyWordObserverInterface> keyWordObserver);

    void removeKeyWordObserver(std::shared_ptr<avsCommon::sdkInterfaces::KeyWordObserverInterface> keyWordObserver);

    void addKeyWordDetectorStateObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::KeyWordDetectorStateObserverInterface> keyWordDetectorStateObserver);

    void removeKeyWordDetectorStateObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::KeyWordDetectorStateObserverInterface> keyWordDetectorStateObserver);

    virtual ~AbstractKeywordDetector() = default;

protected:
    AbstractKeywordDetector(
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::KeyWordObserverInterface>> keyWordObservers =
            std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::KeyWordObserverInterface>>(),
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::KeyWordDetectorStateObserverInterface>>
            keyWordDetectorStateObservers =
                std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::KeyWordDetectorStateObserverInterface>>(),
        bool supportsDavs = false);

    AbstractKeywordDetector(
        std::shared_ptr<acsdkKWDInterfaces::KeywordNotifierInterface> keywordNotifier,
        std::shared_ptr<acsdkKWDInterfaces::KeywordDetectorStateNotifierInterface> keyWordDetectorStateNotifier,
        bool supportsDavs = false);

    void notifyKeyWordObservers(
        std::shared_ptr<avsCommon::avs::AudioInputStream> stream,
        std::string keyword,
        avsCommon::avs::AudioInputStream::Index beginIndex,
        avsCommon::avs::AudioInputStream::Index endIndex,
        std::shared_ptr<const std::vector<char>> KWDMetadata = nullptr) const;

    void notifyKeyWordDetectorStateObservers(
        avsCommon::sdkInterfaces::KeyWordDetectorStateObserverInterface::KeyWordDetectorState state);

    ssize_t readFromStream(
        std::shared_ptr<avsCommon::avs::AudioInputStream::Reader> reader,
        std::shared_ptr<avsCommon::avs::AudioInputStream> stream,
        void* buf,
        size_t nWords,
        std::chrono::milliseconds timeout,
        bool* errorOccurred);

    static bool isByteswappingRequired(avsCommon::utils::AudioFormat audioFormat);

    bool isDavsSupported();

private:
    std::shared_ptr<acsdkKWDInterfaces::KeywordNotifierInterface> m_keywordNotifier;

    std::shared_ptr<acsdkKWDInterfaces::KeywordDetectorStateNotifierInterface> m_keywordDetectorStateNotifier;

    avsCommon::sdkInterfaces::KeyWordDetectorStateObserverInterface::KeyWordDetectorState m_detectorState;

    mutable std::mutex m_detectorStateMutex;

    bool m_supportsDavs;
};

}  // namespace acsdkKWDImplementations
}  // namespace alexaClientSDK

#endif  // ACSDKKWDIMPLEMENTATIONS_ABSTRACTKEYWORDDETECTOR_H_