efl

1
#ifdef HAVE_CONFIG_H
2
#include "config.h"
3
#endif
4

5
#include <Ecore.h>
6

7
#include "eldbus_suite.h"
8
#include "eldbus_fake_server.h"
9

10
#define FAKE_SERVER_DATA_KEY "data"
11

12
static void _fake_server_name_request_cb(void *, const Eldbus_Message *, Eldbus_Pending *);
13
static Eina_Bool _fakse_server_property_get(const Eldbus_Service_Interface *, const char *, Eldbus_Message_Iter *, const Eldbus_Message *, Eldbus_Message **);
14
static Eldbus_Message *_fake_server_property_set(const Eldbus_Service_Interface *, const char *, Eldbus_Message_Iter *, const Eldbus_Message *);
15
static Eldbus_Message *_fake_server_sum(const Eldbus_Service_Interface *, const Eldbus_Message *);
16
static Eldbus_Message *_fake_server_ping(const Eldbus_Service_Interface *, const Eldbus_Message *);
17
static Eina_Bool _fake_server_send_pong_signal(void *);
18

19
static Eldbus_Connection *conn;
20

21
static const Eldbus_Method methods[] = {
22
   {
23
     FAKE_SERVER_SUM_METHOD_NAME, ELDBUS_ARGS({"i", "a"}, {"i", "b"}), ELDBUS_ARGS({"i", "result"}),
24
     _fake_server_sum,
25
      0
26
   },
27
   {
28
     FAKE_SERVER_PING_METHOD_NAME, ELDBUS_ARGS({"i", "a"}), NULL,
29
     _fake_server_ping,
30
      0
31
   },
32
   { NULL, NULL, NULL, NULL, 0 }
33
};
34

35
enum
36
{
37
   FAKE_SERVER_PONG_SIGNAL = 0
38
};
39

40
static const Eldbus_Signal signals[] = {
41
   [FAKE_SERVER_PONG_SIGNAL] = {FAKE_SERVER_PONG_SIGNAL_NAME, ELDBUS_ARGS({ "i", NULL }), 0},
42
   { NULL, NULL, 0 }
43
};
44

45
static const Eldbus_Property properties[] = {
46
   { FAKE_SERVER_READONLY_PROPERTY, "i", _fakse_server_property_get, NULL, 0 },
47
   { FAKE_SERVER_WRITEONLY_PROPERTY, "i", NULL, _fake_server_property_set, 0 },
48
   { FAKE_SERVER_READWRITE_PROPERTY, "i", _fakse_server_property_get, _fake_server_property_set, 0 },
49
   { NULL, NULL, NULL, NULL, 0 }
50
};
51

52
static const Eldbus_Service_Interface_Desc test_interface_desc = {
53
   FAKE_SERVER_INTERFACE, methods, signals, properties, NULL, NULL
54
};
55

56

57
Eldbus_Service_Interface *
58
fake_server_start(Fake_Server_Data *data, const char *name)
59
{
60
   ck_assert_ptr_ne(NULL, data);
61

62
   conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION);
63

64
   Eldbus_Service_Interface *interface = eldbus_service_interface_register(conn, FAKE_SERVER_PATH, &test_interface_desc);
65
   eldbus_service_object_data_set(interface, FAKE_SERVER_DATA_KEY, data);
66

67
   eldbus_name_request(conn, name, ELDBUS_NAME_REQUEST_FLAG_DO_NOT_QUEUE,
68
                       _fake_server_name_request_cb, interface);
69

70
   ecore_main_loop_begin();
71

72
   return interface;
73
}
74

75
void
76
fake_server_stop(Eldbus_Service_Interface *interface)
77
{
78
   eldbus_service_object_unregister(interface);
79
   eldbus_connection_unref(conn);
80
}
81

82
static Eldbus_Message *
83
_fake_server_sum(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
84
{
85
   int a, b;
86
   if (!eldbus_message_arguments_get(msg, "ii", &a, &b))
87
     return eldbus_message_error_new(msg, "Invalid arguments", "Error getting arguments..");
88

89
   int sum = a + b;
90

91
   Eldbus_Message *reply = eldbus_message_method_return_new(msg);
92
   eldbus_message_arguments_append(reply, "i", sum);
93
   return reply;
94
}
95

96
static Eldbus_Message *
97
_fake_server_ping(const Eldbus_Service_Interface *iface , const Eldbus_Message *msg)
98
{
99
   int a;
100
   if (!eldbus_message_arguments_get(msg, "i", &a))
101
     return eldbus_message_error_new(msg, "Invalid arguments", "Error getting arguments..");
102

103
   Fake_Server_Data *pd = eldbus_service_object_data_get(iface, FAKE_SERVER_DATA_KEY);
104
   ck_assert_ptr_ne(NULL, pd);
105

106
   pd->pong_response = a + 1;
107
   Ecore_Timer *timer = ecore_timer_add(0.1, _fake_server_send_pong_signal, iface);
108
   ck_assert_ptr_ne(NULL, timer);
109

110
   return NULL;
111
}
112

113
static Eina_Bool
114
_fake_server_send_pong_signal(void *data)
115
{
116
   Eldbus_Service_Interface *iface = (Eldbus_Service_Interface*)data;
117

118
   Fake_Server_Data *pd = eldbus_service_object_data_get(iface, FAKE_SERVER_DATA_KEY);
119
   ck_assert_ptr_ne(NULL, pd);
120

121
   eldbus_service_signal_emit(iface, FAKE_SERVER_PONG_SIGNAL, pd->pong_response);
122
   return ECORE_CALLBACK_CANCEL;
123
}
124

125
Eina_Bool
126
_fakse_server_property_get(const Eldbus_Service_Interface *iface,
127
                           const char *propname,
128
                           Eldbus_Message_Iter *iter,
129
                           const Eldbus_Message *request_msg EINA_UNUSED,
130
                           Eldbus_Message **error EINA_UNUSED)
131
{
132
   Fake_Server_Data *data = eldbus_service_object_data_get(iface, FAKE_SERVER_DATA_KEY);
133
   ck_assert_ptr_ne(NULL, data);
134

135
   if (strcmp(propname, FAKE_SERVER_READONLY_PROPERTY) == 0)
136
     eldbus_message_iter_arguments_append(iter, "i", data->readonly_property);
137
   else
138
   if (strcmp(propname, FAKE_SERVER_READWRITE_PROPERTY) == 0)
139
     eldbus_message_iter_arguments_append(iter, "i", data->readwrite_property);
140
   else
141
     return EINA_FALSE;
142

143
   return EINA_TRUE;
144
}
145

146
Eldbus_Message *
147
_fake_server_property_set(const Eldbus_Service_Interface *iface,
148
                          const char *propname,
149
                          Eldbus_Message_Iter *iter,
150
                          const Eldbus_Message *msg)
151
{
152
   Fake_Server_Data *data = eldbus_service_object_data_get(iface, FAKE_SERVER_DATA_KEY);
153
   ck_assert_ptr_ne(NULL, data);
154

155
   if (strcmp(propname, FAKE_SERVER_WRITEONLY_PROPERTY) == 0)
156
     {
157
        if (!eldbus_message_iter_arguments_get(iter, "i", &data->writeonly_property))
158
          ck_abort_msg("error getting iter arguments on _fake_server_property_set");
159
     }
160
   else
161
     {
162
        if (strcmp(propname, FAKE_SERVER_READWRITE_PROPERTY) == 0)
163
          {
164
             if (!eldbus_message_iter_arguments_get(iter, "i", &data->readwrite_property))
165
               ck_abort_msg("error getting iter arguments on _fake_server_property_set");
166
          }
167
        else
168
          return eldbus_message_error_new(msg, "Invalid property", "Invalid property.");
169
     }
170

171
   return eldbus_message_method_return_new(msg);
172
}
173

174
static void
175
_fake_server_name_request_cb(void *data EINA_UNUSED,
176
                             const Eldbus_Message *msg,
177
                             Eldbus_Pending *pending EINA_UNUSED)
178
{
179
   const char *name, *text;
180
   if (eldbus_message_error_get(msg, &name, &text))
181
     ck_abort_msg("error on _fake_server_name_request_cb: %s %s", name, text);
182

183
   unsigned int reply;
184
   if (!eldbus_message_arguments_get(msg, "u", &reply))
185
     ck_abort_msg("error geting arguments on _fake_server_name_request_cb");
186

187
   if (ELDBUS_NAME_REQUEST_REPLY_PRIMARY_OWNER != reply)
188
     {
189
        const char *errcode = "Unknown reply";
190
        switch (reply)
191
          {
192
           case ELDBUS_NAME_REQUEST_REPLY_IN_QUEUE:
193
             errcode = "Service could not become the primary owner and has "
194
                       "been placed in the queue";
195
             break;
196
           case ELDBUS_NAME_REQUEST_REPLY_EXISTS:
197
             errcode = "Service is already in the queue";
198
             break;
199
           case ELDBUS_NAME_REQUEST_REPLY_ALREADY_OWNER:
200
             errcode = "Service is already the primary owner";
201
             break;
202
           default: break;
203
          }
204
        ck_abort_msg( "Failed to start fake server: %s (%u)",
205
                 errcode, reply);
206
     }
207

208
   ecore_main_loop_quit();
209
}
210