← Back to branch summary

~charlesk/indicator-application/lp-1197788

« back to all changes in this revision

Viewing changes to tests/test-approver.c

  • Committer: Tarmac
  • Author(s): Marco Trevisan (Treviño)
  • Date: 2012-12-18 20:22:45 UTC
  • mfrom: (236.1.1 indicator-application)
  • Revision ID: tarmac-20121218202245-wkeq4qqxrxmw2947
Indicator-application: removing the deprecated approver support.

Approved by Ted Gould, PS Jenkins bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-approver.c
1
 
#include <glib.h>
2
 
#include <glib-object.h>
3
 
#include <gio/gio.h>
4
 
 
5
 
#include "dbus-shared.h"
6
 
#include "libappindicator/app-indicator.h"
7
 
#include "gen-notification-approver.xml.h"
8
 
 
9
 
#define APPROVER_PATH  "/my/approver"
10
 
 
11
 
#define INDICATOR_ID        "test-indicator-id"
12
 
#define INDICATOR_ICON      "test-indicator-icon-name"
13
 
#define INDICATOR_CATEGORY  APP_INDICATOR_CATEGORY_APPLICATION_STATUS
14
 
 
15
 
#define TEST_APPROVER_TYPE            (test_approver_get_type ())
16
 
#define TEST_APPROVER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_APPROVER_TYPE, TestApprover))
17
 
#define TEST_APPROVER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_APPROVER_TYPE, TestApproverClass))
18
 
#define IS_TEST_APPROVER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_APPROVER_TYPE))
19
 
#define IS_TEST_APPROVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_APPROVER_TYPE))
20
 
#define TEST_APPROVER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_APPROVER_TYPE, TestApproverClass))
21
 
 
22
 
typedef struct _TestApprover      TestApprover;
23
 
typedef struct _TestApproverClass TestApproverClass;
24
 
 
25
 
struct _TestApproverClass {
26
 
        GObjectClass parent_class;
27
 
};
28
 
 
29
 
struct _TestApprover {
30
 
        GObject parent;
31
 
};
32
 
 
33
 
GType test_approver_get_type (void);
34
 
 
35
 
static void test_approver_class_init (TestApproverClass *klass);
36
 
static void test_approver_init       (TestApprover *self);
37
 
static GVariant * approve_item (TestApprover * ta, const gchar * id);
38
 
static void bus_method_call (GDBusConnection * connection, const gchar * sender, const gchar * path, const gchar * interface, const gchar * method, GVariant * params, GDBusMethodInvocation * invocation, gpointer user_data);
39
 
 
40
 
/* GDBus Stuff */
41
 
static GDBusNodeInfo *      node_info = NULL;
42
 
static GDBusInterfaceInfo * interface_info = NULL;
43
 
static GDBusInterfaceVTable interface_table = {
44
 
       method_call:    bus_method_call,
45
 
       get_property:   NULL, /* No properties */
46
 
       set_property:   NULL  /* No properties */
47
 
};
48
 
 
49
 
GMainLoop * main_loop = NULL;
50
 
GDBusConnection * session_bus = NULL;
51
 
GDBusProxy * bus_proxy = NULL;
52
 
GDBusProxy * watcher_proxy = NULL;
53
 
AppIndicator * app_indicator = NULL;
54
 
gboolean passed = FALSE;
55
 
 
56
 
G_DEFINE_TYPE (TestApprover, test_approver, G_TYPE_OBJECT);
57
 
 
58
 
static void
59
 
test_approver_class_init (TestApproverClass *klass)
60
 
{
61
 
        /* Setting up the DBus interfaces */
62
 
        if (node_info == NULL) {
63
 
                GError * error = NULL;
64
 
 
65
 
                node_info = g_dbus_node_info_new_for_xml(_notification_approver, &error);
66
 
                if (error != NULL) {
67
 
                        g_error("Unable to parse Approver Service Interface description: %s", error->message);
68
 
                        g_error_free(error);
69
 
                }
70
 
        }
71
 
 
72
 
        if (interface_info == NULL) {
73
 
                interface_info = g_dbus_node_info_lookup_interface(node_info, NOTIFICATION_APPROVER_DBUS_IFACE);
74
 
 
75
 
                if (interface_info == NULL) {
76
 
                        g_error("Unable to find interface '" NOTIFICATION_APPROVER_DBUS_IFACE "'");
77
 
                }
78
 
        }
79
 
 
80
 
        return;
81
 
}
82
 
 
83
 
static void
84
 
test_approver_init (TestApprover *self)
85
 
{
86
 
        GError * error = NULL;
87
 
 
88
 
        /* Now register our object on our new connection */
89
 
        g_dbus_connection_register_object(session_bus,
90
 
                                          APPROVER_PATH,
91
 
                                          interface_info,
92
 
                                          &interface_table,
93
 
                                          self,
94
 
                                          NULL,
95
 
                                          &error);
96
 
 
97
 
        if (error != NULL) {
98
 
                g_error("Unable to register the object to DBus: %s", error->message);
99
 
                g_error_free(error);
100
 
                return;
101
 
        }
102
 
 
103
 
        return;
104
 
}
105
 
 
106
 
static GVariant *
107
 
approve_item (TestApprover * ta, const gchar * id)
108
 
{
109
 
        g_debug("Asked to approve indicator");
110
 
 
111
 
        if (g_strcmp0(id, INDICATOR_ID) == 0) {
112
 
                passed = TRUE;
113
 
        }
114
 
 
115
 
        g_main_loop_quit(main_loop);
116
 
 
117
 
        return g_variant_new("(b)", TRUE);
118
 
}
119
 
 
120
 
/* A method has been called from our dbus inteface.  Figure out what it
121
 
   is and dispatch it. */
122
 
static void
123
 
bus_method_call (GDBusConnection * connection, const gchar * sender,
124
 
                 const gchar * path, const gchar * interface,
125
 
                 const gchar * method, GVariant * params,
126
 
                 GDBusMethodInvocation * invocation, gpointer user_data)
127
 
{
128
 
        TestApprover * ta = (TestApprover *)user_data;
129
 
        GVariant * retval = NULL;
130
 
 
131
 
        if (g_strcmp0(method, "ApproveItem") == 0) {
132
 
                const gchar * id;
133
 
                g_variant_get(params, "(&ssuso)", &id, NULL, NULL, NULL, NULL);
134
 
                retval = approve_item(ta, id);
135
 
        } else {
136
 
                g_warning("Calling method '%s' on the indicator service and it's unknown", method);
137
 
        }
138
 
 
139
 
        g_dbus_method_invocation_return_value(invocation, retval);
140
 
        return;
141
 
}
142
 
 
143
 
static void
144
 
register_cb (GObject *object, GAsyncResult *res, gpointer user_data)
145
 
{
146
 
        GDBusProxy * proxy = G_DBUS_PROXY(object);
147
 
        GError * error = NULL;
148
 
        GVariant * result;
149
 
 
150
 
        result = g_dbus_proxy_call_finish(proxy, res, &error);
151
 
 
152
 
        if (result != NULL) {
153
 
                g_variant_unref(result);
154
 
                result = NULL;
155
 
        }
156
 
 
157
 
        if (error != NULL) {
158
 
                g_warning("Unable to register approver: %s", error->message);
159
 
                g_error_free(error);
160
 
                g_main_loop_quit(main_loop);
161
 
                return;
162
 
        }
163
 
 
164
 
        g_debug("Building App Indicator");
165
 
        app_indicator = app_indicator_new(INDICATOR_ID, INDICATOR_ICON, INDICATOR_CATEGORY);
166
 
 
167
 
        GtkWidget * menu = gtk_menu_new();
168
 
        GtkWidget * mi = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
169
 
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
170
 
 
171
 
        app_indicator_set_menu(app_indicator, GTK_MENU(menu));
172
 
 
173
 
        return;
174
 
}
175
 
 
176
 
gint owner_count = 0;
177
 
gboolean
178
 
check_for_service (gpointer user_data)
179
 
{
180
 
        g_debug("Checking for Watcher");
181
 
 
182
 
        if (owner_count > 100) {
183
 
                g_warning("Couldn't find watcher after 100 tries.");
184
 
                g_main_loop_quit(main_loop);
185
 
                return FALSE;
186
 
        }
187
 
 
188
 
        owner_count++;
189
 
 
190
 
        gboolean has_owner = FALSE;
191
 
        gchar * owner = g_dbus_proxy_get_name_owner(bus_proxy);
192
 
        has_owner = (owner != NULL);
193
 
        g_free (owner);
194
 
 
195
 
        if (has_owner) {
196
 
                g_debug("Registering Approver");
197
 
                GVariantBuilder * builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
198
 
                g_dbus_proxy_call(bus_proxy, "XAyatanaRegisterNotificationApprover",
199
 
                                  g_variant_new("(oas)", APPROVER_PATH, builder),
200
 
                                  G_DBUS_CALL_FLAGS_NONE, -1, NULL, register_cb,
201
 
                                  NULL);
202
 
                return FALSE;
203
 
        }
204
 
 
205
 
        return TRUE;
206
 
}
207
 
 
208
 
gboolean
209
 
fail_timeout (gpointer user_data)
210
 
{
211
 
        g_debug("Failure timeout initiated.");
212
 
        g_main_loop_quit(main_loop);
213
 
        return FALSE;
214
 
}
215
 
 
216
 
int
217
 
main (int argc, char ** argv)
218
 
{
219
 
        GError * error = NULL;
220
 
 
221
 
        gtk_init(&argc, &argv);
222
 
        g_debug("Initing");
223
 
 
224
 
        session_bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
225
 
        TestApprover * approver = g_object_new(TEST_APPROVER_TYPE, NULL);
226
 
 
227
 
        bus_proxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, NULL, NOTIFICATION_WATCHER_DBUS_ADDR, NOTIFICATION_WATCHER_DBUS_OBJ, NOTIFICATION_WATCHER_DBUS_IFACE, NULL, &error);
228
 
        if (error != NULL) {
229
 
                g_warning("Unable to get bus proxy: %s", error->message);
230
 
                g_error_free(error);
231
 
                return -1;
232
 
        }
233
 
 
234
 
        watcher_proxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, NULL, NOTIFICATION_WATCHER_DBUS_ADDR, NOTIFICATION_WATCHER_DBUS_OBJ, NOTIFICATION_WATCHER_DBUS_IFACE, NULL, &error);
235
 
        if (error != NULL) {
236
 
                g_warning("Unable to get watcher bus: %s", error->message);
237
 
                g_error_free(error);
238
 
                return -1;
239
 
        }
240
 
 
241
 
        g_timeout_add(100, check_for_service, NULL);
242
 
        g_timeout_add_seconds(2, fail_timeout, NULL);
243
 
 
244
 
        main_loop = g_main_loop_new(NULL, FALSE);
245
 
        g_main_loop_run(main_loop);
246
 
 
247
 
        g_object_unref(approver);
248
 
 
249
 
        if (!passed) {
250
 
                return -1;
251
 
        }
252
 
 
253
 
        return 0;
254
 
}