efl

1
//Compile with:
2
// gcc -o client client.c `pkg-config --cflags --libs eldbus ecore eina`
3

4
#include "Eldbus.h"
5
#include <Ecore.h>
6

7
#define BUS "org.Enlightenment"
8
#define PATH "/org/enlightenment"
9
#define INTERFACE "org.enlightenment.Test"
10
#define NTESTS 8
11

12
static int _client_log_dom = -1;
13
#define ERR(...)      EINA_LOG_DOM_ERR(_client_log_dom, __VA_ARGS__)
14

15
static Eldbus_Connection *conn = NULL;
16
static Ecore_Timer *timeout = NULL;
17

18
static void
19
_on_alive(void *context EINA_UNUSED, const Eldbus_Message *msg EINA_UNUSED)
20
{
21
   printf("Alive\n\n");
22
}
23

24
static void
25
_on_hello(void *context EINA_UNUSED, const Eldbus_Message *msg)
26
{
27
   const char *txt;
28
   if (eldbus_message_arguments_get(msg, "s", &txt))
29
     printf("%s\n", txt);
30
}
31

32
#include <inttypes.h>
33

34
static struct expected
35
{
36
   Eina_Bool b;
37
   uint8_t y;
38
   uint32_t u;
39
   int32_t i;
40
   int16_t n;
41
   double d;
42
   const char *s;
43
} expected = {
44
   .b = EINA_TRUE,
45
   .y = 0xAA,
46
   .u = 0xFFFFFFFF,
47
   .i = 0xFFFFFFFF,
48
   .n = 0xFFFF,
49
   .d = 3.1415926,
50
   .s = "test",
51
};
52

53
static void
54
test(void)
55
{
56
   static int n = 0;
57
   n++;
58
   if (n >= NTESTS)
59
     {
60
        printf("Passed in all tests\nExiting...\n");
61
        eldbus_connection_unref(conn);
62
        conn = NULL;
63
        ecore_main_loop_quit();
64
     }
65
   else
66
    printf("Passed in %d/%d tests\n", n, NTESTS);
67
}
68

69
static void
70
_on_send_bool(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
71
{
72
   const char *errname, *errmsg;
73
   Eina_Bool b;
74

75
   if (eldbus_message_error_get(msg, &errname, &errmsg))
76
     {
77
        ERR("%s %s", errname, errmsg);
78
        return;
79
     }
80

81
   if (!eldbus_message_arguments_get(msg, "b", &b))
82
     {
83
        ERR("Could not get entry contents");
84
        return;
85
     }
86

87
   if (b != expected.b)
88
     {
89
        ERR("Bool value doesn't match");
90
        return;
91
     }
92

93
   test();
94
}
95

96
static void
97
_on_send_byte(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
98
{
99
   const char *errname, *errmsg;
100
   uint8_t y;
101

102
   if (eldbus_message_error_get(msg, &errname, &errmsg))
103
     {
104
        ERR("%s %s", errname, errmsg);
105
        return;
106
     }
107

108
   if (!eldbus_message_arguments_get(msg, "y", &y))
109
     {
110
        ERR("Could not get entry contents");
111
        return;
112
     }
113

114
   if (y != expected.y)
115
     {
116
        ERR("Byte value doesn't match expected value");
117
        return;
118
     }
119

120
   test();
121
}
122

123
static void
124
_on_send_uint32(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
125
{
126
   const char *errname, *errmsg;
127
   unsigned int u;
128

129
   if (eldbus_message_error_get(msg, &errname, &errmsg))
130
     {
131
        ERR("%s %s", errname, errmsg);
132
        return;
133
     }
134

135
   if (!eldbus_message_arguments_get(msg, "u", &u))
136
     {
137
        ERR("Could not get entry contents");
138
        return;
139
     }
140

141
   if (u != expected.u)
142
     {
143
        ERR("Uint32 value doesn't match expected value");
144
        return;
145
     }
146

147
   test();
148
}
149

150
static void
151
_on_send_int32(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
152
{
153
   const char *errname, *errmsg;
154
   int32_t i;
155

156
   if (eldbus_message_error_get(msg, &errname, &errmsg))
157
     {
158
        ERR("%s %s", errname, errmsg);
159
        return;
160
     }
161

162
   if (!eldbus_message_arguments_get(msg, "i", &i))
163
     {
164
        ERR("Could not get entry contents");
165
        return;
166
     }
167

168
   if (i != expected.i)
169
     {
170
        ERR("Int32 value doesn't match expected value");
171
        return;
172
     }
173

174
   test();
175
}
176

177
static void
178
_on_send_int16(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
179
{
180
   const char *errname, *errmsg;
181
   int16_t n;
182

183
   if (eldbus_message_error_get(msg, &errname, &errmsg))
184
     {
185
        ERR("%s %s", errname, errmsg);
186
        return;
187
     }
188

189
   if (!eldbus_message_arguments_get(msg, "n", &n))
190
     {
191
        ERR("Could not get entry contents");
192
        return;
193
     }
194

195
   if (n != expected.n)
196
     {
197
        ERR("Int16 value doesn't match expected value");
198
        return;
199
     }
200

201
   test();
202
}
203

204
static void
205
_on_send_double(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
206
{
207
   const char *errname, *errmsg;
208
   double d;
209

210
   if (eldbus_message_error_get(msg, &errname, &errmsg))
211
     {
212
        ERR("%s %s", errname, errmsg);
213
        return;
214
     }
215

216
   if (!eldbus_message_arguments_get(msg, "d", &d))
217
     {
218
        ERR("Could not get entry contents");
219
        return;
220
     }
221

222
   if (!EINA_DBL_EQ(d, expected.d))
223
     {
224
        ERR("Double value doesn't match expected value");
225
        return;
226
     }
227

228
   test();
229
}
230

231
static void
232
_on_send_string(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
233
{
234
   const char *errname, *errmsg;
235
   char *s;
236

237
   if (eldbus_message_error_get(msg, &errname, &errmsg))
238
     {
239
        ERR("%s %s", errname, errmsg);
240
        return;
241
     }
242

243
   if (!eldbus_message_arguments_get(msg, "s", &s))
244
     {
245
        ERR("Could not get entry contents");
246
        return;
247
     }
248

249
   if (strcmp(s, expected.s) != 0)
250
     {
251
        ERR("Uint32 value doesn't match expected value");
252
        return;
253
     }
254

255
   test();
256
}
257

258
static void
259
_on_async_test(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
260
{
261
   const char *errname, *errmsg;
262

263
   if (eldbus_message_error_get(msg, &errname, &errmsg))
264
     {
265
        ERR("%s %s", errname, errmsg);
266
        return;
267
     }
268

269
   test();
270
}
271

272
static void
273
on_name_owner_changed(void *data EINA_UNUSED, const char *bus, const char *old_id, const char *new_id EINA_UNUSED)
274
{
275
   printf("Bus=%s | old=%s | new=%s\n", bus, old_id, new_id);
276
}
277

278
static Eina_Bool
279
finish(void *data EINA_UNUSED)
280
{
281
   ERR("Timeout\nSome error happened or server is taking too much time to respond.");
282
   ecore_main_loop_quit();
283
   timeout = NULL;
284
   return ECORE_CALLBACK_CANCEL;
285
}
286

287
int
288
main(void)
289
{
290
   Eldbus_Object *obj;
291
   Eldbus_Proxy *proxy;
292

293
   eina_init();
294
   _client_log_dom = eina_log_domain_register("client", EINA_COLOR_CYAN);
295
   if (_client_log_dom < 0)
296
     {
297
        EINA_LOG_ERR("Unable to create 'client' log domain");
298
        goto exit_eina;
299
     }
300

301
   ecore_init();
302
   eldbus_init();
303

304
   conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
305

306
   obj = eldbus_object_get(conn, BUS, PATH);
307
   proxy = eldbus_proxy_get(obj, INTERFACE);
308
   eldbus_proxy_signal_handler_add(proxy, "Alive", _on_alive, NULL);
309
   eldbus_proxy_signal_handler_add(proxy, "Hello", _on_hello, NULL);
310

311
   eldbus_proxy_call(proxy, "SendBool", _on_send_bool, NULL, -1, "b",
312
                    expected.b);
313
   eldbus_proxy_call(proxy, "SendByte", _on_send_byte, NULL, -1, "y",
314
                    expected.y);
315
   eldbus_proxy_call(proxy, "SendUint32", _on_send_uint32, NULL, -1, "u",
316
                    expected.u);
317
   eldbus_proxy_call(proxy, "SendInt32", _on_send_int32, NULL, -1, "i",
318
                    expected.i);
319
   eldbus_proxy_call(proxy, "SendInt16", _on_send_int16, NULL, -1, "n",
320
                    expected.n);
321
   eldbus_proxy_call(proxy, "SendDouble", _on_send_double, NULL, -1, "d",
322
                    expected.d);
323
   eldbus_proxy_call(proxy, "SendString", _on_send_string, NULL, -1, "s",
324
                    expected.s);
325
   eldbus_proxy_call(proxy, "AsyncTest", _on_async_test, NULL, -1, "");
326

327
   eldbus_name_owner_changed_callback_add(conn, BUS, on_name_owner_changed,
328
                                         conn, EINA_TRUE);
329
   timeout = ecore_timer_add(30, finish, NULL);
330

331
   ecore_main_loop_begin();
332

333
   if (timeout)
334
      ecore_timer_del(timeout);
335
   if (conn)
336
      eldbus_connection_unref(conn);
337

338
   eldbus_shutdown();
339
   ecore_shutdown();
340

341
   eina_log_domain_unregister(_client_log_dom);
342
exit_eina:
343
   eina_shutdown();
344

345
   return 0;
346
}
347