capability_interface.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2019 SK Telecom Co., Ltd. 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.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License 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 __NUGU_CAPABILITY_INTERFACE_H__
#define __NUGU_CAPABILITY_INTERFACE_H__
 
#include <functional>
#include <list>
#include <njson/njson.h>
#include <set>
#include <string>
 
#include <base/nugu_directive.h>
#include <clientkit/nugu_core_container_interface.hh>
#include <nugu.h>
 
namespace NuguClientKit {
 
typedef struct _DirectiveCancelPolicy {
    bool cancel_all; 
    std::set<std::string> dir_groups; 
} DirectiveCancelPolicy;
 
class NUGU_API ICapabilityInterface;
 
class NUGU_API ICapabilityListener {
public:
    virtual ~ICapabilityListener() = default;
 
    virtual void setCapabilityHandler(ICapabilityInterface* handler);
 
    virtual ICapabilityInterface* getCapabilityHandler();
};
 
class NUGU_API ICapabilityInterface {
public:
    enum class SuspendPolicy {
        STOP, 
        PAUSE 
    };
 
    using EventResultCallback = std::function<void(const std::string&, const std::string&, const std::string&, int, int)>;
 
public:
    virtual ~ICapabilityInterface() = default;
 
    virtual void setNuguCoreContainer(INuguCoreContainer* core_container) = 0;
 
    virtual void initialize() = 0;
 
    virtual void deInitialize() = 0;
 
    virtual void setSuspendPolicy(SuspendPolicy policy = SuspendPolicy::STOP) = 0;
 
    virtual void suspend() = 0;
 
    virtual void restore() = 0;
 
    virtual void addEventResultCallback(const std::string& ename, EventResultCallback callback) = 0;
 
    virtual void removeEventResultCallback(const std::string& ename) = 0;
 
    virtual void notifyEventResult(const std::string& event_desc) = 0;
 
    virtual void notifyEventResponse(const std::string& msg_id, const std::string& data, bool success) = 0;
 
    virtual std::string getName() = 0;
 
    virtual std::string getVersion() = 0;
 
    virtual void preprocessDirective(NuguDirective* ndir) = 0;
 
    virtual void cancelDirective(NuguDirective* ndir) = 0;
 
    virtual void processDirective(NuguDirective* ndir) = 0;
 
    virtual void updateInfoForContext(NJson::Value& ctx) = 0;
 
    virtual void updateCompactContext(NJson::Value& ctx) = 0;
 
    virtual bool receiveCommand(const std::string& from, const std::string& command, const std::string& param) = 0;
 
    virtual void receiveCommandAll(const std::string& command, const std::string& param) = 0;
 
    virtual bool getProperty(const std::string& property, std::string& value) = 0;
 
    virtual bool getProperties(const std::string& property, std::list<std::string>& values) = 0;
 
    virtual void setCapabilityListener(ICapabilityListener* clistener) = 0;
 
    virtual void setCancelPolicy(bool cancel_previous_dialog, DirectiveCancelPolicy&& cancel_policy = { true }) = 0;
};
 
} // NuguClientKit
 
#endif /* __NUGU_CAPABILITY_INTERFACE_H__ */