libhomescreen.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
 *
 * 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.
 */

#include <stdarg.h>
#include <sys/socket.h>
#include <iostream>
#include <algorithm>
#include <thread>
#include <errno.h>
#include <cassert>
#include <cctype>
#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <libhomescreen.hpp>
#include "hmi-debug.h"

using namespace std;

static bool has_verb(const string& verb);
static const char API[] = "homescreen";

const std::vector<std::string> LibHomeScreen::api_list {
    std::string("ping"), // debug do not use
    std::string("tap_shortcut"), // HomeScreen Application only
    std::string("on_screen_message"),
    std::string("on_screen_reply"),
    std::string("subscribe"),
    std::string("unsubscribe")
};

const std::vector<std::string> LibHomeScreen::event_list {
    std::string("tap_shortcut"),
    std::string("on_screen_message"),
    std::string("on_screen_reply"),
    std::string("none")
};


static void _on_hangup_static(void *closure, struct afb_wsj1 *wsj)
{
    static_cast<LibHomeScreen*>(closure)->on_hangup(NULL,wsj);
}

static void _on_call_static(void *closure, const char *api, const char *verb, struct afb_wsj1_msg *msg)
{
    /* LibHomeScreen is not called from other process */
}

static void _on_event_static(void* closure, const char* event, struct afb_wsj1_msg *msg)
{
    static_cast<LibHomeScreen*>(closure)->on_event(NULL,event,msg);
}

static void _on_reply_static(void *closure, struct afb_wsj1_msg *msg)
{
    static_cast<LibHomeScreen*>(closure)->on_reply(NULL,msg);
}


LibHomeScreen::LibHomeScreen()
{
}

LibHomeScreen::~LibHomeScreen()
{
    if(mploop)
    {
        sd_event_unref(mploop);
    }
    if(sp_websock != NULL)
    {
        afb_wsj1_unref(sp_websock);
    }
}

int LibHomeScreen::init(const int port, const string& token)
{
    int ret = 0;
    if(port > 0 && token.size() > 0)
    {
        mport = port;
        mtoken = token;
    }
    else
    {
        HMI_ERROR("libhomescreen","port and token should be > 0, Initial port and token uses.");
    }

    ret = initialize_websocket();
    if(ret != 0 )
    {
        HMI_ERROR("libhomescreen","Failed to initialize websocket");
    }
    else{
        HMI_DEBUG("libhomescreen","Initialized");
    }

    return ret;
}

void LibHomeScreen::registerCallback(
    void (*event_cb)(const std::string& event, struct json_object* event_contents),
    void (*reply_cb)(struct json_object* reply_contents),
    void (*hangup_cb)(void))
{
    onEvent = event_cb;
    onReply = reply_cb;
    onHangup = hangup_cb;
}

int LibHomeScreen::initialize_websocket()
{
    mploop = NULL;
    onEvent = nullptr;
    onReply = nullptr;
    int ret = sd_event_default(&mploop);
    if(ret < 0)
    {
        HMI_ERROR("libhomescreen","Failed to create event loop");
        goto END;
    }

    /* Initialize interface from websocket */
    minterface.on_hangup = _on_hangup_static;
    minterface.on_call = _on_call_static; /* Is this necessary? */
    minterface.on_event = _on_event_static;
    muri += "ws://localhost:" + to_string(mport) + "/api?token=" + mtoken; /*To be modified*/
    sp_websock = afb_ws_client_connect_wsj1(mploop, muri.c_str(), &minterface, this);
    if(sp_websock == NULL)
    {
        HMI_ERROR("libhomescreen","Failed to create websocket connection");
        goto END;
    }

    /* creates the evsrc */
    //ret = sd_event_add_io(mploop,&mevent_src, sp_websock->fd, EPOLLIN, event_callback, NULL);

    return 0;
END:
    if(mploop)
    {
        sd_event_unref(mploop);
    }
    return -1;
}

static void *event_loop_run(void *args)
{
    struct sd_event* loop = (struct sd_event*)(args);
    HMI_DEBUG("libhomescreen","start eventloop");
    for(;;)
        sd_event_run(loop, 30000000);
}

int LibHomeScreen::tapShortcut(const char* application_name)
{
    if(!sp_websock)
    {
        return -1;
    }

    struct json_object* j_obj = json_object_new_object();
    struct json_object* val = json_object_new_string(application_name);
    json_object_object_add(j_obj, "application_name", val);
    return this->call("tap_shortcut", j_obj);
}

int LibHomeScreen::onScreenMessage(const char* display_message)
{
    if(!sp_websock)
    {
        return -1;
    }

    struct json_object* j_obj = json_object_new_object();
    struct json_object* val = json_object_new_string(display_message);
    json_object_object_add(j_obj, "display_message", val);
    return this->call("on_screen_message", j_obj);
}

int LibHomeScreen::onScreenReply(const char* reply_message)
{
    if(!sp_websock)
    {
        return -1;
    }

    struct json_object* j_obj = json_object_new_object();
    struct json_object* val = json_object_new_string(reply_message);
    json_object_object_add(j_obj, "reply_message", val);
    return this->call("on_screen_reply", j_obj);
}

void LibHomeScreen::set_event_handler(enum EventType et, handler_func f)
{
    if (et >= 1 && et <= 3) {
        switch (et) {
            case Event_TapShortcut:
                this->subscribe(LibHomeScreen::event_list[0]);
                break;
            case Event_OnScreenMessage:
                this->subscribe(LibHomeScreen::event_list[1]);
                break;
            case Event_OnScreenReply:
                this->subscribe(LibHomeScreen::event_list[2]);
                break;
        }

        this->handlers[et] = std::move(f);
    }
}

int LibHomeScreen::call(const string& verb, struct json_object* arg)
{
    int ret;
    if(!sp_websock)
    {
        return -1;
    }
    if (!has_verb(verb))
    {
        HMI_ERROR("libhomescreen","verb doesn't exit");
        return -1;
    }
    ret = afb_wsj1_call_j(sp_websock, API, verb.c_str(), arg, _on_reply_static, this);
    if (ret < 0) {
        HMI_ERROR("libhomescreen","Failed to call verb:%s",verb.c_str());
    }
    return ret;
}

int LibHomeScreen::call(const char* verb, struct json_object* arg)
{
    int ret;
    if(!sp_websock)
    {
        return -1;
    }
    if (!has_verb(string(verb)))
    {
        HMI_ERROR("libhomescreen","verb doesn't exit");
        return -1;
    }
    ret = afb_wsj1_call_j(sp_websock, API, verb, arg, _on_reply_static, this);
    if (ret < 0) {
        HMI_ERROR("libhomescreen","Failed to call verb:%s",verb);
    }
    return ret;
}

int LibHomeScreen::subscribe(const string& event_name)
{
    if(!sp_websock)
    {
        return -1;
    }
    struct json_object* j_obj = json_object_new_object();
    json_object_object_add(j_obj, "event", json_object_new_string(event_name.c_str()));

    int ret = afb_wsj1_call_j(sp_websock, API, "subscribe", j_obj, _on_reply_static, this);
    if (ret < 0) {
        HMI_ERROR("libhomescreen","Failed to call verb:%s",__FUNCTION__);
    }
    return ret;
}

int LibHomeScreen::unsubscribe(const string& event_name)
{
    if(!sp_websock)
    {
        return -1;
    }
    struct json_object* j_obj = json_object_new_object();
    json_object_object_add(j_obj, "event", json_object_new_string(event_name.c_str()));

    int ret = afb_wsj1_call_j(sp_websock, API, "unsubscribe", j_obj, _on_reply_static, this);
    if (ret < 0) {
        HMI_ERROR("libhomescreen","Failed to call verb:%s",__FUNCTION__);
    }
    return ret;
}

/************* Callback Function *************/

void LibHomeScreen::on_hangup(void *closure, struct afb_wsj1 *wsj)
{
    HMI_DEBUG("libhomescreen","%s called", __FUNCTION__);
    if(onHangup != nullptr)
    {
        onHangup();
    }
}

void LibHomeScreen::on_call(void *closure, const char *api, const char *verb, struct afb_wsj1_msg *msg)
{
}

/*
* event is like "homescreen/tap_shortcut"
* msg is like {"event":"homescreen\/tap_shortcut","data":{"application_name":"hoge"},"jtype":"afb-event"}
* so you can get
    event name : struct json_object obj = json_object_object_get(msg,"event")
*/
void LibHomeScreen::on_event(void *closure, const char *event, struct afb_wsj1_msg *msg)
{
    HMI_DEBUG("libhomescreen","event: (%s) msg: (%s).", event, afb_wsj1_msg_object_s(msg));

    if (strstr(event, API) == NULL) {
        return;
    }

    struct json_object* ev_contents = afb_wsj1_msg_object_j(msg);
    struct json_object *json_data = json_object_object_get(ev_contents, "data");

    if(onEvent != nullptr)
    {
        const string ev(event);
        onEvent(ev, ev_contents);
    }

    const char* event_only = strchr(event, '/');
    if (event_only != nullptr) {
        event_only = event_only + 1;
    }

    if (strcasecmp(event_only, LibHomeScreen::event_list[0].c_str()) == 0) {
        auto i = this->handlers.find(Event_TapShortcut);
        if ( i != this->handlers.end() ) {
            i->second(json_data);
        }
    }
    else if (strcasecmp(event_only, LibHomeScreen::event_list[1].c_str()) == 0) {
        auto i = this->handlers.find(Event_OnScreenMessage);
        if ( i != this->handlers.end() ) {
            i->second(json_data);
        }
    }
    else if (strcasecmp(event_only, LibHomeScreen::event_list[2].c_str()) == 0) {
        auto i = this->handlers.find(Event_OnScreenReply);
        if ( i != this->handlers.end() ) {
            i->second(json_data);
        }
    }

    json_object_put(ev_contents);
}

void LibHomeScreen::on_reply(void *closure, struct afb_wsj1_msg *msg)
{
    HMI_DEBUG("libhomescreen","msg: (%s)", afb_wsj1_msg_object_s(msg));
    if(onReply != nullptr)
    {
        struct json_object* reply = afb_wsj1_msg_object_j(msg);
        onReply(reply);

        json_object_put(reply);
    }
}

static bool has_verb(const string& verb)
{
    HMI_DEBUG("libhomescreen","verb is %s", verb.c_str());
    if(find(LibHomeScreen::api_list.begin(), LibHomeScreen::api_list.end(), verb) != LibHomeScreen::api_list.end())
        return true;
    else
        return false;
}