DirectiveProcessor.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_ADSL_INCLUDE_ADSL_DIRECTIVEPROCESSOR_H_
#define ALEXA_CLIENT_SDK_ADSL_INCLUDE_ADSL_DIRECTIVEPROCESSOR_H_

#include <array>
#include <condition_variable>
#include <deque>
#include <functional>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <thread>
#include <unordered_map>

#include <AVSCommon/AVS/AVSDirective.h>
#include <AVSCommon/SDKInterfaces/DirectiveHandlerInterface.h>
#include <AVSCommon/Utils/Threading/ConditionVariableWrapper.h>
#include <AVSCommon/Utils/Power/PowerResource.h>

#include "ADSL/DirectiveRouter.h"

namespace alexaClientSDK {
namespace adsl {

class DirectiveProcessor {
public:
    DirectiveProcessor(DirectiveRouter* directiveRouter);

    ~DirectiveProcessor();

    void setDialogRequestId(const std::string& dialogRequestId);

    std::string getDialogRequestId();

    bool onDirective(std::shared_ptr<avsCommon::avs::AVSDirective> directive);

    void shutdown();

    void disable();

    bool enable();

private:
    using ProcessorHandle = unsigned int;

    using DirectiveAndPolicy = std::pair<std::shared_ptr<avsCommon::avs::AVSDirective>, avsCommon::avs::BlockingPolicy>;

    class DirectiveHandlerResult : public avsCommon::sdkInterfaces::DirectiveHandlerResultInterface {
    public:
        DirectiveHandlerResult(
            ProcessorHandle processorHandle,
            std::shared_ptr<avsCommon::avs::AVSDirective> directive);

        void setCompleted() override;

        void setFailed(const std::string& description) override;

    private:
        ProcessorHandle m_processorHandle;

        std::shared_ptr<avsCommon::avs::AVSDirective> m_directive;
    };

    void onHandlingCompleted(std::shared_ptr<avsCommon::avs::AVSDirective> directive);

    void onHandlingFailed(std::shared_ptr<avsCommon::avs::AVSDirective> directive, const std::string& description);

    void removeDirectiveLocked(std::shared_ptr<avsCommon::avs::AVSDirective> directive);

    void processingLoop();

    bool processCancelingQueueLocked(std::unique_lock<std::mutex>& lock);

    bool handleQueuedDirectivesLocked(std::unique_lock<std::mutex>& lock);

    void setDialogRequestIdLocked(const std::string& dialogRequestId);

    void scrubDialogRequestIdLocked(const std::string& dialogRequestId);

    void queueAllDirectivesForCancellationLocked();

    void setDirectiveBeingHandledLocked(
        const std::shared_ptr<avsCommon::avs::AVSDirective>& directive,
        const avsCommon::avs::BlockingPolicy policy);

    void clearDirectiveBeingHandledLocked(const avsCommon::avs::BlockingPolicy policy);

    std::set<std::shared_ptr<avsCommon::avs::AVSDirective>> clearDirectiveBeingHandledLocked(
        std::function<bool(const std::shared_ptr<avsCommon::avs::AVSDirective>&)> shouldClear);

    std::deque<DirectiveAndPolicy>::iterator getNextUnblockedDirectiveLocked();

    int m_handle;

    std::mutex m_mutex;

    DirectiveRouter* m_directiveRouter;

    bool m_isShuttingDown;

    bool m_isEnabled;

    std::string m_dialogRequestId;

    std::deque<std::shared_ptr<avsCommon::avs::AVSDirective>> m_cancelingQueue;

    std::shared_ptr<avsCommon::avs::AVSDirective> m_directiveBeingPreHandled;

    std::deque<DirectiveAndPolicy> m_handlingQueue;

    avsCommon::utils::threading::ConditionVariableWrapper m_wakeProcessingLoop;

    std::thread m_processingThread;

    std::mutex m_onDirectiveMutex;

    static std::mutex m_handleMapMutex;

    static std::unordered_map<ProcessorHandle, DirectiveProcessor*> m_handleMap;

    static ProcessorHandle m_nextProcessorHandle;

    std::array<std::shared_ptr<avsCommon::avs::AVSDirective>, avsCommon::avs::BlockingPolicy::Medium::COUNT>
        m_directivesBeingHandled;

    std::shared_ptr<avsCommon::utils::power::PowerResource> m_powerResource;
};

}  // namespace adsl
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ADSL_INCLUDE_ADSL_DIRECTIVEPROCESSOR_H_