menuapitest.c

Go to the documentation of this file.

/*
 * File Name: menuapi.c
 */

/*
 * This file is part of popupmenu.
 *
 * popupmenu 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.
 *
 * popupmenu 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 "config.h"

#include <glib.h>
#include <stdlib.h> 
#include <getopt.h>
#include <string.h>

#include <liberipc/eripc.h>

#define DBUS_SERVICE            "com.irexnet.popupmenu"

static gboolean verbose_flag = FALSE;
int activated_handler = -1;
eripc_context_t *eripcContext = NULL;

enum cmd_type
{
  CMD_UNKNOWN,
  CMD_ADD,
  CMD_REMOVE,
  CMD_SET_STATE,
  CMD_SHOW,
  CMD_HIDE,
  NUM_CMD
};

enum prop_type
{
  PROP_UNKNOWN,
  PROP_GROUP,
  PROP_STATUSITEM,
  PROP_MENUITEM,
  PROP_MENU,
  NUM_PROP
};

static const gchar* eripcErrorStr(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";
    }
}

/*
static void add_item(eripc_context_t *ctx, const char *name, const char *parent,
                    const char *label, const char *img, const char *img_selected, const char *img_disabled) 
{
    eripc_error_t result;
    
    g_return_if_fail(name != NULL);
    g_return_if_fail(parent != NULL);
    g_return_if_fail(label != NULL);
    g_return_if_fail(img != NULL);
    g_return_if_fail(img_selected != NULL);
    g_return_if_fail(img_disabled != NULL);

    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "addItem",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_STRING, parent,
                                ERIPC_TYPE_STRING, label,
                                ERIPC_TYPE_STRING, img,
                                ERIPC_TYPE_STRING, img_selected,
                                ERIPC_TYPE_STRING, img_disabled,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
    {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    } 
}


static void add_menu(eripc_context_t *ctx, const char *name, const char *group1,
                    const char *group2, const char *group3, const char *group4) 
{
    eripc_error_t result;
    
    g_return_if_fail(name != NULL);
    g_return_if_fail(group1 != NULL);
    g_return_if_fail(group2 != NULL);
    g_return_if_fail(group3 != NULL);
    g_return_if_fail(group4 != NULL);

    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "addMenu",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_STRING, group1,
                                ERIPC_TYPE_STRING, group2,
                                ERIPC_TYPE_STRING, group3,
                                ERIPC_TYPE_STRING, group4,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
    {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    } 
}
*/

static void set_item_state(eripc_context_t *ctx, const char *iname, const char *pname, const char *state) 
{
    eripc_error_t result;
    
    g_return_if_fail(pname != NULL);
    g_return_if_fail(state != NULL);
    
    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "setItemState",
                                ERIPC_TYPE_STRING, iname,
                                ERIPC_TYPE_STRING, pname,
                                ERIPC_TYPE_STRING, state,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void set_group_state(eripc_context_t *ctx, const char *pname, const char *state) 
{
    eripc_error_t result;
    
    g_return_if_fail(pname != NULL);
    g_return_if_fail(state != NULL);
    
    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "setGroupState",
                                ERIPC_TYPE_STRING, pname,
                                ERIPC_TYPE_STRING, state,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}

static void set_popup_state(eripc_context_t *ctx, const char *state) 
{
    eripc_error_t result;
    
    g_return_if_fail(state != NULL);
  
    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "setPopupState",
                                ERIPC_TYPE_STRING, state,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void set_statusitem_state(eripc_context_t *ctx, const char *iname, const char *state) 
{
    eripc_error_t result;
    
    g_return_if_fail(iname != NULL);
    g_return_if_fail(state != NULL);

    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "setStatusItemState",
                                ERIPC_TYPE_STRING, iname,
                                ERIPC_TYPE_STRING, state,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void show_statusitem(eripc_context_t *ctx, const char *iname) 
{
    eripc_error_t result;
    
    g_return_if_fail(iname != NULL);
    
    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "showStatusItem",
                                ERIPC_TYPE_STRING, iname,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void hide_statusitem(eripc_context_t *ctx, const char *iname) 
{
    eripc_error_t result;
    
    g_return_if_fail(iname != NULL);

    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "hideStatusItem",
                                ERIPC_TYPE_STRING, iname,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void remove_group(eripc_context_t *ctx, const char *name) 
{
    eripc_error_t result;
    
    g_return_if_fail(name != NULL);

    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "removeGroup",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void remove_item(eripc_context_t *ctx, const char *name, const char *parent) 
{
    eripc_error_t result;
    
    g_return_if_fail(name != NULL);

    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "removeItem",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_STRING, parent,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}

static void remove_menu(eripc_context_t *ctx, const char *name) 
{
    eripc_error_t result;
    
    g_return_if_fail(name != NULL);
    
    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "removeMenu",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void show_menu(eripc_context_t *ctx, const char *name) 
{
    eripc_error_t result;
    
    g_return_if_fail(name != NULL);
        
    result = eripc_send_varargs_and_wait(ctx,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "showMenu",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
    {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}

void usage()
{
    g_print("Usage: %s -r -s -n newstate -i item -g group -m menu -t statusitem\n", "menuapitest");
    g_print("\t-r --remove\t\tRemove command, followed by item, group or menu\n");
    g_print("\t-s --show\t\tShow command, followed by menu\n");
    g_print("\t-n --newstate <newstate>\tSet new state to:\n");
    g_print("\t\t\titem:\tNORMAL, SELECTED, DISABLED\n");
    g_print("\t\t\tgroup:\tNORMAL, DISABLED\n");
    g_print("\t\t\tmenu:\tSHOW, HIDE, TOGGLE\n");
    g_print("\t\t\tstatus:\tname of status\n");
    g_print("\t-i --item=<item>\tItem to operate command (group must be specified first)\n");
    g_print("\t-g --group=<group>\tGroup to operate command\n");
    g_print("\t-m --menu[=<menu>]\tMenu to operate command (menu name not required for 'newstate')\n");
    g_print("\t-t --statusitem=<statusitem>\tStatus item to operate command\n");
    g_print("Example: %s --show --menu=uds_menu_reading\n", "menuapitest");
    g_print("Example: %s --newstate=SELECTED --group=system --item=rotate_screen\n", "menuapitest");
    g_print("Example: %s --newstate=cha040 --statusitem=battery\n", "menuapitest");
    g_print("Example: %s --newstate=TOGGLE --menu\n", "menuapitest");
}

int main (int argc, char **argv)
{
    int c;
    
    enum cmd_type command = CMD_UNKNOWN;
    enum prop_type property = PROP_UNKNOWN;
    GMainLoop *gloop = NULL;
    GString *iname = NULL;
    GString *pname = NULL;
    GString *state = NULL;

    gloop = g_main_loop_new(NULL, FALSE);
    eripcContext = eripc_init("menuapitest", "1.0", NULL);
    if (eripcContext == NULL) 
    {
       g_error("Failed to initialize IPC API\n");
    }

    eripc_set_timeout(eripcContext, 2000);

    while (1)
    {
       static struct option long_options[] =
         {
           /* These options set a flag. */
           {"verbose", no_argument,       &verbose_flag, TRUE},
           /* These options don't set a flag.
              We distinguish them by their indices. */
           {"remove",   no_argument,       NULL, 'r'},
           {"show",     no_argument,       NULL, 's'},
           {"hide",     no_argument,       NULL, 'h'},
           {"item",     required_argument, NULL, 'i'},
           {"group",    required_argument, NULL, 'g'},
           {"menu",     optional_argument, NULL, 'm'},
           {"newstate", required_argument, NULL, 'n'},
           {"statusitem",required_argument,NULL, 't'},
           {0, 0, 0, 0}
         };
       /* getopt_long stores the option index here. */
       int option_index = 0;
 
        c = getopt_long (argc, argv, "rshi:g:n:t:m::", long_options, &option_index);
 
       /* Detect the end of the options. */
       if (c == -1)
         break;
 
       switch (c)
         {
         case 0:
           /* If this option set a flag, do nothing else now. */
           if (long_options[option_index].flag != 0)
             break;
           g_print("option %s", long_options[option_index].name);
           if (optarg)
             g_print(" with arg %s", optarg);
           g_print("\n");
           break;
 
         case 'r':
           command = CMD_REMOVE;
           g_print("option -r\n");
           break;
 
         case 's':
           command = CMD_SHOW;
           g_print("option -s\n");
           break;
 
         case 'h':
           command = CMD_HIDE;
           g_print("option -h\n");
           break;
                     
         case 'i':
           if (pname != NULL)
           {
             g_print("option -i with value `%s'\n", optarg);
             property = PROP_MENUITEM;
             iname = g_string_new(optarg);
           }
           else 
           {
             g_error("option -g must be set before -i\n");
           }
           break;
 
         case 't':
           g_print("option -t with value `%s'\n", optarg);
           property = PROP_STATUSITEM;
           iname = g_string_new(optarg);
           break;
                     
         case 'g':
           g_print("option -g with value `%s'\n", optarg);
           property = PROP_GROUP;
           pname = g_string_new(optarg);
           break;
 
         case 'm':
           pname = g_string_new(optarg);
           if (optarg != NULL)
           {
                g_print("option -m with value `%s'\n", optarg);
           }
           else
           {
                g_print("option -m\n");
           }
                     
           if (property==PROP_UNKNOWN) 
           {
               property = PROP_MENU;
           }
           break;
 
         case 'n':
           g_print("option -n with value `%s'\n", optarg);
           command = CMD_SET_STATE;
           state = g_string_new(optarg);
           break;
 
         case '?':
           /* getopt_long already printed an error message. */
           usage();
           break;
 
         default:
           usage();
           break;
         }
    }
 
   if (verbose_flag)
     g_print("verbose flag is set");
 
   if (optind < argc)
     {
       g_print("unsupported options: ");
       while (optind < argc)
         g_print("%s ", argv[optind++]);
       g_print("\n");
     }
 
    switch (command)
    {
    case CMD_REMOVE:
      switch (property)
      {
      case PROP_MENUITEM:
        remove_item(eripcContext, iname->str, pname->str);
        break;
      case PROP_GROUP:
        remove_group(eripcContext, pname->str);
        break;
      case PROP_MENU:
        remove_menu(eripcContext, pname->str);
        break;
      default:
        break;
      }
      break;
        
    case CMD_SET_STATE:
      switch (property)
      {
      case PROP_STATUSITEM:
        set_statusitem_state(eripcContext, iname->str, state->str);
        break;
      case PROP_MENUITEM:
        set_item_state(eripcContext, iname->str, pname->str, state->str);
        break;
      case PROP_GROUP:
        set_group_state(eripcContext, pname->str, state->str);
        break;
      case PROP_MENU:
        set_popup_state(eripcContext, state->str);
        break;
      default:
        break;
      }
      break;
        
    case CMD_SHOW:
      switch (property)
      {
      case PROP_MENU:
        show_menu(eripcContext, pname->str);     
        break;
      case PROP_STATUSITEM:
        show_statusitem(eripcContext, iname->str);
        break;
      default:
        break;
      }
      break;
        
    case CMD_HIDE:
      switch (property)
      {
      case PROP_STATUSITEM:
        hide_statusitem(eripcContext, iname->str);
        break;
      default:
        break;
      }
      break;
        
    default:
      break;
    }
    
    eripcContext = NULL;
    return EXIT_SUCCESS;    
}