TestDirectiveHandler.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_INTEGRATION_INCLUDE_INTEGRATION_TESTDIRECTIVEHANDLER_H_
#define ALEXA_CLIENT_SDK_INTEGRATION_INCLUDE_INTEGRATION_TESTDIRECTIVEHANDLER_H_
 
#include <condition_variable>
#include <string>
#include <future>
#include <fstream>
#include <chrono>
#include <deque>
#include <mutex>
#include <unordered_map>
 
#include "AVSCommon/SDKInterfaces/DirectiveHandlerInterface.h"
#include "AVSCommon/AVS/Attachment/AttachmentManager.h"
#include "AVSCommon/Utils/JSON/JSONUtils.h"
 
using namespace alexaClientSDK::avsCommon;
 
namespace alexaClientSDK {
namespace integration {
namespace test {
 
class TestDirectiveHandler : public avsCommon::sdkInterfaces::DirectiveHandlerInterface {
public:
    TestDirectiveHandler(avsCommon::avs::DirectiveHandlerConfiguration config);
 
    void handleDirectiveImmediately(std::shared_ptr<avsCommon::avs::AVSDirective> directive) override;
 
    void preHandleDirective(
        std::shared_ptr<avsCommon::avs::AVSDirective> directive,
        std::unique_ptr<avsCommon::sdkInterfaces::DirectiveHandlerResultInterface> result) override;
 
    bool handleDirective(const std::string& messageId) override;
 
    void cancelDirective(const std::string& messageId) override;
 
    avsCommon::avs::DirectiveHandlerConfiguration getConfiguration() const override;
 
    void onDeregistered() override;
 
    class DirectiveParams {
    public:
        DirectiveParams();
 
        bool isUnset() const {
            return Type::UNSET == type;
        }
 
        bool isHandleImmediately() const {
            return Type::HANDLE_IMMEDIATELY == type;
        }
 
        bool isPreHandle() const {
            return Type::PREHANDLE == type;
        }
 
        bool isHandle() const {
            return Type::HANDLE == type;
        }
 
        bool isCancel() const {
            return Type::CANCEL == type;
        }
 
        bool isTimeout() const {
            return Type::TIMEOUT == type;
        }
 
        // Enum for the way the directive was passed to DirectiveHandler.
        enum class Type {
            // Not yet set.
            UNSET,
            // Set when handleDirectiveImmediately is called.
            HANDLE_IMMEDIATELY,
            // Set when preHandleDirective is called.
            PREHANDLE,
            // Set when handleDirective is called.
            HANDLE,
            // Set when cancelDirective is called.
            CANCEL,
            // Set when waitForNext times out waiting for a directive.
            TIMEOUT
        };
 
        // Type of how the directive was passed to DirectiveHandler.
        Type type;
        // AVSDirective passed from the Directive Sequencer to the DirectiveHandler.
        std::shared_ptr<avsCommon::avs::AVSDirective> directive;
        // DirectiveHandlerResult to inform the Directive Sequencer a directive has either successfully or
        // unsuccessfully handled.
        std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerResultInterface> result;
    };
 
    DirectiveParams waitForNext(const std::chrono::seconds duration);
 
private:
    std::mutex m_mutex;
    std::condition_variable m_wakeTrigger;
    std::deque<DirectiveParams> m_queue;
    std::unordered_map<std::string, std::shared_ptr<avsCommon::sdkInterfaces::DirectiveHandlerResultInterface>>
        m_results;
    std::unordered_map<std::string, std::shared_ptr<avsCommon::avs::AVSDirective>> m_directives;
    avsCommon::avs::DirectiveHandlerConfiguration m_configuration;
};
}  // namespace test
}  // namespace integration
}  // namespace alexaClientSDK
 
#endif  // ALEXA_CLIENT_SDK_INTEGRATION_INCLUDE_INTEGRATION_TESTDIRECTIVEHANDLER_H_