Sound Manager: SoundManagerBinding/soundmanager_binging/soundmanager.c Source 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.
  */

 #define _GNU_SOURCE
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <unistd.h>
 #include <json-c/json.h>
 //#include <search.h>
 #include <pthread.h>
 #include <afb/afb-binding.h>
 #include "sm-helper.h"
 #include <glib.h>
 #include "dbus/audio_manager_interface.h"

 #define AM_NAME "org.genivi.audiomanager"
 #define AM_CMD_PATH     "/org/genivi/audiomanager/commandinterface"
 #define AM_ROUTE_PATH   "/org/genivi/audiomanager/routinginterface"
 #define SOUND_MANAGER_NAME "org.soundmanager.genivi.routingsend"
 #define SOUND_MANAGER_PATH "org/soundmanager/genivi/routingsend"

 #define COMMAND_EVENT_NUM 10
 #define ROUTING_EVENT_NUM 10
 #define MAX_LEN_STR 100

 const static struct afb_binding_interface *afbitf;
 static AudiomanagerCommandinterface *am_cmd_bus;
 static AudiomanagerRoutinginterface *am_route_bus;
 static OrgSoundmanagerGeniviRoutingsend *sm_adapter;
 static OrgSoundmanagerGeniviRoutingsendIface* sm_itf;

 static GMainLoop *loop = NULL;
 /* To Do hash table is better */
 struct event{
     char* name;
     struct afb_event* event;
     };
 static struct event command_event_list[COMMAND_EVENT_NUM];
 static struct event routing_event_list[ROUTING_EVENT_NUM];

 static struct afb_event ev_new_connection;
 static struct afb_event ev_removed_main_connection;
 static struct afb_event ev_volume_changed;
 static struct afb_event ev_sink_mute_state_changed;
 static struct afb_event ev_main_connection_state_changed;

 /* Routing interface event */
 static struct afb_event ev_set_routing_ready;
 static struct afb_event ev_set_routing_rundown;
 static struct afb_event ev_async_connect;
 static struct afb_event ev_async_set_source_state;

 static const char _sourceid[] = "sourceID";
 static const char _sinkid[] = "sinkID" ;
 static const char _main_connection_id[] = "mainConnectionID";
 static const char _delay[] = "delay";
 static const char _connectionState[] = "connectionState";
 static const char _connectionID[] = "connectionID";
 static const char _volume[] = "volume";
 static const char _volumeStep[] = "volumeStep";
 static const char _muteState[] = "muteState";

 static const char _handle[] = "handle";
 static const char _appname[] = "appname";
 static const char _ramp[] = "ramp";
 static const char _time[] = "time";
 static const char _sourceState[] = "sourceState";
 static const char _sourceClassID[] = "sourceClassID";
 static const char _error[] = "error";
 static const char _sinkData[] = "sinkData";
 static const char _sourceData[] = "sourceData";
 static const char _interruptState[] = "interruptState";
 static const char _availability[] = "availability";
 static const char _domainID[] = "domainID";
 static const char _listvolumes[] = "listvolumes";
 static const char _payload[] = "payload";
 static const char _connectionFormat[] = "connectionFormat";
 /*
 ********** Method of Sound Manager (API) **********
 */

 /* call "connect" function of Audio Manager*/
 static void connect (struct afb_req request)
 {
     DEBUG(afbitf,"call connect");
     guint16 source_id, sink_id;
     guint16 main_connectionID = 0;
     gint16 ret;
     REQ_ERROR req_err1, req_err2;
     GError *err = NULL;
     /* ToDo select appname or sourceID(sinkID) */

     req_err1 = getid_uint16(request, _sourceid, &source_id);
     req_err2 = getid_uint16(request, _sinkid, &sink_id);

     if((req_err1 != REQ_OK) || (req_err2 != REQ_OK))
     {
         DEBUG(afbitf, "getid_uint16 source ret = %d,sink ret = %d", source_id, sink_id);
         NOTICE(afbitf,"wrong request");
         afb_req_fail(request,"wrong-request",NULL);
         return;
     }

     audiomanager_commandinterface_call_connect_sync(
         am_cmd_bus,
         source_id,
         sink_id,
         &ret,
         &main_connectionID,
         NULL, &err);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call connect");
         return;
     }

     /* ToDo Remember appname(key) and tie to sourceID(value) */

     /*create response json object*/
     struct json_object *res = json_object_new_object();
     sm_add_object_to_json_object_func(res, __FUNCTION__, 4,
         "error", ret,
         _main_connection_id, main_connectionID);
     char *info;
     get_response_audiomanager_massage_error(ret,&info);
     afb_req_success(request, res, info);
 }

 /* call "disconnect" function of Audio Manager*/
 static void disconnect (struct afb_req request)
 {
     DEBUG(afbitf,"call disconnect");

     guint16 id;
     gint16 ret;
     REQ_ERROR req_err;
     GError *err = NULL;

     req_err = getid_uint16(request, _main_connection_id, &id);
     DEBUG(afbitf, "requested %s = %d", _main_connection_id, id);

     if(req_err != REQ_OK)
     {
         afb_req_fail(request,"wrong-request",afb_req_value (request, _main_connection_id));
         return;
     }
     audiomanager_commandinterface_call_disconnect_sync(
         am_cmd_bus,
         id,
         &ret,
         NULL, &err);
     DEBUG(afbitf, "ret = %d", ret);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call getListMainConnections");
         return;
     }

     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object_func(res_obj, __FUNCTION__, 2,
         "error", ret);
     char *info;
     get_response_audiomanager_massage_error(ret,&info);

     afb_req_success(request, res_obj, info); /* return error num as status */
 }

 static void setVolume (struct afb_req request)
 {
     DEBUG(afbitf,"call setVolume");

     guint16 sink_id, vol;
     gint16 ret;
     REQ_ERROR req_err1, req_err2;
     GError *err = NULL;

     req_err1 = getid_uint16(request, _sinkid, &sink_id);
     req_err2 = getid_int16(request, _volume, &vol);
     DEBUG(afbitf, "requested %s = %d, %s = %d",_sinkid, sink_id, _volume, vol);
     if((req_err1 != REQ_OK) || (req_err2 != REQ_OK))
     {
         afb_req_fail(request,"wrong-request", NULL);
         return;
     }

     audiomanager_commandinterface_call_set_volume_sync(
         am_cmd_bus,
         sink_id,
         vol,
         &ret,
         NULL, &err);
     DEBUG(afbitf, "ret = %d", ret);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call setVolume");
         return;
     }

     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object_func(res_obj, __FUNCTION__, 2,
         "error", ret);
     char *info;
     get_response_audiomanager_massage_error(ret,&info);

     afb_req_success(request, res_obj, info); /* return error num as status */
 }

 static void volumeStep (struct afb_req request)
 {
     DEBUG(afbitf,"call volumeStep");

     guint16 sink_id, vol;
     gint16 ret;
     REQ_ERROR req_err1, req_err2;
     GError *err = NULL;

     req_err1 = getid_uint16(request, _sinkid, &sink_id);
     req_err2 = getid_int16(request, _volumeStep, &vol);
     DEBUG(afbitf, "requested %s = %d, %s = %d",_sinkid, sink_id, _volumeStep, vol);
     if((req_err1 != REQ_OK) || (req_err2 != REQ_OK))
     {
         afb_req_fail(request,"wrong-request", NULL);
         return;
     }

     audiomanager_commandinterface_call_volume_step_sync(
         am_cmd_bus,
         sink_id,
         vol,
         &ret,
         NULL, &err);
     DEBUG(afbitf, "ret = %d", ret);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call volumeStep");
         return;
     }

     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object_func(res_obj, __FUNCTION__, 2,
         "error", ret);
     char *info;
     get_response_audiomanager_massage_error(ret,&info);

     afb_req_success(request, res_obj, info); /* return error num as status */
 }

 /* 1 means mute, 2 means unmute */
 static void setSinkMuteState(struct afb_req request)
 {
     DEBUG(afbitf,"call setSinkMuteStete");

     guint16 sink_id, mute;
     gint16 ret;
     REQ_ERROR req_err1, req_err2;
     GError *err = NULL;

     req_err1 = getid_uint16(request, _sinkid, &sink_id);
     req_err2 = getid_int16(request, _muteState, &mute);
     DEBUG(afbitf, "requested %s = %d, %s = %d",_sinkid, sink_id, _muteState, mute);
     if((req_err1 != REQ_OK) || (req_err2 != REQ_OK))
     {
         afb_req_fail(request,"wrong-request", NULL);
         return;
     }

     audiomanager_commandinterface_call_set_sink_mute_state_sync(
         am_cmd_bus,
         sink_id,
         mute,
         &ret,
         NULL, &err);
     DEBUG(afbitf, "ret = %d", ret);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call setSinkMuteStete");
         return;
     }

     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object_func(res_obj, __FUNCTION__, 2,
         "error", ret);
     char *info;
     get_response_audiomanager_massage_error(ret,&info);

     afb_req_success(request, res_obj, info); /* return error num as status */
 }

 /* call "getListMainConnections" function of Audio Manager */
 static void getListMainConnections(struct afb_req request)
 {
     DEBUG(afbitf,"call getListMainConnections");
     guint16 ret;
     GVariant* mainConnectionList;
     GError *err = NULL;

     audiomanager_commandinterface_call_get_list_main_connections_sync(
         am_cmd_bus,
         &ret,
         &mainConnectionList,
         NULL,
         &err
     );
     DEBUG(afbitf,"ret = %d, mainConnectionList pointer = %p", ret, &mainConnectionList);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call getListMainConnections");
         return;
     }

     /* create response */
     struct json_object *array_res = json_object_new_array();
     gsize size = g_variant_n_children(mainConnectionList);
     DEBUG(afbitf, "mainConnectionList size is %u",(uint16_t)size);
     struct json_object *verb_obj = json_object_new_object();
     sm_add_object_to_json_object_func(verb_obj, __FUNCTION__, 0);
     json_object_array_add(array_res, verb_obj);
     if(size <= 0)
     {
         NOTICE(afbitf, "mainConnectionList size is 0");
     }
     else{
         for(int i = 0; i < size; ++i)
         {
             guint16 mcid, srcid, sinkid;
             gint16 delay, constate;
             g_variant_get_child(
                 mainConnectionList,i,"(qqqnn)",
                 &mcid, &srcid, &sinkid, &delay, &constate
                 );

             struct json_object* res_obj = json_object_new_object();
             sm_add_object_to_json_object_func(res_obj,__FUNCTION__,10,
                 _main_connection_id, mcid,
                 _sourceid, srcid,
                 _sinkid, sinkid,
                 _delay, delay,
                 _connectionState, constate
             );
             json_object_array_add(array_res,res_obj);
         }
     }
     DEBUG(afbitf,"json object :%s:",json_object_to_json_string(array_res));
     afb_req_success(request, array_res, "Success to get main connection list");
 }

 /*
 *
 ****** Routing Interface method(API) ***********
 *
 */
 static void ackConnect(struct afb_req request)
 {
     /* This function will be deprecated */
     DEBUG(afbitf,"call %s", __FUNCTION__);
     guint16 handle, connection_id, error;
     REQ_ERROR req_err1, req_err2 , req_err3;
     GError *err = NULL;

     req_err1 = getid_uint16(request, _handle, &handle);
     req_err2 = getid_uint16(request, _connectionID, &connection_id);
     req_err3 = getid_uint16(request, _error, &error);

     if((req_err1 != REQ_OK) || (req_err2 != REQ_OK) || (req_err3 != REQ_OK))
     {
         afb_req_fail(request,"wrong-request", NULL);
         return;
     }
     if(connection_id == 0)
     {
         afb_req_fail(request,"wrong-request", "connectionID is more than 0");
         return;
     }


     audiomanager_routinginterface_call_ack_connect_sync(
         am_route_bus,
         handle,
         connection_id,
         error,
         NULL, &err);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call ackConnect");
         return;
     }
     afb_req_success(request, NULL, NULL);
 }
 static void ackDisconnect(struct afb_req request)
 {
     /* This function will be deprecated */
     DEBUG(afbitf,"call %s", __FUNCTION__);
     guint16 handle, connection_id, error;
     REQ_ERROR req_err1, req_err2 , req_err3;
     GError *err = NULL;

     req_err1 = getid_uint16(request, _handle, &handle);
     req_err2 = getid_uint16(request, _connectionID, &connection_id);
     req_err3 = getid_uint16(request, _error, &error);

     if((req_err1 != REQ_OK) || (req_err2 != REQ_OK) || (req_err3 != REQ_OK))
     {
         afb_req_fail(request,"wrong-request", "connectionID is more than 0");
         return;
     }
     if(connection_id == 0)
     {
         afb_req_fail(request,"wrong-request", "connectionID is more than 0");
         return;
     }

     audiomanager_routinginterface_call_ack_disconnect_sync(
         am_route_bus,
         handle,
         connection_id,
         error,
         NULL, &err);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call ackDisconnect");
         return;
     }
     afb_req_success(request, NULL, NULL);
 }
 static void ackSetSourceState(struct afb_req request)
 {
     /* This function will be deprecated */
         /* This function will be deprecated */
     DEBUG(afbitf,"call %s", __FUNCTION__);
     guint16 handle, error;
     REQ_ERROR req_err1, req_err2;
     GError *err = NULL;

     req_err1 = getid_uint16(request, _handle, &handle);
     req_err2 = getid_uint16(request, _error, &error);

     if((req_err1 != REQ_OK) || (req_err2 != REQ_OK))
     {
         NOTICE(afbitf,"wrong request");
         afb_req_fail(request,"wrong-request", NULL);
         return;
     }

     audiomanager_routinginterface_call_ack_set_source_state_sync(
         am_route_bus,
         handle,
         error,
         NULL, &err);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call ackDisconnect");
         return;
     }
     afb_req_success(request, NULL, NULL);
 }
 static void registerSink(struct afb_req request)
 {
     /* This function will be deprecated because application will not register function*/
 }
 static void deregisterSink(struct afb_req request)
 {
     /* This function will be deprecated because application will not register function*/
 }

 /* This function will be modified to abstract argument */
 static void registerSource(struct afb_req request)
 {
     DEBUG(afbitf,"call %s", __FUNCTION__);
     GError *err = NULL;

     guint16 source_id; /* q  0 is for dynamic id*/
     guint16 domain_id;  /* q */
     guint16 source_class_id;   /* q */
     gint32  source_state = 1; /* i SS_ON */
     gint16  volume;  /* n */

     if(REQ_OK != getid_uint16(request, _sourceid, &source_id)){
         source_id = 0;  /* if 0, dynamic source id will be attached */
     }
     if( REQ_OK != getid_uint16(request, _domainID, &domain_id)){
         afb_req_fail(request,"wrong-request", "domainID should be more than 0");
         return;
     }
     if(domain_id == 0)
     {
         afb_req_fail(request,"wrong-request", "domainID should be more than 0");
         return;
     }
     const gchar* name = afb_req_value(request, _appname);  /* s */
     if(!name)
     {
         char* info = "Must specify the name. Please input json arg such as {\"appname\":\"radio\"}";
         afb_req_fail(request, NULL, info);
         return;
     }
     if(REQ_OK != getid_uint16(request, _sourceClassID, &source_class_id)){
         source_class_id = 0;    /* BASE */
     }
     if(REQ_OK != getid_uint16(request, _sourceState, &source_state)){
         source_state = 0;
     }
     if(REQ_OK != getid_int16(request, _volume, &volume)){
         volume = 3000;
     }
     gboolean visible = TRUE;   /* b */
     struct availability_s available;     /* (ii) */
     available.availability = 1;         /* A_UNKNOWN */
     available.avalilable_reason = 0;    /* AR_UNKNOWN */
     guint16 interrupt = 1;              /* q IS_OFF */

     struct sound_property_s sound_property_list;   /* a(in) */
     sound_property_list.type = 0;
     sound_property_list.value = 0;     /* in reality, this is array of struct */

     gint32 connection_format_list = 0; /* ai */
     struct  main_sound_property_s main_property_list;    /* a(in) */
     main_property_list.type = 0;
     main_property_list.value = 0;

     struct notification_config_s nconf_routing;
     struct notification_config_s nconf_command; /* a(iin)a(iin) */
     nconf_routing.type = 0;
     nconf_routing.status = 0;
     nconf_routing.parameter = 0;

     nconf_command.type = 0;
     nconf_command.status = 0;
     nconf_command.parameter = 0;

     /* acuire data */
     guint16 acquire_source_id;
     guint16 error;

     GVariant* sourceData = create_source_data (source_id, domain_id, name, source_class_id,
         source_state, volume, visible, available, interrupt,
         sound_property_list, connection_format_list, main_property_list,
         nconf_routing, nconf_command, afbitf);

     GVariant* input =  g_variant_ref_sink(sourceData);
     audiomanager_routinginterface_call_register_source_sync(
         am_route_bus,
         input,
         &acquire_source_id,
         &error,
         NULL, &err);
     g_variant_unref(input);

     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call registerSource");
         return;
     }

     /*create response json object*/
     struct json_object *res = json_object_new_object();
     sm_add_object_to_json_object_func(res, __FUNCTION__, 4,
         _error, error,
         _sourceid, acquire_source_id);
     char *info;
     get_response_audiomanager_massage_error(error,&info);
     afb_req_success(request, res, info);
 }

 static void deregisterSource(struct afb_req request)
 {
     guint16 source_id;
     guint16 error;

     GError *err = NULL;

     if(REQ_OK != getid_uint16(request, _sourceid, &source_id)){
         afb_req_fail(request, "wrong-request", NULL);
     }
     audiomanager_routinginterface_call_deregister_source_sync(
         am_route_bus,
         source_id,
         &error,
         NULL, &err
     );
     if(err != NULL)
     {
         afb_req_fail(request, "failed", "Unable to call deregisterSource");
         return;
     }
     /*create response json object*/
     struct json_object *res = json_object_new_object();
     sm_add_object_to_json_object_func(res, __FUNCTION__, 2,
         _error, error);
     char *info;
     get_response_audiomanager_massage_error(error,&info);
     afb_req_success(request, res, info);

 }

 static void confirmRoutingReady(struct afb_req request)
 {
     /* This function will be deprecated because application will not register function*/
 }
 static void confirmRoutingRundown(struct afb_req request)
 {
     /* This function will be deprecated because application will not register function*/
 }
 static void ackSetVolumes(struct afb_req request)
 {
     /* This function will be deprecated */
 }
 static void ackSinkNotificationConfiguration(struct afb_req request)
 {
     /* This function will be deprecated */
 }
 static void ackSourceNotificationConfiguration(struct afb_req request)
 {
     /* This function will be deprecated */
 }


 static void subscribe(struct afb_req request)
 {
     const char *value = afb_req_value(request, "event");
     char *info;
     DEBUG(afbitf, "value is %s", value);
     if(value) {
         int index = sm_search_event_name_index(value);
         if(index < 0)
         {
             index = sm_search_routing_event_name_index(value);
             if(index < 0)
             {
                 ERROR(afbitf, "dedicated event doesn't exist");
             }
             else
             {
                 afb_req_subscribe(request, *routing_event_list[index].event);
             }
         }
         else
         {
             afb_req_subscribe(request, *command_event_list[index].event);
         }
     }
     else{
         ERROR(afbitf, "Please input event name");
     }
     afb_req_success(request, NULL, NULL);
 }

 static void unsubscribe(struct afb_req request)
 {
     const char *value = afb_req_value(request, "event");
     char *info;
     DEBUG(afbitf, "value is %s", value);
     if(value) {
         int index = sm_search_event_name_index(value);
         if(index < 0)
         {
             index = sm_search_routing_event_name_index(value);
             if(index < 0)
             {
                 ERROR(afbitf, "dedicated event doesn't exist");
             }
             else
             {
                 afb_req_unsubscribe(request, *routing_event_list[index].event);
             }
         }
         else
         {
             afb_req_unsubscribe(request, *command_event_list[index].event);
         }
     }
     else{
         ERROR(afbitf, "Please input event name");
     }
     afb_req_success(request, NULL, NULL);
 }

 /*
 ********** Callback Function invoked by Audio Manager **********
 */

 static void on_new_main_connection(AudiomanagerCommandinterface* interface,
     GVariant* mainConnection)
 {
     DEBUG(afbitf,"%s is called",__FUNCTION__);

     guint16 mcid, srcid, sinkid;
     gint16 delay, constate;
     g_variant_get(
         mainConnection,"(qqqnn)", &mcid, &srcid, &sinkid, &delay, &constate);

     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object(res_obj,10,
         _main_connection_id, mcid,
         _sourceid, srcid,
         _sinkid, sinkid,
         _delay, delay,
         _connectionState, constate
         );
     DEBUG(afbitf,"json object :%s:",json_object_to_json_string(res_obj));

     afb_event_push(ev_new_connection, res_obj);
 }

 static void on_removed_main_connection(
     AudiomanagerCommandinterface* interface, guint16 mainConnectionID)
 {
     DEBUG(afbitf,"%s is called",__FUNCTION__);

     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object(res_obj, 2,
         _main_connection_id, mainConnectionID);
     afb_event_push(ev_removed_main_connection, res_obj);
 }

 static void on_main_connection_state_changed(
     AudiomanagerCommandinterface* interface, guint16 connectionID, gint16 connectionState)
 {
     DEBUG(afbitf,"%s is called",__FUNCTION__);

     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object(res_obj, 4,
         _connectionID, connectionID,
         _connectionState, connectionState);
     afb_event_push(ev_main_connection_state_changed, res_obj);
 }

 static void on_volume_changed(
             AudiomanagerCommandinterface* interface, guint16 sinkID, gint16 volume)
 {
     DEBUG(afbitf,"%s is called",__FUNCTION__);
     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object(res_obj, 4,
         _sinkid, sinkID,
         _volume, volume);
     afb_event_push(ev_volume_changed, res_obj);
 }

 static void on_sink_mute_state_changed(
             AudiomanagerCommandinterface* interface, guint16 sinkID, gint16 mute)
 {
     DEBUG(afbitf,"%s is called",__FUNCTION__);
     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object(res_obj, 4,
         _sinkid, sinkID,
         _muteState, mute);
     afb_event_push(ev_sink_mute_state_changed, res_obj);
 }

 /*
 ********** Callback Function invoked by Audio Manager Routing Interface**********
 */
 static void on_set_routing_ready(
             AudiomanagerRoutinginterface* interface)
 {
     DEBUG(afbitf,"%s is called",__FUNCTION__);
     afb_event_push(ev_set_routing_ready, NULL);
 }

 static void on_set_routing_rundown(
             AudiomanagerRoutinginterface* interface)
 {
     DEBUG(afbitf,"%s is called",__FUNCTION__);
     afb_event_push(ev_set_routing_ready, NULL);
 }


 /*
 ********** Callback Function invoked by Sound Manager Adapter Interface**********
 *
 *   For now, there may be no need to send events to applications from these invocation.
 *   Sound Manager just sends ack to Audio Manager in charge of applications.
 *   If event is needed, make events in initialize function in this source, and
 *   write afb_event_push in the invocations.
 *   Events should be pushed in this source.(I teseted to push events in other code, but can't)
 *
 */


 static gboolean on_async_abort(
     OrgSoundmanagerGeniviRoutingsend *object,
     GDBusMethodInvocation *invocation,
     guint16 arg_handle)
 {
     DEBUG(afbitf, "%s called", __FUNCTION__);
     /* Nothing To Do. If it is better to implement something, I will implement */
     return TRUE;
 }

 static gboolean on_async_connect(
     OrgSoundmanagerGeniviRoutingsend *object,
     GDBusMethodInvocation *invocation,
     guint16 arg_handle,
     guint16 arg_connectionID,
     guint16 arg_sourceID,
     guint16 arg_sinkID,
     gint arg_connectionFormat)
 {
     DEBUG(afbitf, "%s called", __FUNCTION__);
     GError* err;
     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object(res_obj, 10,
         _handle, arg_handle,
         _connectionID, arg_connectionID,
         _sourceid, arg_sourceID,
         _sinkid, arg_sinkID,
         _connectionFormat, arg_connectionFormat);
     afb_event_push(ev_async_connect, res_obj);
     audiomanager_routinginterface_call_ack_connect_sync(
         am_route_bus,
         arg_handle,
         arg_connectionID,
         NULL,
         NULL, &err);
     if(err != NULL)
     {
         ERROR(afbitf, "Can't create sound manager adapter");
         return FALSE;
     }
     return TRUE;
 }

 static gboolean on_async_disconnect(
     OrgSoundmanagerGeniviRoutingsend *object,
     GDBusMethodInvocation *invocation,
     guint16 arg_handle,
     guint16 arg_connectionID)
 {
     DEBUG(afbitf, "%s called", __FUNCTION__);
     GError* err;
     audiomanager_routinginterface_call_ack_disconnect_sync(
         am_route_bus,
         arg_handle,
         arg_connectionID,
         NULL,
         NULL, &err);
     if(err != NULL)
     {
         ERROR(afbitf, "Can't create sound manager adapter");
         return FALSE;
     }
     return TRUE;
 }

 static gboolean on_async_set_sink_volume(
     OrgSoundmanagerGeniviRoutingsend *object,
     GDBusMethodInvocation *invocation,
     guint16 arg_handle,
     guint16 arg_sinkID,
     gint16 arg_volume,
     gint16 arg_ramp,
     guint16 arg_time)
 {
     DEBUG(afbitf, "%s called", __FUNCTION__);
     /* Nothing To Do. If it is better to implement something, I will implement */
     return TRUE;
 }

 static gboolean on_async_set_source_state(
     OrgSoundmanagerGeniviRoutingsend *object,
     GDBusMethodInvocation *invocation,
     guint16 arg_handle,
     guint16 arg_sourceID,
     gint arg_sourceState)
 {
     DEBUG(afbitf, "%s called", __FUNCTION__);
     GError* err;
     struct json_object* res_obj = json_object_new_object();
     sm_add_object_to_json_object(res_obj, 6,
         _handle, arg_handle,
         _sourceid, arg_sourceID,
         _sourceState, arg_sourceState);
     afb_event_push(ev_async_set_source_state, res_obj);
     /* Applications should return ackSetSourceState, then Sound Manager doen't return ackSetSourceState */
     /*audiomanager_routinginterface_call_ack_set_source_state_sync(
         am_route_bus,
         arg_handle,
         NULL,
         NULL, &err);*/
     if(err != NULL)
     {
         ERROR(afbitf, "Can't create sound manager adapter");
         return FALSE;
     }
     return TRUE;
 }

 static gboolean init_sound_manager_adapter(GDBusServer *server, GDBusConnection *conn, gpointer data)
 {
     DEBUG(afbitf, "%s called", __FUNCTION__);
     sm_adapter = org_soundmanager_genivi_routingsend_skeleton_new();
     sm_itf = ORG_SOUNDMANAGER_GENIVI_ROUTINGSEND_GET_IFACE(sm_adapter);
     /* initialize sound manager adapter */
     sm_itf->handle_async_abort = on_async_abort;
     sm_itf->handle_async_connect = on_async_connect;
     sm_itf->handle_async_disconnect = on_async_disconnect;
     sm_itf->handle_async_set_sink_volume = on_async_set_sink_volume;
     sm_itf->handle_async_set_source_state = on_async_set_source_state;
     gboolean ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(sm_adapter), conn, SOUND_MANAGER_PATH, NULL);
     if(!ret)
     {
         ERROR(afbitf, "Can't create sound manager adapter");
         return FALSE;
     }
     return TRUE;
 }

 /*
  * array of the verbs exported to afb-daemon
  */
 static const struct afb_verb_desc_v1 binding_verbs[]= {
 /* VERB'S NAME                    SESSION MANAGEMENT                FUNCTION TO CALL                    SHORT DESCRIPTION */
 { .name = "connect",        .session = AFB_SESSION_NONE,    .callback = connect,     .info = "Connect source id and sink id" },
 { .name = "disconnect",     .session = AFB_SESSION_NONE,    .callback = disconnect,  .info = "Disconnect source id and sink id" },
 { .name = "setVolume",      .session = AFB_SESSION_NONE,    .callback = setVolume,  .info = "Set volume value" }, /* it is better to show the range*/
 { .name = "volumeStep",     .session = AFB_SESSION_NONE,    .callback = volumeStep,  .info = "Set volume step range" },
 { .name = "setSinkMuteState",     .session = AFB_SESSION_NONE,    .callback = setSinkMuteState,  .info = "Set Mute state: 1 means mute, 2 means umute. Others are invalid" },
 { .name = "getListMainConnections",     .session = AFB_SESSION_NONE,    .callback = getListMainConnections,  .info = "Get MainConnection List" },
 /* Routing Interface */
 { .name = "registerSource",      .session = AFB_SESSION_NONE,    .callback = registerSource,  .info = "Register Application" },
 { .name = "deregisterSource",      .session = AFB_SESSION_NONE,    .callback = deregisterSource,  .info = "Deregister Application" },
 { .name = "ackConnect",      .session = AFB_SESSION_NONE,    .callback = ackConnect,  .info = "Acknowledge of asyncConnect" },
 { .name = "ackDisconnect",      .session = AFB_SESSION_NONE,    .callback = ackDisconnect,  .info = "Acknowledge of asyncConnect" },
 { .name = "ackSetSourceState",      .session = AFB_SESSION_NONE,    .callback = ackSetSourceState,  .info = "Acknowledge of asyncSetSourceState" },
 { .name = "subscribe",      .session = AFB_SESSION_NONE,    .callback = subscribe,  .info = "Subscribe event" },
 { .name = "unsubscribe",    .session = AFB_SESSION_NONE,    .callback = unsubscribe,  .info = "Unsubscribe event" },
 { .name = NULL } /* marker for end of the array */
 };

 static const struct afb_binding binding_description =
 {
     .type = AFB_BINDING_VERSION_1,
     .v1 = {
         .info = "Sound Manager" ,
         .prefix = "soundmanager" ,
         .verbs = binding_verbs
     }
 };

 static void *dbus_event_loop_run(void *args)
 {
     loop = g_main_loop_new(NULL, FALSE);
     g_main_loop_run(loop);
 }

 static void free_dbus()
 {
     ERROR(afbitf, "free dbus");
     if(am_cmd_bus)
     {
         free(am_cmd_bus);
     }
     if(am_route_bus)
     {
         free(am_route_bus);
     }
 }

 static int init()
 {
     int ret;
     INFO(afbitf,"Initialize Dbus object");
     /* Initialize Dbus interface */
     if(am_cmd_bus || am_route_bus)
     {
         ERROR(afbitf, "Dbus object to Audio Manager is already created");
         goto out;
     }
     am_cmd_bus = audiomanager_commandinterface_proxy_new_for_bus_sync(
         G_BUS_TYPE_SYSTEM,
         G_DBUS_PROXY_FLAGS_NONE,
         AM_NAME,
         AM_CMD_PATH,
         NULL,
         NULL
         );
     am_route_bus = audiomanager_routinginterface_proxy_new_for_bus_sync(
         G_BUS_TYPE_SYSTEM,
         G_DBUS_PROXY_FLAGS_NONE,
         AM_NAME,
         AM_ROUTE_PATH,
         NULL,
         NULL
         );

     if(!am_cmd_bus || !am_route_bus)
     {
         goto out;
     }

     INFO(afbitf, "Finish Initialize");
     return 0;
 out:
     ERROR(afbitf,"Failed to initialize");
     free_dbus();
     return -1;
 }

 static int sm_event_init()
 {
     INFO(afbitf,"Initialize event receive setting");
     int ret;
     /* Initialize make event */
     size_t size = sizeof cmd_evlist / sizeof *cmd_evlist;

     /*create event*/
     /*ToDo Hash table is better. And event should be created in the loop
       I would like to change */
     ev_volume_changed = afb_daemon_make_event(afbitf->daemon, cmd_evlist[0]);
     ev_new_connection = afb_daemon_make_event(afbitf->daemon, cmd_evlist[1]);
     ev_removed_main_connection   = afb_daemon_make_event(afbitf->daemon, cmd_evlist[2]);
     ev_sink_mute_state_changed  = afb_daemon_make_event(afbitf->daemon, cmd_evlist[3]);
     ev_main_connection_state_changed    = afb_daemon_make_event(afbitf->daemon, cmd_evlist[4]);
     command_event_list[0].name = cmd_evlist[0];
     command_event_list[0].event = &ev_volume_changed;
     command_event_list[1].name = cmd_evlist[1];
     command_event_list[1].event = &ev_new_connection;
     command_event_list[2].name = cmd_evlist[2];
     command_event_list[2].event = &ev_removed_main_connection;
     command_event_list[3].name = cmd_evlist[3];
     command_event_list[3].event = &ev_sink_mute_state_changed;
     command_event_list[4].name = cmd_evlist[4];
     command_event_list[4].event = &ev_main_connection_state_changed;

     /* create routing event */
     ev_set_routing_ready = afb_daemon_make_event(afbitf->daemon, route_evlist[0]);
     ev_set_routing_rundown = afb_daemon_make_event(afbitf->daemon, route_evlist[1]);
     ev_async_connect = afb_daemon_make_event(afbitf->daemon, route_evlist[2]);
     ev_async_set_source_state = afb_daemon_make_event(afbitf->daemon, route_evlist[3]);
     routing_event_list[0].name = route_evlist[0];
     routing_event_list[0].event = &ev_set_routing_ready;
     routing_event_list[1].name = route_evlist[1];
     routing_event_list[1].event = &ev_set_routing_rundown;
     routing_event_list[2].name = route_evlist[1];
     routing_event_list[2].event = &ev_async_connect;
     routing_event_list[3].name = route_evlist[1];
     routing_event_list[3].event = &ev_async_set_source_state;
     /*for(size_t i = 0; i < size; ++i)
     {
         struct afb_event afbev = afb_daemon_make_event(afbitf->daemon, cmd_evlist[i]));
         size_t afbev_size = sizeof afbev;
         size_t key_size = sizeof cmd_evlist[i];

         struct event ev = {cmd_evlist[i],afbev};
         command_event_list[i] = malloc(key_size + afbev_size);
         command_event_list[i] = ev;
         search_result = hsearch(entry, FIND);
         if(search_result)
             DEBUG(afbitf, "event name is %s", search_result->key);
     }*/

     /* Initialize dbus event thread */
     if(!am_cmd_bus || !am_route_bus)
     {
         goto ev_init_out;
     }
     pthread_t thread_id;
     ret = pthread_create(&thread_id, NULL, dbus_event_loop_run, NULL);
     if(ret != 0)
     {
         goto ev_init_out;
     }
     /* initialize signal from audio manager command interface */
     g_signal_connect(am_cmd_bus,
         "volume_changed",
         G_CALLBACK(on_volume_changed),
         NULL);
     g_signal_connect(am_cmd_bus,
         "new_main_connection",
         G_CALLBACK(on_new_main_connection),
         NULL);
     g_signal_connect(am_cmd_bus,
         "removed_main_connection",
         G_CALLBACK(on_removed_main_connection),
         NULL);
     g_signal_connect(am_cmd_bus,
         "sink_mute_state_changed",
         G_CALLBACK(on_sink_mute_state_changed),
         NULL);
     g_signal_connect(am_cmd_bus,
         "main_connection_state_changed",
         G_CALLBACK(on_main_connection_state_changed),
         NULL);
     g_signal_connect(am_route_bus,
         "set_routing_ready",
         G_CALLBACK(on_set_routing_ready),
         NULL);
     g_signal_connect(am_route_bus,
         "set_routing_rundown",
         G_CALLBACK(on_set_routing_rundown),
         NULL);

     /* Get soundmanager adapter bus */
     g_bus_own_name(G_BUS_TYPE_SYSTEM, SOUND_MANAGER_NAME, G_BUS_NAME_OWNER_FLAGS_NONE,
         NULL, init_sound_manager_adapter, NULL, NULL, NULL);

     INFO(afbitf,"Finish Initialize event receive setting");
     return 0;

 ev_init_out:
     if(loop != NULL)
     {
         g_main_loop_unref(loop);
     }
     free_dbus();
     ERROR(afbitf, "DBus connection is not created");
     return -1;
 }

 /*
  * activation function for registering the binding called by afb-daemon
  */
 const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf)
 {
     afbitf = itf;         // records the interface for accessing afb-daemon

     int ret = init();     // Set Dbus communication with audio mangaer
     return (ret == 0) ? &binding_description : NULL;
 }

 int afbBindingV1ServiceInit(struct afb_service service)
 {
     DEBUG(afbitf, "Initializing Audio Manager Notification \n");
     int ret = sm_event_init();
     return ret;
 }
event::event
struct afb_event * event
Definition: soundmanager.c:51

+AM_CMD_PATH
#define AM_CMD_PATH
Definition: soundmanager.c:32

+AM_NAME
#define AM_NAME
Definition: soundmanager.c:31

+AM_ROUTE_PATH
#define AM_ROUTE_PATH
Definition: soundmanager.c:33

+event
Definition: soundmanager.c:49

+afbBindingV1Register
const struct afb_binding * afbBindingV1Register(const struct afb_binding_interface *itf)
Definition: soundmanager.c:1137

+afbBindingV1ServiceInit
int afbBindingV1ServiceInit(struct afb_service service)
Definition: soundmanager.c:1145

+ROUTING_EVENT_NUM
#define ROUTING_EVENT_NUM
Definition: soundmanager.c:38

+SOUND_MANAGER_PATH
#define SOUND_MANAGER_PATH
Definition: soundmanager.c:35

+SOUND_MANAGER_NAME
#define SOUND_MANAGER_NAME
Definition: soundmanager.c:34

+COMMAND_EVENT_NUM
#define COMMAND_EVENT_NUM
Definition: soundmanager.c:37

+event::name
char * name
Definition: soundmanager.c:50

+