Server to test complex types (arrays, structs, dicts).
 
#include "Eldbus.h"
#include <Ecore.h>
 
#define BUS "com.profusion"
#define PATH "/com/profusion/Test"
#define IFACE "com.profusion.Test"
 
static char *resp2;
static int int32 = 35;
 
{
   const char *txt;
 
   printf("- receiveArray\n");
     {
        printf("Error on eldbus_message_arguments_get()\n");
        return reply;
     }
 
     printf("%s\n", txt);
   printf("}\n\n");
 
   return reply;
}
 
{
   int size, i = 0;
 
   printf("- receiveArrayOfStringIntWithSize\n{\n");
     {
        printf("Error on eldbus_message_arguments_get()\n");
        return reply;
     }
 
     {
        const char *txt;
        int num;
          {
             printf("Error on eldbus_message_arguments_get()\n");
             return reply;
          }
        printf("%s | %d\n", txt, num);
        i++;
     }
   printf("size in msg %d | size read %d\n", size, i);
   printf("}\n\n");
 
   return reply;
}
 
{
 
 
 
 
   return reply;
}
 
{
   char *type;
 
   printf("- sendVariantData\n{\n");
     {
        printf("Error on eldbus_message_arguments_get()\n");
        return reply;
     }
 
   if (type[1])
     {
        printf("It is a complex type, not handle yet.\n");
        free(type);
        return reply;
     }
 
   switch (type[0])
     {
      case 's':
      case 'o':
        {
           char *txt;
           printf("type = %c value = %s\n", type[0], txt);
           break;
        }
      case 'i':
        {
           int num;
           printf("type = %c value = %d\n", type[0], num);
           break;
        }
      default:
        {
           printf("Unhandled type\n");
        }
     }
 
   printf("}\n\n");
 
   free(type);
   return reply;
}
 
{
   int numbers[] = { 10, 9, 8, 7, 6, 5 };
 
   printf("- sendArrayInt\n\n");
 
 
   return reply;
}
 
{
   const char *array_string[5] = {"qqqq", "wwwww", "eeeeee", "rrrrr", "ttttt"};
   int i;
 
   printf("sendArray\n\n");
 
   for (i = 0; i < 5; i++)
 
   return reply;
}
 
{
   int num;
 
   printf("- plusOne\n\n");
     {
        printf("Error on eldbus_message_arguments_get()\n");
        return reply;
     }
   num++;
 
   return reply;
}
 
{
   int num1, num2;
 
     {
        printf("Error on eldbus_message_arguments_get()\n");
        return NULL;
     }
 
   printf("DoubleCountainer\n{\nArray1:\n");
     {
        printf("1 %d - 2 %d\n", num1, num2);
     }
 
   printf("Array2:\n");
     {
         printf("1 %d - 2 %d\n", num1, num2);
     }
   printf("}\n\n");
   return reply;
}
 
{
   printf("Properties_get - %s\n", propname);
   if (!strcmp(propname, "Resp2"))
   else if (!strcmp(propname, "text"))
   else if (!strcmp(propname, "int32"))
     {
        int32++;
     }
   else if (!strcmp(propname, "st"))
     {
     }
}
 
{
   char *type;
 
 
   if (!strcmp(propname, "int32"))
     {
        int num;
        if (type[0] != 'i')
          goto invalid_signature;
        printf("int32 was set to: %d, previously was: %d\n", num, int32);
        int32 = num;
     }
   else if (!strcmp(propname, "Resp2"))
     {
        const char *txt;
        if (type[0] != 's')
          goto invalid_signature;
        printf("Resp2 was set to: %s, previously was: %s\n", txt, resp2);
        free(resp2);
        resp2 = strdup(txt);
     }
   free(type);
 
invalid_signature:
   free(type);
                                  "Invalid type.");
}
 
      {
        "ReceiveArray", 
ELDBUS_ARGS({
"as", 
"array_of_strings"}),
 
        NULL, _receive_array, 0
      },
      {
        "ReceiveArrayOfStringIntWithSize",
        ELDBUS_ARGS({
"i", 
"size_of_array"}, {
"a(si)", 
"array"}),
 
        NULL, _receive_array_of_string_int_with_size, 0
      },
      {
        NULL, _send_variant, 0
      },
      {
       "ReceiveVariantData", NULL, 
ELDBUS_ARGS({
"v", 
"variant_data"}),
 
       _receive_variant, 0
      },
      {
        "SendArrayInt", NULL,
        ELDBUS_ARGS({
"ai", 
"array_of_int"}), _send_array_int, 0
 
      },
      {
        "SendArray", NULL, 
ELDBUS_ARGS({
"as", 
"array_string"}),
 
        _send_array, 0
      },
      {
      },
      {
        "DoubleContainner", 
ELDBUS_ARGS({
"a(ii)", 
"array1"}, {
"a(ii)", 
"array2"}),
 
        NULL, _double_container, 0
      },
      { }
};
 
      { "Resp2", "s", NULL, _properties_set, 0 },
      { "text", "s", NULL, NULL, 0 },
      { "int32", "i", NULL, _properties_set, 0 },
      { "st", "(ss)", NULL, NULL, 0 },
      { }
};
 
   IFACE, methods, NULL, properties, _properties_get, NULL
};
 
{
   Eldbus_Service_Interface *iface = data;
   eldbus_service_property_invalidate_set(iface, 
"Resp2", 
EINA_TRUE);
}
 
static void
{
   unsigned int reply;
   Eldbus_Service_Interface *iface = data;
 
     {
        printf("error on on_name_request\n");
        return;
     }
 
     {
        printf("error geting arguments on on_name_request\n");
        return;
     }
 
     {
        printf("error name already in use\n");
        return;
     }
 
}
 
int
main(void)
{
   Eldbus_Service_Interface *iface;
 
 
 
   resp2 = malloc(sizeof(char) * 5);
   strcpy(resp2, "test");
                      on_name_request, iface);
 
 
   free(resp2);
 
   return 0;
}
EAPI int ecore_shutdown(void)
Shuts down connections, signal handlers sockets etc.
Definition: ecore.c:366
EAPI int ecore_init(void)
Sets up connections, signal handlers, sockets etc.
Definition: ecore.c:225
#define ECORE_CALLBACK_RENEW
Return value to keep a callback.
Definition: Ecore_Common.h:153
void ecore_main_loop_begin(void)
Runs the application main loop.
Definition: ecore_main.c:1298
Ecore_Timer * ecore_timer_add(double in, Ecore_Task_Cb func, const void *data)
Creates a timer to call the given function in the given period of time.
Definition: ecore_timer.c:189
void * ecore_timer_del(Ecore_Timer *timer)
Deletes the specified timer from the timer list.
Definition: ecore_timer.c:238
Eo Ecore_Timer
A handle for timers.
Definition: Ecore_Common.h:3065
#define EINA_TRUE
boolean value TRUE (numerical value 1)
Definition: eina_types.h:539
unsigned char Eina_Bool
Type to mimic a boolean.
Definition: eina_types.h:527
#define EINA_C_ARRAY_LENGTH(arr)
Macro to return the array length of a standard c array.
Definition: eina_types.h:621
#define EINA_UNUSED
Used to indicate that a function parameter is purposely unused.
Definition: eina_types.h:339
#define ELDBUS_NAME_REQUEST_FLAG_DO_NOT_QUEUE
If we can not become the primary owner do not place us in the queue.
Definition: eldbus_freedesktop.h:12
Eldbus_Pending * eldbus_name_request(Eldbus_Connection *conn, const char *name, unsigned int flags, Eldbus_Message_Cb cb, const void *cb_data)
Send a "RequestName" method call in proxy.
Definition: eldbus_freedesktop.c:6
#define ELDBUS_NAME_REQUEST_REPLY_PRIMARY_OWNER
Service has become the primary owner of the requested name.
Definition: eldbus_freedesktop.h:15
void eldbus_connection_unref(Eldbus_Connection *conn)
Decrement connection reference count.
Definition: eldbus_core.c:1306
Eldbus_Connection * eldbus_connection_get(Eldbus_Connection_Type type)
Establish a connection to bus and integrate it with the ecore main loop.
Definition: eldbus_core.c:1102
struct _Eldbus_Message_Iter Eldbus_Message_Iter
Represents an iterator over a complex message type (array, dict, struct, or variant).
Definition: Eldbus.h:181
struct _Eldbus_Message Eldbus_Message
Represents the way data is sent and received in DBus.
Definition: Eldbus.h:173
EAPI int eldbus_shutdown(void)
Shutdown eldbus.
Definition: eldbus_core.c:246
struct _Eldbus_Pending Eldbus_Pending
Represents a message that has been sent but has not yet reached its destination.
Definition: Eldbus.h:188
EAPI int eldbus_init(void)
Initialize eldbus.
Definition: eldbus_core.c:128
Eina_Bool eldbus_message_iter_container_close(Eldbus_Message_Iter *iter, Eldbus_Message_Iter *sub)
Closes a container-typed value appended to the message.
Definition: eldbus_message.c:548
Eina_Bool eldbus_message_iter_get_and_next(Eldbus_Message_Iter *iter, char signature,...)
Useful when iterating over arrays.
Definition: eldbus_message.c:736
Eina_Bool eldbus_message_iter_fixed_array_append(Eldbus_Message_Iter *iter, int type, const void *array, unsigned int size)
Append a array of basic type with fixed size to Eldbus_Message_Iter.
Definition: eldbus_message.c:573
Eldbus_Message_Iter * eldbus_message_iter_get(const Eldbus_Message *msg)
Get the main Eldbus_Message_Iter from the Eldbus_Message.
Definition: eldbus_message.c:264
char * eldbus_message_iter_signature_get(Eldbus_Message_Iter *iter)
Returns the current signature of a message iterator.
Definition: eldbus_message.c:605
Eldbus_Message_Iter * eldbus_message_iter_container_new(Eldbus_Message_Iter *iter, int type, const char *contained_signature)
Create and append a typed iterator to another iterator.
Definition: eldbus_message.c:526
Eina_Bool eldbus_message_iter_arguments_append(Eldbus_Message_Iter *iter, const char *signature,...)
Append an argument into an Eldbus_Message_Iter.
Definition: eldbus_message.c:379
Eina_Bool eldbus_message_iter_arguments_get(Eldbus_Message_Iter *iter, const char *signature,...)
Get data from Eldbus_Message_Iter, for each complete type must have a pointer to store his value,...
Definition: eldbus_message.c:842
Eina_Bool eldbus_message_iter_basic_append(Eldbus_Message_Iter *iter, int type,...)
Append a basic type into an Eldbus_Iterator.
Definition: eldbus_message.c:558
Eldbus_Message * eldbus_message_method_return_new(const Eldbus_Message *msg)
Create a message that is a reply to a method call.
Definition: eldbus_message.c:895
Eina_Bool eldbus_message_error_get(const Eldbus_Message *msg, const char **name, const char **text)
Get the error text and name from a Eldbus_Message.
Definition: eldbus_message.c:233
Eldbus_Message * eldbus_message_error_new(const Eldbus_Message *msg, const char *error_name, const char *error_msg)
Create a new message that is an error reply to another message.
Definition: eldbus_message.c:875
Eina_Bool eldbus_message_arguments_get(const Eldbus_Message *msg, const char *signature,...)
Get the arguments from an Eldbus_Message.
Definition: eldbus_message.c:274
Eina_Bool eldbus_message_arguments_append(Eldbus_Message *msg, const char *signature,...)
Append arguments into an Eldbus_Message.
Definition: eldbus_message.c:495
void eldbus_service_interface_unregister(Eldbus_Service_Interface *iface)
Unregister a interface.
Definition: eldbus_service.c:1277
Eina_Bool eldbus_service_property_changed(const Eldbus_Service_Interface *interface, const char *name)
Add property to list of changed properties A DBus.PropertiesChanged signal will be sent in an idler w...
Definition: eldbus_service.c:1478
Eldbus_Service_Interface * eldbus_service_interface_register(Eldbus_Connection *conn, const char *path, const Eldbus_Service_Interface_Desc *desc)
Register an interface in the given path and connection.
Definition: eldbus_service.c:998
#define ELDBUS_ARGS(args...)
Used to insert complete types to signature of methods or signals.
Definition: eldbus_service.h:33
struct _Eldbus_Connection Eldbus_Connection
Represents a connection of one the type of connection with the DBus daemon.
Definition: Eldbus.h:227
Definition: eldbus_service.h:71
Definition: eldbus_service.h:94
Definition: eldbus_service.h:103