← Back to branch summary

~noskcaj/ubuntu/saucy/xfce4-power-manager/1.2.0-2ubuntu1

« back to all changes in this revision

Viewing changes to libxfpm/hal-manager.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc
  • Date: 2010-12-09 18:28:34 UTC
  • mfrom: (2.3.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20101209182834-efb7dinmf9ssp3es
Tags: 1.0.1-0ubuntu1
Upload to natty (pkg-xfce svn r4665), no Ubuntu changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libxfpm/hal-manager.c
1
 
/*
2
 
 * * Copyright (C) 2008-2009 Ali <aliov@xfce.org>
3
 
 *
4
 
 * Licensed under the GNU General Public License Version 2
5
 
 *
6
 
 * This program is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU General Public License as published by
8
 
 * the Free Software Foundation; either version 2 of the License, or
9
 
 * (at your option) any later version.
10
 
 *
11
 
 * This program is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU General Public License
17
 
 * along with this program; if not, write to the Free Software
18
 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
20
 
 
21
 
#ifdef HAVE_CONFIG_H
22
 
#include <config.h>
23
 
#endif
24
 
 
25
 
#include <stdio.h>
26
 
#include <stdlib.h>
27
 
#include <string.h>
28
 
 
29
 
#include <dbus/dbus-glib.h>
30
 
#include <glib.h>
31
 
 
32
 
#include "hal-manager.h"
33
 
#include "hal-device.h"
34
 
 
35
 
static void hal_manager_finalize   (GObject *object);
36
 
 
37
 
#define HAL_MANAGER_GET_PRIVATE(o) \
38
 
(G_TYPE_INSTANCE_GET_PRIVATE((o), HAL_TYPE_MANAGER, HalManagerPrivate))
39
 
 
40
 
struct HalManagerPrivate
41
 
{
42
 
    DBusGConnection *bus;
43
 
    DBusGProxy      *proxy;
44
 
    gboolean         connected;
45
 
    gboolean         is_laptop;
46
 
};
47
 
 
48
 
enum
49
 
{
50
 
    DEVICE_ADDED,
51
 
    DEVICE_REMOVED,
52
 
    LAST_SIGNAL
53
 
};
54
 
 
55
 
static gpointer hal_manager_object = NULL;
56
 
 
57
 
static guint signals[LAST_SIGNAL] = { 0 };
58
 
 
59
 
G_DEFINE_TYPE (HalManager, hal_manager, G_TYPE_OBJECT)
60
 
 
61
 
static void
62
 
hal_manager_device_added_cb (DBusGProxy *proxy, const gchar *udi, HalManager *manager)
63
 
{
64
 
    g_signal_emit (G_OBJECT(manager), signals[DEVICE_ADDED], 0, udi);
65
 
}
66
 
 
67
 
static void
68
 
hal_manager_device_removed_cb (DBusGProxy *proxy, const gchar *udi, HalManager *manager)
69
 
{
70
 
    g_signal_emit (G_OBJECT(manager), signals[DEVICE_REMOVED], 0, udi);
71
 
}
72
 
 
73
 
static void
74
 
hal_manager_connect (HalManager *manager)
75
 
{
76
 
    GError *error = NULL;
77
 
    
78
 
    manager->priv->bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
79
 
    
80
 
    if ( error )
81
 
    {
82
 
        g_critical ("Failed to get bus system %s\n", error->message);
83
 
        g_error_free (error);
84
 
        goto out;
85
 
    }
86
 
    manager->priv->connected = TRUE;
87
 
    
88
 
    manager->priv->proxy = dbus_g_proxy_new_for_name (manager->priv->bus,
89
 
                                                      "org.freedesktop.Hal",
90
 
                                                      "/org/freedesktop/Hal/Manager",
91
 
                                                      "org.freedesktop.Hal.Manager");
92
 
    
93
 
    if ( !manager->priv->proxy )
94
 
    {
95
 
        g_critical ("Unable to get proxy for \n");
96
 
        goto out;
97
 
    }
98
 
    
99
 
    dbus_g_proxy_add_signal (manager->priv->proxy, "DeviceAdded",
100
 
                             G_TYPE_STRING, G_TYPE_INVALID);
101
 
                             
102
 
    dbus_g_proxy_connect_signal (manager->priv->proxy, "DeviceAdded",
103
 
                                 G_CALLBACK (hal_manager_device_added_cb), manager, NULL);
104
 
 
105
 
    dbus_g_proxy_add_signal (manager->priv->proxy, "DeviceRemoved",
106
 
                             G_TYPE_STRING, G_TYPE_INVALID);
107
 
        
108
 
    dbus_g_proxy_connect_signal (manager->priv->proxy, "DeviceRemoved",
109
 
                                 G_CALLBACK (hal_manager_device_removed_cb), manager, NULL);
110
 
out:
111
 
        ;
112
 
}
113
 
 
114
 
static void
115
 
hal_manager_get_is_laptop_internal (HalManager *manager)
116
 
{
117
 
    HalDevice *device;
118
 
    gchar *form_factor;
119
 
    
120
 
    device = hal_device_new ();
121
 
    
122
 
    hal_device_set_udi (device, "/org/freedesktop/Hal/devices/computer");
123
 
 
124
 
    form_factor = hal_device_get_property_string (device, "system.formfactor");
125
 
 
126
 
    if ( g_strcmp0 (form_factor, "laptop") == 0)
127
 
        manager->priv->is_laptop = TRUE;
128
 
    else
129
 
        manager->priv->is_laptop = FALSE;
130
 
    
131
 
    if (form_factor)
132
 
        g_free (form_factor);
133
 
 
134
 
    g_object_unref (device);
135
 
}
136
 
 
137
 
static void
138
 
hal_manager_class_init(HalManagerClass *klass)
139
 
{
140
 
    GObjectClass *object_class = G_OBJECT_CLASS(klass);
141
 
    
142
 
    signals[DEVICE_ADDED] =
143
 
        g_signal_new("device-added",
144
 
                     HAL_TYPE_MANAGER,
145
 
                     G_SIGNAL_RUN_LAST,
146
 
                     G_STRUCT_OFFSET(HalManagerClass, device_added),
147
 
                     NULL, NULL,
148
 
                     g_cclosure_marshal_VOID__STRING,
149
 
                     G_TYPE_NONE, 1, G_TYPE_STRING);
150
 
                     
151
 
    signals[DEVICE_REMOVED] =
152
 
        g_signal_new("device-removed",
153
 
                     HAL_TYPE_MANAGER,
154
 
                     G_SIGNAL_RUN_LAST,
155
 
                     G_STRUCT_OFFSET(HalManagerClass, device_removed),
156
 
                     NULL, NULL,
157
 
                     g_cclosure_marshal_VOID__STRING,
158
 
                     G_TYPE_NONE, 1, G_TYPE_STRING);
159
 
    
160
 
    object_class->finalize = hal_manager_finalize;
161
 
 
162
 
    g_type_class_add_private (klass,sizeof(HalManagerPrivate));
163
 
}
164
 
 
165
 
static void
166
 
hal_manager_init (HalManager *manager)
167
 
{
168
 
    manager->priv = HAL_MANAGER_GET_PRIVATE (manager);
169
 
    
170
 
    manager->priv->bus       = NULL;
171
 
    manager->priv->proxy     = NULL;
172
 
    manager->priv->connected = FALSE;
173
 
    
174
 
    hal_manager_connect (manager);
175
 
    hal_manager_get_is_laptop_internal (manager);
176
 
}
177
 
 
178
 
static void
179
 
hal_manager_finalize(GObject *object)
180
 
{
181
 
    HalManager *manager;
182
 
 
183
 
    manager = HAL_MANAGER(object);
184
 
    
185
 
    if ( manager->priv->proxy )
186
 
        g_object_unref (manager->priv->proxy);
187
 
        
188
 
    if ( manager->priv->bus )
189
 
        dbus_g_connection_unref (manager->priv->bus);
190
 
 
191
 
    G_OBJECT_CLASS(hal_manager_parent_class)->finalize(object);
192
 
}
193
 
 
194
 
HalManager *
195
 
hal_manager_new (void)
196
 
{
197
 
    if ( hal_manager_object != NULL )
198
 
    {
199
 
        g_object_ref (hal_manager_object);
200
 
    }
201
 
    else
202
 
    {
203
 
        hal_manager_object = g_object_new (HAL_TYPE_MANAGER, NULL);
204
 
        g_object_add_weak_pointer (hal_manager_object, &hal_manager_object);
205
 
    }
206
 
    
207
 
    return HAL_MANAGER (hal_manager_object);
208
 
}
209
 
 
210
 
gchar **hal_manager_find_device_by_capability (HalManager *manager, const gchar *capability)
211
 
{
212
 
    GError *error = NULL;
213
 
    gchar  **udi = NULL;
214
 
    
215
 
    g_return_val_if_fail (HAL_IS_MANAGER(manager), NULL);
216
 
    g_return_val_if_fail (manager->priv->connected, NULL);
217
 
    
218
 
    dbus_g_proxy_call (manager->priv->proxy, "FindDeviceByCapability", &error, 
219
 
                       G_TYPE_STRING, capability, 
220
 
                       G_TYPE_INVALID,
221
 
                       G_TYPE_STRV, &udi,
222
 
                       G_TYPE_INVALID);
223
 
    if ( error )
224
 
    {
225
 
        g_critical ("Error finding devices by capability %s\n", error->message);
226
 
        g_error_free (error);
227
 
    }
228
 
    
229
 
    return udi;
230
 
}
231
 
 
232
 
gboolean hal_manager_get_is_laptop (HalManager *manager)
233
 
{
234
 
    g_return_val_if_fail (HAL_IS_MANAGER (manager), FALSE);
235
 
    
236
 
    return manager->priv->is_laptop;
237
 
}
238
 
 
239
 
void hal_manager_free_string_array (gchar **array)
240
 
{
241
 
    gint i;
242
 
 
243
 
    if (array == NULL)  
244
 
            return;
245
 
    
246
 
    for (i=0; array[i]; i++) 
247
 
        g_free (array[i]);
248
 
    
249
 
    g_free (array);
250
 
}