capability.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_H__
#define __NUGU_CAPABILITY_H__
 
#include <algorithm>
#include <memory>
#include <string>
#include <vector>
 
#include <base/nugu_event.h>
#include <base/nugu_network_manager.h>
#include <clientkit/capability_interface.hh>
 
namespace NuguClientKit {
 
class Capability;
 
class CapabilityEvent {
public:
    explicit CapabilityEvent(const std::string& name, Capability* cap);
    virtual ~CapabilityEvent();
 
    std::string getName();
 
    std::string getDialogRequestId();
 
    std::string getMessageId();
 
    void setDialogRequestId(const std::string& id);
 
    void setType(enum nugu_event_type type);
 
    void setMimeType(const std::string& type);
 
    void forceClose();
 
    void sendEvent(const std::string& context, const std::string& payload);
 
    void sendAttachmentEvent(bool is_end, size_t size, unsigned char* data);
 
private:
    struct Impl;
    std::unique_ptr<Impl> pimpl;
};
 
class Capability : virtual public ICapabilityInterface {
public:
    explicit Capability(const std::string& name, const std::string& ver = "1.0");
    virtual ~Capability();
 
    void setNuguCoreContainer(INuguCoreContainer* core_container) override;
 
    void initialize() override;
 
    void deInitialize() override;
 
    void setSuspendPolicy(SuspendPolicy policy = SuspendPolicy::STOP) override;
 
    void suspend() override;
 
    void restore() override;
 
    void addEventResultCallback(const std::string& ename, EventResultCallback callback) override;
 
    void removeEventResultCallback(const std::string& ename) override;
 
    void notifyEventResult(const std::string& event_desc) override;
 
    void notifyEventResponse(const std::string& msg_id, const std::string& data, bool success) override;
 
    void addReferrerEvents(const std::string& ename, const std::string& dname);
 
    void addBlockingPolicy(const std::string& dname, BlockingPolicy policy);
 
    std::string getReferrerDialogRequestId(const std::string& ename);
 
    void setReferrerDialogRequestId(const std::string& dname, const std::string& id);
 
    void setName(const std::string& name);
 
    std::string getName() override;
 
    void setVersion(const std::string& ver);
 
    std::string getVersion() override;
 
    std::string getPlayServiceIdInStackControl(const NJson::Value& playstack_control);
 
    std::string getPlayServiceIdInStackControl(const char* payload);
 
    InteractionMode getInteractionMode(const NJson::Value& interaction_control);
 
    void preprocessDirective(NuguDirective* ndir) override;
 
    void cancelDirective(NuguDirective* ndir) override;
 
    void processDirective(NuguDirective* ndir) override final;
 
    void destroyDirective(NuguDirective* ndir, bool is_cancel = false);
 
    NuguDirective* getNuguDirective();
 
    std::string sendEvent(const std::string& name, const std::string& context, const std::string& payload, EventResultCallback cb = nullptr);
 
    void sendEvent(CapabilityEvent* event, const std::string& context, const std::string& payload, EventResultCallback cb = nullptr);
 
    void sendAttachmentEvent(CapabilityEvent* event, bool is_end, size_t size, unsigned char* data);
 
    bool getProperty(const std::string& property, std::string& value) override;
 
    bool getProperties(const std::string& property, std::list<std::string>& values) override;
 
    void setCapabilityListener(ICapabilityListener* clistener) override;
 
    void setCancelPolicy(bool cancel_previous_dialog, DirectiveCancelPolicy&& cancel_policy = { true }) override;
 
    bool receiveCommand(const std::string& from, const std::string& command, const std::string& param) override;
 
    void receiveCommandAll(const std::string& command, const std::string& param) override;
 
    virtual void parsingDirective(const char* dname, const char* message);
 
    virtual std::string getContextInfo();
 
    virtual void updateCompactContext(NJson::Value& ctx) override;
 
    ICapabilityHelper* getCapabilityHelper();
 
protected:
    bool initialized = false;
 
    bool destroy_directive_by_agent = false;
 
    bool suspended = false;
 
    INuguCoreContainer* core_container = nullptr;
 
    ICapabilityHelper* capa_helper = nullptr;
 
    IPlaySyncManager* playsync_manager = nullptr;
 
    IFocusManager* focus_manager = nullptr;
 
    ISessionManager* session_manager = nullptr;
 
    IInteractionControlManager* interaction_control_manager = nullptr;
 
    IDirectiveSequencer* directive_sequencer = nullptr;
 
    IRoutineManager* routine_manager = nullptr;
 
    SuspendPolicy suspend_policy = SuspendPolicy::STOP;
 
private:
    struct Impl;
    std::unique_ptr<Impl> pimpl;
    std::map<std::string, EventResultCallback> event_result_cbs;
};
 
} // NuguClientKit
 
#endif