path: root/libsoundmanager/libsoundmanager.cpp

/*
 * 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 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("newMainConnection"),
    std::string("volumeChanged"),
	std::string("removedMainConnection"),
	std::string("sinkMuteStateChanged"),
	std::string("mainConnectionStateChanged"),
	std::string("setRoutingReady"),
	std::string("setRoutingRundown"),
	std::string("asyncConnect"),
	std::string("asyncSetSourceState")
};

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);
	}
}


/**
 * This function is initialization function
 * 
 * #### Parameters
 * - port  [in] : This argument should be specified to the port number to be used for websocket
 * - token [in] : This argument should be specified to the token to be used for websocket
 *
 * #### Rreturn
 * Returns 0 on success or -1 in case of error.
 *
 * #### Note
 *
 */
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;
	}
	ret = run_eventloop();
	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"));
}

/**
 * This function register callback function for reply/event message from sound manager
 * 
 * #### Parameters
 * - event_cb [in] : This argument should be specified to the callback for subscribed event
 * - reply_cb [in] : This argument should be specified to the reply callback for call function
 *
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * Event callback is invoked by sound manager for event you subscribed.
 * If you would like to get event, please call subscribe function before/after this function
 */
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::run_eventloop()
{
	if(mploop && sp_websock)
	{
		pthread_t thread_id;
	    int ret = pthread_create(&thread_id, NULL, event_loop_run, mploop);
		if(ret != 0)
		{
			ELOG("Cannot run eventloop due to error:%d", errno);
			return -1;
		}
		else
			return 0;
	}
	else
	{
		ELOG("Connecting is not established yet");
		return -1;
	}
}

/**
 * This function calls registerSource of Audio Manager via WebSocket
 * registerSource is registration as source for policy management
 * 
 * #### Parameters
 * - sourceName [in] : This argument should be specified to the source name (e.g. "MediaPlayer")
 *	
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * This function must be called to get source ID
 * mainConnectionID is returned by async reply function
 *
 */
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);
}

/**
 * This function calls connect of Audio Manager via WebSocket
 * connect is to get sound right
 * 
 * #### Parameters
 * - sourceID [in] : This argument should be specified to the sourceID as int. This parameter is returned value of registerSource
 * - sinkID   [in] : This argument should be specified to the sinkID as int. ID is specified by AudioManager
 *
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * This function must be called to get source right
 * connectionID is  
 *
 */
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);
}

/**
 * This function calls the connect of Audio Manager via WebSocket
 * 
 * #### Parameters
 * - sourceID   [in] : This argument should be specified to the sourceID as int. This parameter is returned value of registerSource
 * - sinkName   [in] : This argument should be specified to the sinkID as int. ID is aliased by SoundManager (e.g: "default")
 *	
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * For now, aliase(hardware abstraction) like "DriverZone:Speaker" is undier hard consideration
 * Just "default" is usable. "default" parameter is set by soundmanager
 *
 */
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);
}

/**
 * This function calls the disconnect of Audio Manager via WebSocket
 * 
 * #### Parameters
 * - connectionID  [in] : This parameter is returned value of connect
 *	
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * 
 *
 */
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);
}

/**
 * This function calls the ackSetSourceState of Audio Manager via WebSocket
 * 
 * #### Parameters
 * - sourceID  [in] : This parameter is returned value of ackSetSourceState
 * - handle    [in] : This parameter is returned value of ackSetSourceState
 * - errno     [in] : If you have some errors, input ohter than 0. 0 means acknowledge
 *	
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * This function must be called when application get asyncSetSourceState event
 * Input handle number attached in asyncSetSourceState and error number(0 is acknowledge)
 */
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);
}

/**
 * This function calls the API of Audio Manager via WebSocket
 * 
 * #### Parameters
 * - verb [in] : This argument should be specified to the API name (e.g. "connect")
 * - arg  [in] : This argument should be specified to the argument of API. And this argument expects JSON object
 *	
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * To call Audio Manager's APIs, the application should set its function name, arguments to JSON format.
 *
 */
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;
}

/**
 * This function calls the API of Audio Manager via WebSocket
 * This function is overload function of "call"
 * 
 * #### Parameters
 * - verb [in] : This argument should be specified to the API name (e.g. "connect")
 * - arg  [in] : This argument should be specified to the argument of API. And this argument expects JSON object
 *	
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * To call Audio Manager's APIs, the application should set its function name, arguments to JSON format.
 * 
 */
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;
}

/**
 * Register callback function for each event
 * 
 * #### Parameters
 * - event_name [in] : This argument should be specified to the event name
 *	
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * This function enables to get an event to your callback function. 
 * Regarding the list of event name, please refer to CommandSender API and RountingSender API.
 *
 */
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;
}

/**
 * Unregister callback function for each event
 * 
 * #### Parameters
 * - event_name [in] : This argument should be specified to the event name
 *	
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * This function disables to get an event to your callback function. 
 *
 */
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;
}

/**
 * This function calls the ackSetSourceState of Audio Manager via WebSocket
 * 
 * #### Parameters
 * - EventType_AsyncSetSourceState     [in] : This parameter is EventType of soundmanager
 * - handler_func  [in] : This parameter is callback function
 *	
 * #### Rreturn
 * - Returns 0 on success or -1 in case of error.
 *
 * #### Note
 * This function must be called when application get asyncSetSourceState event
 * Input handle number attached in asyncSetSourceState and error number(0 is acknowledge)
 */
void LibSoundmanager::set_event_handler(enum EventType_AsyncSetSourceState et, handler_asyncSetSourceState f)
{
	if (et >= 1 && et <= 3) {
		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);
	}
	
	if(ev.find("asyncSetSourceState") != string::npos){
		// check sourceID is indicated to me
		struct json_object *json_data, *jSourceID, *jsourceState, *jhandle;
		json_object_object_get_ex(ev_contents, "data", &json_data);
		json_object_object_get_ex(json_data, "sourceID", &jSourceID);
		int sourceID = json_object_get_int(jSourceID);		
        /* This is not supported yet because application may have some sourceID.
		   Application has to check sourceID
		if(find( msourceIDs.begin(),msourceIDs.end(), sourceID) != msourceIDs.end()){
			json_object_put(ev_contents);
			return;
		}*/
		json_object_object_get_ex(json_data, "sourceState", &jsourceState);		
		json_object_object_get_ex(json_data, "handle", &jhandle);		
		string sourceState = string(json_object_get_string(jsourceState));
		int handle = json_object_get_int(jhandle);
		dispatch_asyncSetSourceState(sourceID, handle, sourceState);
		json_object_put(json_data);
		json_object_put(jSourceID);
		json_object_put(jsourceState);
		json_object_put(jhandle);
	}
	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_asyncSetSourceState(int sourceID, int handle, const string& sourceState){
	//dipatch event
	EventType_AsyncSetSourceState x;
	if(sourceState == "on"){
		x = Event_AsyncSetSourceState_On;
	}else if(sourceState == "off"){
		x = Event_AsyncSetSourceState_Off;
	}else if(sourceState == "pause"){
		x = Event_AsyncSetSourceState_Pause;
	}
	auto i = this->handlers.find(x);
	if(i != handlers.end()){
		i->second(sourceID, handle);
		return 0;
	}
	else{
		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;
}