soundmanager.c

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.
 */

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