support.c

Go to the documentation of this file.

/**
 * @file support.c
 * @brief This file implements a variety of support wrapper functionality
 */
 
/*
 * This file is part of liberipc.
 *
 * liberipc is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * liberipc is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V. 
 * All rights reserved.
 *
 * Based on code found in libosso library by Kimmo Hämäläinen <kimmo.hamalainen@nokia.com>
 */

#include "internal.h"
#include "eripc_support.h"

#define DBUS_SERVICE_SYSTEM_CONTROL     "com.irexnet.sysd"
#define DBUS_SERVICE_POPUP_MENU         "com.irexnet.popupmenu"

/*****************************************************************************/
/*                            Support Macros                                 */
/*****************************************************************************/

/**
 * Make a simple function body that calls eripc_send_varargs.
 * Checks the return value and returns TRUE on success, FALSE otherwise
 *
 * Expects a eripc_client_context_t* ccontext local available.
 **/
#define MAKE_VARARG_CALL(destination, message, ...)               \
{                                                                 \
    g_assert( ccontext );                                         \
    if (eripc_send_varargs(                                       \
                ccontext->context,                                \
                NULL,                                             \
                NULL,                                             \
                ERIPC_BUS_SESSION,                                \
                destination,                                      \
                message,                                          \
                __VA_ARGS__) != ERIPC_ERROR_SUCCESS)              \
    {                                                             \
        ULOG_DEBUG_F("eripc_send_varargs failed");  \
        return FALSE;                                             \
    }                                                             \
    return TRUE;                                                  \
}

/**
 * Convenience function for the common case of MAKE_VARARG_CALL with one string arg
 **/
#define MAKE_VARARG_CALL_1S(destination, message, s1) \
    MAKE_VARARG_CALL(destination, message,            \
                     ERIPC_TYPE_STRING, s1,           \
                     ERIPC_TYPE_INVALID);

/**
 * Convenience function for the common case of MAKE_VARARG_CALL with two string args
 **/
#define MAKE_VARARG_CALL_2S(destination, message, s1, s2) \
    MAKE_VARARG_CALL(destination, message,                \
                     ERIPC_TYPE_STRING, s1,               \
                     ERIPC_TYPE_STRING, s2,               \
                     ERIPC_TYPE_INVALID);

/**
 * Convenience function for the common case of MAKE_VARARG_CALL with three string args
 **/
#define MAKE_VARARG_CALL_3S(destination, message, s1, s2, s3) \
    MAKE_VARARG_CALL(destination, message,                    \
                     ERIPC_TYPE_STRING, s1,                   \
                     ERIPC_TYPE_STRING, s2,                   \
                     ERIPC_TYPE_STRING, s3,                   \
                     ERIPC_TYPE_INVALID);

/**
 * Make a simple function body that calls eripc_send_signal_varargs.
 * Checks the return value and returns TRUE on success, FALSE otherwise
 *
 * Expects a eripc_client_context_t* ccontext local available.
 **/
#define MAKE_SIGNAL_VARARG_CALL(interface, message, ...)                \
{                                                                       \
    g_assert( ccontext );                                               \
    if (eripc_send_signal_varargs(                                      \
                ccontext->context,                                      \
                ERIPC_BUS_SESSION,                                      \
                ccontext->path,                                         \
                interface,                                              \
                message,                                                \
                __VA_ARGS__) != ERIPC_ERROR_SUCCESS)                    \
    {                                                                   \
        ULOG_DEBUG_F("eripc_send_signal_varargs failed"); \
        return FALSE;                                                   \
    }                                                                   \
    return TRUE;                                                        \
}

/**
 * Make a function body that calls eripc_send_varargs_and_wait.
 * Parse the reply using the reply_parser function.
 *
 * Expects eripc_client_context_t* ccontext, int retval, char** err_message locals available.
 **/
#define MAKE_VARARG_WAIT_CALL(interface, message, reply_parser, ...)          \
{                                                                             \
    eripc_event_info_t *reply = NULL;                                         \
    result = eripc_send_varargs_and_wait(                                     \
                                ccontext->context,                            \
                                &reply,                                       \
                                ERIPC_BUS_SESSION,                            \
                                interface,                                    \
                                message,                                      \
                                __VA_ARGS__);                                 \
    if (result != ERIPC_ERROR_SUCCESS)                                        \
        ULOG_DEBUG_F("eripc_send_varargs_and_wait failed");     \
    else if (reply == NULL || reply->args == NULL)                            \
        ULOG_DEBUG_F("sysd returns OK but no reply structure"); \
    else                                                                      \
        retval = reply_parser;                                                \
    eripc_event_info_free(ccontext->context, reply);                          \
}

/**
 * Set busy and change IPC timeout to seconds. Pair with MAKE_BUSY_TIMEOUT_END()
 **/
#define MAKE_BUSY_TIMEOUT_START(seconds)                               \
{                                                                      \
    result = eripc_get_timeout(ccontext->context, &old_timeout);       \
    if (result == ERIPC_ERROR_SUCCESS)                                 \
    {                                                                  \
        result = eripc_set_timeout(ccontext->context, (seconds)*1000); \
        timeout_set = (result == ERIPC_ERROR_SUCCESS);                 \
    }                                                                  \
}

/**
 * Reset busy and change IPC timeout back to original value before the matching 
 * MAKE_BUSY_TIMEOUT_START()
 **/
#define MAKE_BUSY_TIMEOUT_END()                            \
{                                                          \
    if (timeout_set)                                       \
        eripc_set_timeout(ccontext->context, old_timeout); \
}


static int parse_reply_capabilities( eripc_event_info_t *reply, eripc_device_caps_t *dev_caps );
static int parse_reply_start(eripc_event_info_t *reply, char **err_message);

static char *fix_name(const char* raw_name)
{
    char *name = strdup(raw_name);
    if (name == NULL) {
        ULOG_CRIT_F("fix_name failed: out of memory");
        return NULL;
    }
    
    // replace dashes (-) with underscores (_) as dbus chokes on dashes
    unsigned int i;
    for (i=0; i<strlen(name); i++)
    {
        if (name[i] == '-')
            name[i] = '_';
    }
    return name;
}


/*****************************************************************************/
/*                               General                                     */
/*****************************************************************************/

eripc_client_context_t *eripc_client_context_new( const char *raw_name,
                                                  const char *version,
                                                  const char *raw_service,
                                                  const char *raw_path,
                                                  const char *raw_interface,
                                                  eripc_callback_function_t *callbacks )
{
    int retval;
    eripc_client_context_t* ccontext;

    ccontext = (eripc_client_context_t*)malloc(sizeof(eripc_client_context_t));
    
    char *name      = fix_name(raw_name);
    char *service   = fix_name(raw_service);
    char *path      = fix_name(raw_path);
    char *interface = fix_name(raw_interface);
    
    ccontext->context = eripc_init(name, version, NULL);
    if (ccontext->context == NULL) 
    {
        // NOTE: MEMLEAK on name, service, path and interface!
        ULOG_ERR("Failed to initialize eripc context");
        free(ccontext);
        return NULL;
    }
    
    if (callbacks != NULL)
    {
        for (int i = 0 ; callbacks[i].handler != NULL ; i++)
        {
            if (callbacks[i].interface)
            {
                // install signal handler
                char *cb_interface = fix_name(callbacks[i].interface);
                retval = eripc_set_signal_handler( ccontext->context,
                                                   callbacks[i].handler,
                                                   NULL,
                                                   ERIPC_BUS_SESSION,
                                                   cb_interface,
                                                   callbacks[i].message_name,
                                                   &(callbacks[i].handler_id) );
                
                free(cb_interface);
                if (retval != ERIPC_ERROR_SUCCESS) 
                {
                    ULOG_DEBUG_F( "eripc_set_signal_handler %s returns %d",
                                 callbacks[i].message_name,
                                 retval );
                }
            }
            else
            {
                // install message handler
                retval = eripc_set_message_handler( ccontext->context,
                                                    callbacks[i].handler,
                                                    NULL,
                                                    ERIPC_BUS_SESSION,
                                                    interface,
                                                    callbacks[i].message_name,
                                                    &(callbacks[i].handler_id) );
                  
                if (retval != ERIPC_ERROR_SUCCESS) 
                {
                    ULOG_DEBUG_F( "eripc_set_message_handler %s returns %d",
                                 callbacks[i].message_name,
                                 retval );
                }
            }
        }
    }

    free(interface);
    
    ccontext->name = name;
    ccontext->service = service;
    ccontext->path = path;
    return ccontext;
}


void eripc_client_context_free( eripc_client_context_t *ccontext,
                                eripc_callback_function_t *callbacks )
{
    if (callbacks != NULL)
    {
        for (int i = 0 ; callbacks[i].handler_id != 0 ; i++)
        {
            eripc_unset_handler(ccontext->context, callbacks[i].handler_id);
        }
    }

    if (ccontext)
    {
        free(ccontext->name);
        free(ccontext->service);
        free(ccontext->path);
        free(ccontext);
    }
}


const gchar* eripc_error_string(eripc_error_t errorcode) 
{
    switch (errorcode) 
    {
    case ERIPC_ERROR_SUCCESS:
        return "No error (ERIPC_ERROR_SUCCESS)";
    case ERIPC_ERROR:
        return "Some kind of error occurred (ERIPC_ERROR)";
    case ERIPC_ERROR_INVALID:
        return "At least one parameter is invalid (ERIPC_ERROR_INVALID)";
    case ERIPC_ERROR_OOM:
        return "Out of memory error (ERIPC_ERROR_OOM)";
    case ERIPC_ERROR_TIMEOUT:
        return "Timeout error (ERIPC_ERROR_TIMEOUT)";
    default:
        return "Unknown/Undefined";
    }
}


/*****************************************************************************/
/*                             Popup Menu                                    */
/*****************************************************************************/

gboolean eripc_menu_add_menu( eripc_client_context_t *ccontext,
                              const char *name,
                              const char *group1,
                              const char *group2,
                              const char *group3,
                              const char *group4 )
{
    MAKE_VARARG_CALL(DBUS_SERVICE_POPUP_MENU, "addMenu",
                     ERIPC_TYPE_STRING, name,
                     ERIPC_TYPE_STRING, "",
                     ERIPC_TYPE_STRING, ccontext->service,
                     ERIPC_TYPE_STRING, group1,
                     ERIPC_TYPE_STRING, group2,
                     ERIPC_TYPE_STRING, group3,
                     ERIPC_TYPE_STRING, group4,
                     ERIPC_TYPE_INVALID );
}


gboolean eripc_menu_remove_menu( eripc_client_context_t *ccontext,
                                 const char *name )
{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_POPUP_MENU, "removeMenu", name);
}


gboolean eripc_menu_add_group( eripc_client_context_t *ccontext,
                               const char *name,
                               const char *parent, 
                               const char *image )
{
    MAKE_VARARG_CALL(DBUS_SERVICE_POPUP_MENU, "addGroup",
                     ERIPC_TYPE_STRING, name,
                     ERIPC_TYPE_STRING, parent,
                     ERIPC_TYPE_STRING, "",
                     ERIPC_TYPE_STRING, image,
                     ERIPC_TYPE_INVALID );
}


gboolean eripc_menu_add_item( eripc_client_context_t *ccontext,
                              const char *name,
                              const char *parent, 
                              const char *image  )
{
    MAKE_VARARG_CALL(DBUS_SERVICE_POPUP_MENU, "addItem",
                     ERIPC_TYPE_STRING, name,
                     ERIPC_TYPE_STRING, parent,
                     ERIPC_TYPE_STRING, "",
                     ERIPC_TYPE_STRING, image,
                     ERIPC_TYPE_INVALID );
}


gboolean eripc_menu_set_menu_label ( eripc_client_context_t *ccontext,
                                     const char *name,
                                     const char *label )
{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_POPUP_MENU, "setMenuLabel", name, label);
}


gboolean eripc_menu_set_group_label ( eripc_client_context_t *ccontext,
                                      const char *name,
                                      const char *label )
{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_POPUP_MENU, "setGroupLabel", name, label);
}


gboolean eripc_menu_set_item_label ( eripc_client_context_t *ccontext,
                                     const char *name,
                                     const char *parent, 
                                     const char *label )
{
    MAKE_VARARG_CALL_3S(DBUS_SERVICE_POPUP_MENU, "setItemLabel",
                        name, parent, label);
}


gboolean eripc_menu_show_menu( eripc_client_context_t *ccontext,
                               const char *name )
{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_POPUP_MENU, "showMenu", name);
}


gboolean eripc_menu_set_group_state( eripc_client_context_t *ccontext,
                                     const char *name,
                                     const char *state )
{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_POPUP_MENU, "setGroupState", name, state);
}


gboolean eripc_menu_set_item_state( eripc_client_context_t *ccontext,
                                    const char *name,
                                    const char *parent,
                                    const char *state )
{
    MAKE_VARARG_CALL_3S(DBUS_SERVICE_POPUP_MENU, "setItemState",
                        name, parent, state);
}

gboolean eripc_menu_set_pagecounter( eripc_client_context_t *ccontext,
                                     int cur_page,
                                     int num_pages,
                                     gboolean boundary_check )
{
    MAKE_VARARG_CALL(DBUS_SERVICE_POPUP_MENU, "updatePageCounter",
                     ERIPC_TYPE_INT, cur_page,
                     ERIPC_TYPE_INT, num_pages,
                     ERIPC_TYPE_BOOL, boundary_check,
                     ERIPC_TYPE_INVALID );
}


gboolean eripc_menu_set_statusitem_state( eripc_client_context_t *ccontext,
                                          const char *item,
                                          const char *state )
{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_POPUP_MENU, "setStatusItemState", item, state);
}

/*****************************************************************************/
/*                            System Daemon                                  */
/*****************************************************************************/

gboolean eripc_sysd_set_menu_state( eripc_client_context_t *ccontext,
                                    const char *state )
{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "menuRequestPopup", state);
}


gboolean eripc_sysd_mount_sd_card( eripc_client_context_t *ccontext , gboolean show_index_splash)
{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysCardMount",
                     ERIPC_TYPE_BOOL, show_index_splash, ERIPC_TYPE_INVALID );
}


gboolean eripc_sysd_unmount_sd_card( eripc_client_context_t *ccontext )
{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysCardUnmount",
                     ERIPC_TYPE_INVALID );
}


gboolean eripc_sysd_set_busy( eripc_client_context_t *ccontext,
                              const char *state,
                              const char *message )
{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_SYSTEM_CONTROL, "sysSetBusy", state, message);
}

gboolean eripc_sysd_reset_busy( eripc_client_context_t *ccontext )
{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysResetBusy",
                     ERIPC_TYPE_INVALID );
}

gboolean eripc_sysd_set_bg_busy( eripc_client_context_t *ccontext )
{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysSetBgBusy",
                     ERIPC_TYPE_INVALID );
}

gboolean eripc_sysd_reset_bg_busy( eripc_client_context_t *ccontext )
{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysResetBgBusy",
                     ERIPC_TYPE_INVALID );
}

gboolean eripc_sysd_set_keyboard( eripc_client_context_t *ccontext, 
                                  const char *state)
{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "sysSetKeyboard", state);
}

gboolean eripc_sysd_startup_complete( eripc_client_context_t *ccontext,
                                      const int pid,
                                      const gboolean is_multidoc, 
                                      const int xid)
{
    MAKE_SIGNAL_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "startupComplete",
                            ERIPC_TYPE_STRING, ccontext->name,
                            ERIPC_TYPE_INT,    pid,
                            ERIPC_TYPE_BOOL,   is_multidoc,
                            ERIPC_TYPE_STRING, ccontext->service,
                            ERIPC_TYPE_INT,    xid,
                            ERIPC_TYPE_INVALID );
}

/**
 * Parse the reply from an "startTask" or "openUrl" eripc calls
 **/
static int parse_reply_start(eripc_event_info_t *reply, char **err_message) 
{
    int retval = 0;
    if (reply->args[0].type == ERIPC_TYPE_INT) 
    {
        retval = reply->args[0].value.i;
        if (reply->args[1].type == ERIPC_TYPE_STRING) 
        {
            gchar *message = reply->args[1].value.s;
            if ( (message != NULL) && (err_message != NULL))
            {
                *err_message = g_strdup(message);
            }
        }
    }
    else
    {
        ULOG_DEBUG_F("unexpected reply argument");
    }
    return retval;
}

gint eripc_sysd_start_task( eripc_client_context_t *ccontext,
                            const gchar  *cmd_line,
                            const gchar  *work_dir,
                            const gchar  *label,
                            const gchar  *thumbnail_path,
                            gchar        **err_message )
{
    int old_timeout;
    int timeout_set = 0;
    int retval = 0;
    eripc_error_t result;

    MAKE_BUSY_TIMEOUT_START(60);
    MAKE_VARARG_WAIT_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "startTask",
                          parse_reply_start(reply, err_message),
                          ERIPC_TYPE_STRING, cmd_line,
                          ERIPC_TYPE_STRING, work_dir,
                          ERIPC_TYPE_STRING, label,
                          ERIPC_TYPE_STRING, thumbnail_path,
                          ERIPC_TYPE_INVALID );
    MAKE_BUSY_TIMEOUT_END();
    return retval;
}

gboolean eripc_sysd_stop_task( eripc_client_context_t *ccontext,
                              const char *cmd_line )
{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "stopTask", cmd_line);
}

gint eripc_sysd_open_url ( eripc_client_context_t *ccontext,
                           const gchar  *url,
                           const gchar  *label,
                           const gchar  *back_text,
                           gchar        **err_message )
{
    int old_timeout;
    int timeout_set = 0;
    int retval = 0;
    eripc_error_t result;
    
    MAKE_BUSY_TIMEOUT_START(60);
    MAKE_VARARG_WAIT_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "openUrl",
                          parse_reply_start(reply, err_message),
                          ERIPC_TYPE_STRING, url,
                          ERIPC_TYPE_STRING, label,
                          ERIPC_TYPE_STRING, back_text,
                          ERIPC_TYPE_INVALID );
    MAKE_BUSY_TIMEOUT_END();
    return retval;
}

static int parse_reply_capabilities( eripc_event_info_t *reply, eripc_device_caps_t *dev_caps )
{
    int i; 
    gboolean ok = TRUE;
    const eripc_arg_t *arg = NULL;

    // parse the reply strcuture
    for ( i = 0, arg = reply->args ;
                 arg->type != ERIPC_TYPE_INVALID ;
          i++,   arg++ )
    {
        ok = FALSE;
        switch (i)
        {
            case 0:
                if (arg->type == ERIPC_TYPE_BOOL)
                {
                    dev_caps->has_stylus = arg->value.b ? TRUE : FALSE;
                    ok = TRUE;
                }
                break;
            case 1:
                if (arg->type == ERIPC_TYPE_BOOL)
                {
                    dev_caps->has_wifi = arg->value.b ? TRUE : FALSE;
                    ok = TRUE;
                }
                break;
            case 2:
                if (arg->type == ERIPC_TYPE_BOOL)
                {
                    dev_caps->has_bluetooth = arg->value.b ? TRUE : FALSE;
                    ok = TRUE;
                }
                break;
            case 3:
                if (arg->type == ERIPC_TYPE_BOOL)
                {
                    dev_caps->has_3g = arg->value.b ? TRUE : FALSE;
                    ok = TRUE;
                }
                break;
            default:
                ; // ignore
        }
        if (!ok)
        {
            ULOG_DEBUG_F("unexpected argument");
        }
    }
    return ok ? 0 : 1;
}

gboolean eripc_sysd_get_device_capabilities ( eripc_client_context_t *ccontext,
                                              eripc_device_caps_t *caps )
{
    int old_timeout;
    int timeout_set = 0;
    int retval = 0;
    eripc_error_t result;

    // set default reply
    caps->has_stylus    = FALSE;
    caps->has_wifi      = FALSE;
    caps->has_bluetooth = FALSE;
    caps->has_3g        = FALSE;
    
    result = eripc_get_timeout(ccontext->context, &old_timeout);
    if (result == ERIPC_ERROR_SUCCESS)
    {
        result = eripc_set_timeout(ccontext->context, 5*1000);
        timeout_set = (result == ERIPC_ERROR_SUCCESS);
    }
    
    MAKE_VARARG_WAIT_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysGetDeviceCapabilities",
                          parse_reply_capabilities(reply, caps),
                          ERIPC_TYPE_INVALID );
    
    if (timeout_set)
        eripc_set_timeout(ccontext->context, old_timeout);
    
    return retval;
}

gboolean eripc_sysd_conn_connect ( eripc_client_context_t *ccontext,
                                   const char *medium,
                                   const char *profile )
{
    MAKE_VARARG_CALL_3S(DBUS_SERVICE_SYSTEM_CONTROL, "connConnect", 
                        ccontext->service, medium, profile);
}

gboolean eripc_sysd_conn_disconnect ( eripc_client_context_t *ccontext )
{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "connDisconnect", ccontext->service);
}

gboolean eripc_sysd_conn_status_request ( eripc_client_context_t *ccontext )
{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "connConnectionStatusRequest", ccontext->name);
}