diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/CMakeLists.txt | 50 | ||||
| -rw-r--r-- | src/libsoundmanager.cpp | 641 | ||||
| -rw-r--r-- | src/libsoundmanager.hpp | 92 |
3 files changed, 783 insertions, 0 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..1a34347 --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,50 @@ +# +# 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. +# + + +cmake_minimum_required(VERSION 2.8) + +set(TARGET_LIBSM soundmanager) +add_definitions("-std=c++11") + +pkg_check_modules(libsm_depends json-c libafbwsc libsystemd) +set(libsm_sources libsoundmanager.cpp) + +link_libraries(-Wl,--as-needed -Wl,--gc-sections -Wl,--no-undefined) + +add_library(${TARGET_LIBSM} SHARED ${libsm_sources}) +target_compile_options(${TARGET_LIBSM} PUBLIC ${libsm_depends_CFLAGS}) + +if(DEFINED DEBUGMODE) + target_compile_options(${TARGET_LIBSM} PRIVATE -g -O0) +else(DEFINED DEBUGMODE) + target_compile_options(${TARGET_LIBSM} PRIVATE -g -O2) +endif(DEFINED DEBUGMODE) + +include_directories(${TARGET_LIBSM} ${libsm_depends_INCLUDE_DIRS}) +target_link_libraries(${TARGET_LIBSM} afbwsc ${link_libraries} ${libsm_depends_LIBRARIES}) + +if(DEFINED CMAKE_INSTALL_LIBDIR) + INSTALL(TARGETS ${TARGET_LIBSM} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) +endif(DEFINED CMAKE_INSTALL_LIBDIR) +if(DEFINED CMAKE_INSTALL_INCLUDEDIR) + INSTALL(FILES libsoundmanager.hpp DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) +endif(DEFINED CMAKE_INSTALL_INCLUDEDIR) + +##################### +#add_subdirectory(test) + diff --git a/src/libsoundmanager.cpp b/src/libsoundmanager.cpp new file mode 100644 index 0000000..45b7858 --- /dev/null +++ b/src/libsoundmanager.cpp @@ -0,0 +1,641 @@ +/* + * 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 "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("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); +} + +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 + * + * #### Return + * Returns 0 on success or -1 in case of transmission 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; + } + 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 + * - hangup_cb [in] : This argument should be specified to the hangup callback for call function. nullptr is defaulty set. + * + * #### Return + * + * #### 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; +} + +/** + * This function is overload of register_callback. This registers callback function for reply/event message from sound manager + * + * #### Parameters + * - reply_cb [in] : This argument should be specified to the reply callback for call function + * - hangup_cb [in] : This argument should be specified to the hangup callback for call function. nullptr is defaulty set. + * + * #### Return + * + * #### Note + * Event callback is invoked by sound manager for event you subscribed. + * This function for convinience for user uses set_event_handler + * If you would like to get event, please call subscribe function before/after this function + */ +void LibSoundmanager::register_callback( + void (*reply_cb)(struct json_object* reply_contents), + void (*hangup_cb)(void)) +{ + onReply = reply_cb; + onHangup = hangup_cb; +} + +/** + * 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") + * + * #### Return + * - Returns 0 on success or -1 in case of transmission 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 + * + * #### Return + * - Returns 0 on success or -1 in case of transmission error. + * + * #### Note + * This function must be called to get source right + * connectionID is returned by reply event + * + */ +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 + * This function is overload of connect + * Instead of sinkID as the number, abstract sinkName will be supported. + * For now, "default" is only supported + * + * #### 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 transmission error. + * + * #### Note + * For now, aliase(hardware abstraction) like "DriverZone:Speaker" is under hard consideration + * Just "default" is usable. + * + */ +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 + * + * #### Return + * - Returns 0 on success or -1 in case of transmission 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 + * + * #### Return + * - Returns 0 on success or -1 in case of transmission 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 + * + * #### Return + * - Returns 0 on success or -1 in case of transmission 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 + * + * #### Return + * - Returns 0 on success or -1 in case of transmission 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 + * + * #### Return + * - Returns 0 on success or -1 in case of transmission 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 + * + * #### Return + * - Returns 0 on success or -1 in case of transmission 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 + * + * #### Return + * - Returns 0 on success or -1 in case of transmission 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_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; + } + 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; +} diff --git a/src/libsoundmanager.hpp b/src/libsoundmanager.hpp new file mode 100644 index 0000000..daa4695 --- /dev/null +++ b/src/libsoundmanager.hpp @@ -0,0 +1,92 @@ +/* + * 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. + */ + +#ifndef LIBSOUNDMANAGER_H +#define LIBSOUNDMANAGER_H +#include <vector> +#include <map> +#include <string> +#include <functional> +#include <json-c/json.h> +#include <systemd/sd-event.h> +extern "C" +{ +#include <afb/afb-wsj1.h> +#include <afb/afb-ws-client.h> +} + +class LibSoundmanager +{ +public: + LibSoundmanager(); + ~LibSoundmanager(); + LibSoundmanager(const LibSoundmanager &) = delete; + LibSoundmanager &operator=(const LibSoundmanager &) = delete; + int init(int port, const std::string& token); + + using handler_fun = std::function<void(struct json_object*)>; + + enum EventType_SM { + Event_AsyncSetSourceState = 1 /*arg key: {sourceID, handle, sourceState}*/ + }; + + /* Method */ + int registerSource(const std::string& sourceName); + int connect(int sourceID, int sinkID); + int connect(int sourceID, const std::string& sinkName); + int disconnect(int connectionID); + int ackSetSourceState(int handle, int error); + + int call(const std::string& verb, struct json_object* arg); + int call(const char* verb, struct json_object* arg); + int subscribe(const std::string& event_name); + int unsubscribe(const std::string& event_name); + void set_event_handler(enum EventType_SM et, handler_fun f); + void register_callback( + void (*event_cb)(const std::string& event, struct json_object* event_contents), + void (*reply_cb)(struct json_object* reply_contents), + void (*hangup_cb)(void) = nullptr); + void register_callback( + void (*reply_cb)(struct json_object* reply_contents), + void (*hangup_cb)(void) = nullptr); + +private: + int init_event(); + int initialize_websocket(); + int dispatch_event(const std::string& event, struct json_object* ev_contents); + + void (*onEvent)(const std::string& event, struct json_object* event_contents); + void (*onReply)(struct json_object* reply); + void (*onHangup)(void); + + struct afb_wsj1* sp_websock; + struct afb_wsj1_itf minterface; + sd_event* mploop; + int mport; + std::string mtoken; + std::vector<int> msourceIDs; + std::map<EventType_SM, handler_fun> handlers; + EventType_SM const NumItems = (EventType_SM)(Event_AsyncSetSourceState + 1); + +public: + /* Don't use/ Internal only */ + void on_hangup(void *closure, struct afb_wsj1 *wsj); + void on_call(void *closure, const char *api, const char *verb, struct afb_wsj1_msg *msg); + void on_event(void *closure, const char *event, struct afb_wsj1_msg *msg); + void on_reply(void *closure, struct afb_wsj1_msg *msg); +}; + +#endif /* LIBSOUNDMANAGER_H */ |