settings/src/ipc.c

Go to the documentation of this file.

/*
 * File Name: ipc.c
 */

/*
 * This file is part of settings.
 *
 * settings 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.
 *
 * settings 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.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <sys/stat.h>
#include <unistd.h>
#include <gtk/gtk.h>

// ereader include files, between < >
#include <liberipc/eripc.h>
#include <liberipc/eripc_support.h>

// local include files, between " "
#include "log.h"
#include "i18n.h"
#include "ipc.h"
#include "settings.h"
#include "sd_settings.h"
#include "reset.h"
#include "datetime.h"

//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

// IPC settings
#define DBUS_APPL_NAME           PACKAGE_NAME
#define DBUS_SERVICE             "com.irexnet."DBUS_APPL_NAME
#define DBUS_PATH                "/com/irexnet/"DBUS_APPL_NAME
#define DBUS_INTERFACE           "com.irexnet."DBUS_APPL_NAME

// IPC popup menu
#define DBUS_SERVICE_SYSD        "com.irexnet.sysd"
#define DBUS_SERVICE_CTB         "com.irexnet.ctb"

// Popup menu strings

//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static eripc_client_context_t *eripcClient = NULL;
static gboolean                g_menu_blocked = FALSE;


//============================================================================
// Local Function Definitions
//============================================================================

extern void main_quit();

static void on_mounted           ( eripc_context_t          *context,
                                   const eripc_event_info_t *info,
                                   void                     *user_data );
                                 
static void on_unmounted         ( eripc_context_t          *context,
                                   const eripc_event_info_t *info,
                                   void                     *user_data );

static void on_changed_locale    ( eripc_context_t          *context,
                                   const eripc_event_info_t *info,
                                   void                     *user_data );

static void on_window_activated  ( eripc_context_t          *context,
                                   const eripc_event_info_t *info,
                                   void                     *user_data );

static void on_window_deactivated ( eripc_context_t          *context,
                                   const eripc_event_info_t *info,
                                   void                     *user_data );

static void on_changed_orientation ( eripc_context_t          *context,
                                     const eripc_event_info_t *info,
                                     void                     *user_data );

static gboolean ipc_menu_add_menu(const char *name,
                                  const char *label,
                                  const char *group1,
                                  const char *group2,
                                  const char *group3,
                                  const char *group4);

// Exported DBUS API list
static eripc_callback_function_t
service_functions[] = {
    { on_window_activated,  "activatedWindow",     NULL,              0 },
    { on_window_deactivated,"deactivatedWindow",   NULL,              0 },
    { on_mounted,           "sysVolumeMounted",    NULL,              0 },
    { on_mounted,           "sysVolumeMounted",    DBUS_SERVICE_SYSD, 0 },
    { on_unmounted,         "sysVolumeUnmounted",  DBUS_SERVICE_SYSD, 0 },
    { on_changed_locale,    "sysChangedLocale",    DBUS_SERVICE_SYSD, 0 },
    { on_changed_orientation, "sysChangedOrientation",  DBUS_SERVICE_SYSD, 0 },
    { NULL, NULL, NULL, 0 }  // end of list
};


//============================================================================
// Functions Implementation
//============================================================================

gboolean ipc_set_services()
{
    eripcClient = eripc_client_context_new(
                    DBUS_APPL_NAME,
                    "1.0",
                    DBUS_SERVICE,
                    DBUS_PATH,
                    DBUS_INTERFACE,
                    service_functions);

    return TRUE;
}


void ipc_unset_services()
{
    eripc_client_context_free(eripcClient, service_functions);
}


void ipc_sys_startup_complete (int xid)
{
    eripc_sysd_startup_complete( eripcClient, getpid(), FALSE, xid);
}


gboolean ipc_menu_show_menu( const char *name )
{
    return eripc_menu_show_menu(eripcClient, name);
}


gboolean ipc_remove_menu( const char *name )
{
    return eripc_menu_remove_menu(eripcClient, name);
}


gboolean ipc_menu_popup(const char* state)
{
    return eripc_sysd_set_menu_state(eripcClient, state);
}


gboolean ipc_sys_busy( gboolean look_busy )
{
    if (look_busy)
        return eripc_sysd_set_busy(eripcClient, "delaydialog", NULL);
    else
        return eripc_sysd_reset_busy(eripcClient);
}


gboolean ipc_set_stylus(const char* state)
{
    g_return_val_if_fail( (state != NULL), FALSE);
    return eripc_menu_set_statusitem_state(eripcClient, "statusbar_stylus", state);
}


void menu_init()
{
    LOGPRINTF("entry");
    
    ipc_menu_add_menu(SETTINGS_MENU, _("Menu"), NULL, NULL, NULL, NULL);

    ipc_menu_show_menu(SETTINGS_MENU);
}


gboolean get_device_capabilities(gboolean* has_stylus,
                                 gboolean* has_wifi,
                                 gboolean* has_bluetooth,
                                 gboolean* has_3g)
{
    eripc_device_caps_t er_dev_caps;

    eripc_sysd_get_device_capabilities( eripcClient, &er_dev_caps );

    *has_stylus = er_dev_caps.has_stylus;
    *has_wifi = er_dev_caps.has_wifi;
    *has_bluetooth = er_dev_caps.has_bluetooth;
    *has_3g = er_dev_caps.has_3g;

    return TRUE;
}


void mount_sd_card()
{
    eripc_sysd_mount_sd_card(eripcClient, FALSE);
}


void unmount_sd_card()
{
    eripc_sysd_unmount_sd_card(eripcClient);
}



static gboolean ipc_menu_add_menu(const char *name,
                                  const char *label,
                                  const char *group1,
                                  const char *group2,
                                  const char *group3,
                                  const char *group4)
{
    return eripc_menu_add_menu(eripcClient, name, group1, group2, group3, group4);
}


//============================================================================
// Local Functions Implementation
//============================================================================

// storage device mounted
static void on_mounted(eripc_context_t          *context,
                       const eripc_event_info_t *info,
                       void                     *user_data)
{
    LOGPRINTF("entry");

    g_return_if_fail(info->args);
    g_return_if_fail(info->args[0].type == ERIPC_TYPE_STRING);

    const eripc_arg_t *arg_array  = info->args;
    const char        *mountpoint = arg_array[0].value.s;

    LOGPRINTF("mountpoint=%s", mountpoint);
    if (mountpoint && strcmp(mountpoint, SD_CARD_MOUNTPOINT) == 0)
    {
        LOGPRINTF("Calling sd_card_mounted(TRUE)\n");
        sd_card_mounted(TRUE);
        reset_sdcard_mounted(TRUE);
    }
}


// storage device unmounted
static void on_unmounted(eripc_context_t          *context,
                         const eripc_event_info_t *info,
                         void                     *user_data)
{
    LOGPRINTF("entry");

    g_return_if_fail(info->args);
    g_return_if_fail(info->args[0].type == ERIPC_TYPE_STRING);

    const eripc_arg_t *arg_array  = info->args;
    const char        *mountpoint = arg_array[0].value.s;

    LOGPRINTF("mountpoint=%s", mountpoint);
    if (mountpoint && strcmp(mountpoint, SD_CARD_MOUNTPOINT) == 0)
    {
        LOGPRINTF("Calling sd_card_mounted(FALSE)\n");
        sd_card_mounted(FALSE);
        reset_sdcard_mounted(FALSE);
    }
}


static void on_window_activated(eripc_context_t          *context,
                                const eripc_event_info_t *info,
                                void                     *user_data)
{
    LOGPRINTF("entry");
    gboolean          result      = FALSE; 
    const eripc_arg_t *arg_array  = info->args;

    if (arg_array[0].type == ERIPC_TYPE_INT)
    {
        ipc_menu_show_menu(SETTINGS_MENU);
        result = TRUE;
    }

    // return result to caller
    eripc_reply_bool(context, info->message_id, result);
}

static void on_window_deactivated(eripc_context_t          *context,
                                const eripc_event_info_t *info,
                                void                     *user_data)
{
    LOGPRINTF("entry");
    gboolean          result      = FALSE; 
    const eripc_arg_t *arg_array  = info->args;

    if (arg_array[0].type == ERIPC_TYPE_INT)
    {
        // close application when window is set to the background
        main_quit();
        result = TRUE;
    }

    // return result to caller
    eripc_reply_bool(context, info->message_id, result);
}


static void on_changed_locale (eripc_context_t          *context,
                               const eripc_event_info_t *info,
                               void                     *user_data)
{
    LOGPRINTF("entry");
    const eripc_arg_t *arg_array = info->args;

    if (arg_array[0].type == ERIPC_TYPE_STRING)
    {
        const char *locale = arg_array[0].value.s;
        if (locale)
        {
            const char *old_locale = g_getenv("LANG");
            
            if (!old_locale || (strcmp(old_locale, locale) != 0))
            {
                LOGPRINTF("Locale has changed to %s", locale);

                // set locale in environment 
                g_setenv("LANG", locale, TRUE);
                setlocale(LC_ALL, "");
            }
        }
    }
}


// open url
gint ipc_sys_open_url ( const gchar  *url,
        const gchar  *label,
        const gchar  *back_text,
        gchar        **err_message )
{
    LOGPRINTF("entry: url [%s] label [%s] back_text [%s]",
                      url,     label,     back_text     );
    g_assert( url && *url );
    return eripc_sysd_open_url( eripcClient, url, label, back_text, err_message );
}


// start task (application)
gint ipc_sys_start_task ( const gchar  *cmd_line,
        const gchar  *work_dir,
        const gchar  *label,
        const gchar  *thumbnail_path,
        gchar        **err_message )
{
    LOGPRINTF("entry: cmd_line [%s] work_dir [%s] label [%s] thumbnail_path [%s]",
            cmd_line,     work_dir,     label,     thumbnail_path       );
    g_assert( cmd_line && *cmd_line );
    return eripc_sysd_start_task( eripcClient,
            cmd_line,
            work_dir,
            label,
            thumbnail_path,
            err_message);
}


// stop task (application)
gboolean ipc_sys_stop_task ( const gchar  *cmd_line )
{
    LOGPRINTF("entry: cmd_line [%s]", cmd_line );
    g_assert( cmd_line && *cmd_line );
    return eripc_sysd_stop_task( eripcClient, cmd_line );
}


gboolean ipc_menu_block( void )
{
    if (g_menu_blocked)
    {
        return FALSE;
    }
    g_menu_blocked = TRUE;
    return eripc_sysd_set_menu_state(eripcClient, "block");
}


gboolean ipc_menu_unblock( void )
{
    if (!g_menu_blocked)
    {
        return FALSE;
    }
    g_menu_blocked = FALSE;
    return eripc_sysd_set_menu_state(eripcClient, "unblock");
}



// Function: ipc_sys_is_in_portrait_mode()
//
// Return value: False -> the device is in landscape mode i.e. flipbar up should be interpreted as previous page.
//               True  ->  the device is in portrait mode i.e. flipbar interpretation should depend on sys_is_pageturn_inverted result.
// Intended use: during application initialisation

gboolean ipc_sys_is_in_portrait_mode(void)
{

    gboolean result = TRUE;

    eripc_error_t retval;
    eripc_event_info_t* info = NULL;

    LOGPRINTF("entry");

    retval = eripc_send_varargs_and_wait(eripcClient->context,
            &info,
            ERIPC_BUS_SESSION,
            DBUS_SERVICE_SYSD,
            "sysGetOrientation",
            ERIPC_TYPE_INVALID);

    if (retval != ERIPC_ERROR_SUCCESS)
    {
        ERRORPRINTF("Error launching eripc handler");
    }
    else if (info == NULL || info->args == NULL)
    {
        ERRORPRINTF("sysd returns OK but no reply structure");
    }
    else
    {
        const eripc_arg_t *arg_array = info->args;

        if (arg_array[0].type == ERIPC_TYPE_STRING)
        {
            if ( strcmp("portrait", arg_array[0].value.s) == 0 )
            {
                result = TRUE;
            }
            else
            {
                result = FALSE;
            }
        }
        else
        {
            result = FALSE ;
        }
    }
    eripc_event_info_free(eripcClient->context, info);
    return result;
}

/* @brief Called when the display's orientation has changed
 *
 * Application may need to adapt its screen size, coordinates and/or origin.
 * Possible values: "portrait", "landscape_clockwise", "landscape_anticlockwise"
 */
static void on_changed_orientation ( eripc_context_t          *context,
        const eripc_event_info_t *info,
        void                     *user_data )
{
    LOGPRINTF("entry");
    const eripc_arg_t *arg_array = info->args;

    if (arg_array[0].type == ERIPC_TYPE_STRING)
    {
        const char *orientation = arg_array[0].value.s;
        if (orientation)
        {
            //call orientation check callback
            if ( 0 == strcasecmp( orientation, "portrait") )
            {
                datetime_set_orientation(TRUE);
            }
            else 
            {
                datetime_set_orientation(FALSE);
            }
        }
    }
}

gboolean ipc_get_battery_state(gint *level, gchar **state, gint *timeleft)
{
    eripc_error_t retval;
    eripc_event_info_t *info = NULL;
    gboolean result = FALSE;
    
    LOGPRINTF("entry");
    
    retval = eripc_send_varargs_and_wait(eripcClient->context,
                                         &info,
                                         ERIPC_BUS_SESSION,
                                         DBUS_SERVICE_SYSD,
                                         "sysGetBatteryState",
                                         ERIPC_TYPE_INVALID);

    if (retval == ERIPC_ERROR_SUCCESS) 
    {
        const eripc_arg_t *arg_array = info->args;
        
        if ((arg_array[0].type == ERIPC_TYPE_INT) && 
            (arg_array[1].type == ERIPC_TYPE_STRING) &&
            (arg_array[2].type == ERIPC_TYPE_INT))
        {
            *level = arg_array[0].value.i;
            *state = g_strdup(arg_array[1].value.s);
            if (timeleft != NULL)
            {
                *timeleft = arg_array[2].value.i;
                LOGPRINTF("Reply received: battery at %d%% %s, time left: %d", *level, *state, *timeleft);
            }
            else
            {
                LOGPRINTF("Reply received: battery at %d%% %s", *level, *state);
            }
            
            result = TRUE;
        }
    }
    else
    {
        ERRORPRINTF("Error launching eripc handler: %s", eripc_error_string(retval));
    }
    
    eripc_event_info_free(eripcClient->context, info);
    return result;
}