libsoundmanager.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 <libsoundmanager.hpp>

#define ELOG(args,...) _ELOG(__FUNCTION__,__LINE__,args,##__VA_ARGS__)
#ifdef DEBUGMODE
 #define DLOG(args,...) _DLOG(__FUNCTION__,__LINE__,args,##__VA_ARGS__)
#else
 #define DLOG(args,...)
#endif
static void _DLOG(const char* func, const int line, const char* log, ...);
static void _ELOG(const char* func, const int line, const char* log, ...);

using namespace std;

static bool has_verb(const std::string& verb);
static const char API[] = "soundmanager";
static int eventIndent(const string& event);

static const std::vector<std::string> api_list{
    std::string("connect"),
    std::string("disconnect"),
    std::string("setVolume"),
    std::string("volumeStep"),
    std::string("setSinkMuteState"),
    std::string("getListMainConnections"),
    std::string("ackConnect"),
    std::string("ackDisconnect"),
    std::string("ackSetSourceState"),    
    std::string("registerSource"),
    std::string("deregisterSource"),
    std::string("subscribe"),
    std::string("unsubscribe")
};

static const std::vector<std::string> event_list{
    std::string("asyncSetSourceState"),
    std::string("newMainConnection"),
    std::string("volumeChanged"),
    std::string("removedMainConnection"),
    std::string("sinkMuteStateChanged"),
    std::string("mainConnectionStateChanged"),
    std::string("setRoutingReady"),
    std::string("setRoutingRundown"),
    std::string("asyncConnect")
};

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

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

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

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

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

LibSoundmanager::LibSoundmanager()
{
}

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


int LibSoundmanager::init(int port, const string& token)
{
    int ret;
    if(port > 0 && token.size() > 0)
    {
        mport = port;
        mtoken = token;
    }
    else
    {
        ELOG("port and token should be > 0, Initial port and token uses.");
        return -1;
    }

    ret = initialize_websocket();
    if(ret != 0 )
    {
        ELOG("Failed to initialize websocket");
        return -1;
    }
    ret = init_event();
    if(ret != 0 )
    {
        ELOG("Failed to initialize websocket");
        return -1;
    }
    if(ret == -1){
        ELOG("Failed to create thread");
        return -1;
    }
    return 0;
}

int LibSoundmanager::initialize_websocket()
{
    mploop = NULL;
    onEvent = nullptr;
    onReply = nullptr;
    int ret = sd_event_default(&mploop);
    if(ret < 0)
    {
        ELOG("Failed to create event loop");
        goto END;
    }
    /* Initialize interface from websocket */
    {
    minterface.on_hangup = _on_hangup_static;
    minterface.on_call = _on_call_static;
    minterface.on_event = _on_event_static;
    string muri = "ws://localhost:" + to_string(mport) + "/api?token=" + mtoken;
    sp_websock = afb_ws_client_connect_wsj1(mploop, muri.c_str(), &minterface, this);
    }
    if(sp_websock == NULL)
    {
        ELOG("Failed to create websocket connection");
        goto END;
    }

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

int LibSoundmanager::init_event(){
    /* subscribe most important event for sound right */
    return subscribe(string("asyncSetSourceState"));
}

void LibSoundmanager::register_callback(
    void (*event_cb)(const 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;
}

void LibSoundmanager::register_callback(
    void (*reply_cb)(struct json_object* reply_contents),
    void (*hangup_cb)(void))
{
    onReply = reply_cb;
    onHangup = hangup_cb;
}

int LibSoundmanager::registerSource(const string& sourceName)
{
    if(!sp_websock)
    {
        return -1;
    }
    struct json_object* j_obj = json_object_new_object();
    struct json_object* jsn = json_object_new_string(sourceName.c_str());
    json_object_object_add(j_obj, "appname", jsn);
    return this->call(__FUNCTION__, j_obj);
}

int LibSoundmanager::connect(int sourceID, int sinkID)
{
    if(!sp_websock)
    {
        return -1;
    }
    struct json_object* j_obj = json_object_new_object();
    struct json_object* jsource = json_object_new_int(sourceID);
    struct json_object* jsink = json_object_new_int(sinkID);
    json_object_object_add(j_obj, "sourceID", jsource);
    json_object_object_add(j_obj, "sinkID", jsink);
    return this->call(__FUNCTION__, j_obj);
}

int LibSoundmanager::connect(int sourceID, const string& sinkName)
{
    if(!sp_websock)
    {
        return -1;
    }
    struct json_object* j_obj = json_object_new_object();
    struct json_object* jsource = json_object_new_int(sourceID);
    //struct json_object* jsink = json_object_new_int(1);
    struct json_object* jsink = json_object_new_string(sinkName.c_str());
    json_object_object_add(j_obj, "sourceID", jsource);
    json_object_object_add(j_obj, "sinkID", jsink);
    return this->call(__FUNCTION__, j_obj);
}

int LibSoundmanager::disconnect(int connectionID)
{
    if(!sp_websock)
    {
        return -1;
    }
    struct json_object* j_obj = json_object_new_object();
    struct json_object* jconnection = json_object_new_int(connectionID);
    json_object_object_add(j_obj, "mainConnectionID", jconnection);
    return this->call(__FUNCTION__, j_obj);
}

int LibSoundmanager::ackSetSourceState(int handle, int error)
{
    if(!sp_websock)
    {
        return -1;
    }
    struct json_object* j_obj = json_object_new_object();
    struct json_object* jhandle = json_object_new_int(handle);
    struct json_object* jerrno = json_object_new_int(error);
    json_object_object_add(j_obj, "handle", jhandle);
    json_object_object_add(j_obj, "error", jerrno);
    return this->call(__FUNCTION__, j_obj);
}

int LibSoundmanager::call(const string& verb, struct json_object* arg)
{
    int ret;
    if(!sp_websock)
    {
        return -1;
    }
    if (!has_verb(verb))
    {
        ELOG("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) {
        ELOG("Failed to call verb:%s",verb.c_str());
    }
    return ret;
}

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

int LibSoundmanager::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) {
        ELOG("Failed to call verb:%s",__FUNCTION__);
    }
    return ret;
}

int LibSoundmanager::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) {
        ELOG("Failed to call verb:%s",__FUNCTION__);
    }
    return ret;
}

void LibSoundmanager::set_event_handler(enum EventType_SM et, handler_fun f)
{
    if (et > 1 && et < NumItems) {
        this->handlers[et] = std::move(f);
    }
}


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

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

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

/*
* event is like "soundmanager/newMainConnection"
* msg is like {"event":"soundmanager\/newMainConnection","data":{"mainConnectionID":3,"sourceID":101,"sinkID":100,"delay":0,"connectionState":4},"jtype":"afb-event"})}
*               ^key^   ^^^^^^^^^^^^ value ^^^^^^^^^^^^
* so you can get 
    event name : struct json_object obj = json_object_object_get(msg,"event")
*/ 
void LibSoundmanager::on_event(void *closure, const char *event, struct afb_wsj1_msg *msg)
{
    /* check event is for us */
    string ev = string(event);
    if (ev.find(API) == string::npos) {
        /* It's not us */
        return;
    }
    struct json_object* ev_contents = afb_wsj1_msg_object_j(msg);
    if(onEvent != nullptr)
    {
        onEvent(ev, ev_contents);
    }
    else{}

    dispatch_event(ev, ev_contents);
    
    json_object_put(ev_contents);
}

void LibSoundmanager::on_reply(void *closure, struct afb_wsj1_msg *msg)
{
    struct json_object* reply = afb_wsj1_msg_object_j(msg);
    /*struct json_object *json_data = json_object_object_get(reply, "response");
    struct json_object *jverb = json_object_object_get(json_data, "verb");
    const char* cverb = json_object_get_string(jverb);
    DLOG("cverb is %s",cverb);
    string verb = string(cverb);
    DLOG("verb is %s",verb.c_str());
    
    if(verb == "registerSource"){
        struct json_object *jsourceID = json_object_object_get(json_data, "sourceID");
        int sourceID = json_object_get_int(jsourceID);
        msourceIDs.push_back(sourceID);
        DLOG("my sourceID is created: %d", sourceID);
    }*/
    if(onReply != nullptr)
    {
        onReply(reply);
    }
    json_object_put(reply); 
}

int LibSoundmanager::dispatch_event(const string &event , json_object* event_contents){
    //dipatch event
    EventType_SM x;

    if(event.find(event_list[0].c_str())){
        x = Event_AsyncSetSourceState;
    }
    else{
        return -1;
    }
    auto i = this->handlers.find(x);
    if(i != handlers.end()){
        i->second(event_contents);
        return 0;
    }
    return -1;
}

/* Internal Function in libsoundmanager */

static void _ELOG(const char* func, const int line, const char* log, ...)
{
    char *message;
    va_list args;
    va_start(args, log);
    if (log == NULL || vasprintf(&message, log, args) < 0)
        message = NULL;
    cout << "[ERROR: soundmanager]" << func << "(" << line << "):" << message << endl; 
    va_end(args);
    free(message);
}

static void _DLOG(const char* func, const int line, const char* log, ...)
{
    char *message;
    va_list args;
    va_start(args, log);
    if (log == NULL || vasprintf(&message, log, args) < 0)
        message = NULL;
    cout << "[DEBUG: soundmanager]" << func << "(" << line << "):" << message << endl; 
    va_end(args);
    free(message);
}

static bool has_verb(const string& verb)
{
    if(find(api_list.begin(), api_list.end(), verb) != api_list.end())
        return true;
    else
        return false;
}