src/dbus-common.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2006-2010  Nokia Corporation
   6  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   7  *  Copyright (C) 2005-2007  Johan Hedberg <johan.hedberg@nokia.com>
   8  *
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  *
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <stdint.h>
  32
  33 #include <glib.h>
  34 #include <dbus/dbus.h>
  35 #include <gdbus.h>
  36
  37 #include "log.h"
  38
  39 #include "dbus-common.h"
  40
  41 static DBusConnection *connection = NULL;
  42
  43 static void append_variant(DBusMessageIter *iter, int type, void *val)
  44 {
  45         DBusMessageIter value;
  46         char sig[2] = { type, '\0' };
  47
  48         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, sig, &value);
  49
  50         dbus_message_iter_append_basic(&value, type, val);
  51
  52         dbus_message_iter_close_container(iter, &value);
  53 }
  54
  55 static void append_array_variant(DBusMessageIter *iter, int type, void *val,
  56                                                         int n_elements)
  57 {
  58         DBusMessageIter variant, array;
  59         char type_sig[2] = { type, '\0' };
  60         char array_sig[3] = { DBUS_TYPE_ARRAY, type, '\0' };
  61
  62         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  63                                                 array_sig, &variant);
  64
  65         dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
  66                                                 type_sig, &array);
  67
  68         if (dbus_type_is_fixed(type) == TRUE) {
  69                 dbus_message_iter_append_fixed_array(&array, type, val,
  70                                                         n_elements);
  71         } else if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH) {
  72                 const char ***str_array = val;
  73                 int i;
  74
  75                 for (i = 0; i < n_elements; i++)
  76                         dbus_message_iter_append_basic(&array, type,
  77                                                         &((*str_array)[i]));
  78         }
  79
  80         dbus_message_iter_close_container(&variant, &array);
  81
  82         dbus_message_iter_close_container(iter, &variant);
  83 }
  84
  85 void dict_append_entry(DBusMessageIter *dict,
  86                         const char *key, int type, void *val)
  87 {
  88         DBusMessageIter entry;
  89
  90         if (type == DBUS_TYPE_STRING) {
  91                 const char *str = *((const char **) val);
  92                 if (str == NULL)
  93                         return;
  94         }
  95
  96         dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
  97                                                         NULL, &entry);
  98
  99         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 100
 101         append_variant(&entry, type, val);
 102
 103         dbus_message_iter_close_container(dict, &entry);
 104 }
 105
 106 void dict_append_array(DBusMessageIter *dict, const char *key, int type,
 107                         void *val, int n_elements)
 108 {
 109         DBusMessageIter entry;
 110
 111         dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
 112                                                 NULL, &entry);
 113
 114         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 115
 116         append_array_variant(&entry, type, val, n_elements);
 117
 118         dbus_message_iter_close_container(dict, &entry);
 119 }
 120
 121 dbus_bool_t emit_property_changed(DBusConnection *conn,
 122                                         const char *path,
 123                                         const char *interface,
 124                                         const char *name,
 125                                         int type, void *value)
 126 {
 127         DBusMessage *signal;
 128         DBusMessageIter iter;
 129
 130         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 131
 132         if (!signal) {
 133                 error("Unable to allocate new %s.PropertyChanged signal",
 134                                 interface);
 135                 return FALSE;
 136         }
 137
 138         dbus_message_iter_init_append(signal, &iter);
 139
 140         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
 141
 142         append_variant(&iter, type, value);
 143
 144         return g_dbus_send_message(conn, signal);
 145 }
 146
 147 dbus_bool_t emit_array_property_changed(DBusConnection *conn,
 148                                         const char *path,
 149                                         const char *interface,
 150                                         const char *name,
 151                                         int type, void *value, int num)
 152 {
 153         DBusMessage *signal;
 154         DBusMessageIter iter;
 155
 156         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 157
 158         if (!signal) {
 159                 error("Unable to allocate new %s.PropertyChanged signal",
 160                                 interface);
 161                 return FALSE;
 162         }
 163
 164         dbus_message_iter_init_append(signal, &iter);
 165
 166         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
 167
 168         append_array_variant(&iter, type, value, num);
 169
 170         return g_dbus_send_message(conn, signal);
 171 }
 172
 173 void set_dbus_connection(DBusConnection *conn)
 174 {
 175         connection = conn;
 176 }
 177
 178 DBusConnection *get_dbus_connection(void)
 179 {
 180         return connection;
 181 }
 182
 183 const char *class_to_icon(uint32_t class)
 184 {
 185         switch ((class & 0x1f00) >> 8) {
 186         case 0x01:
 187                 return "computer";
 188         case 0x02:
 189                 switch ((class & 0xfc) >> 2) {
 190                 case 0x01:
 191                 case 0x02:
 192                 case 0x03:
 193                 case 0x05:
 194                         return "phone";
 195                 case 0x04:
 196                         return "modem";
 197                 }
 198                 break;
 199         case 0x03:
 200                 return "network-wireless";
 201         case 0x04:
 202                 switch ((class & 0xfc) >> 2) {
 203                 case 0x01:
 204                 case 0x02:
 205                         return "audio-card";    /* Headset */
 206                 case 0x06:
 207                         return "audio-card";    /* Headphone */
 208                 case 0x0b: /* VCR */
 209                 case 0x0c: /* Video Camera */
 210                 case 0x0d: /* Camcorder */
 211                         return "camera-video";
 212                 default:
 213                         return "audio-card";    /* Other audio device */
 214                 }
 215                 break;
 216         case 0x05:
 217                 switch ((class & 0xc0) >> 6) {
 218                 case 0x00:
 219                         switch ((class & 0x1e) >> 2) {
 220                         case 0x01:
 221                         case 0x02:
 222                                 return "input-gaming";
 223                         }
 224                         break;
 225                 case 0x01:
 226                         return "input-keyboard";
 227                 case 0x02:
 228                         switch ((class & 0x1e) >> 2) {
 229                         case 0x05:
 230                                 return "input-tablet";
 231                         default:
 232                                 return "input-mouse";
 233                         }
 234                 }
 235                 break;
 236         case 0x06:
 237                 if (class & 0x80)
 238                         return "printer";
 239                 if (class & 0x20)
 240                         return "camera-photo";
 241                 break;
 242         }
 243
 244         return NULL;
 245 }
 246
 247 const char *gap_appearance_to_icon(uint16_t appearance)
 248 {
 249         switch ((appearance & 0xffc0) >> 6) {
 250         case 0x01:
 251                 return "phone";
 252         case 0x02:
 253                 return "computer";
 254         case 0x05:
 255                 return "video-display";
 256         case 0x0a:
 257                 return "multimedia-player";
 258         case 0x0b:
 259                 return "scanner";
 260         case 0x0f: /* HID Generic */
 261                 switch (appearance & 0x3f) {
 262                 case 0x01:
 263                         return "input-keyboard";
 264                 case 0x02:
 265                         return "input-mouse";
 266                 case 0x03:
 267                 case 0x04:
 268                         return "input-gaming";
 269                 case 0x05:
 270                         return "input-tablet";
 271                 case 0x08:
 272                         return "scanner";
 273                 }
 274                 break;
 275         }
 276
 277         return NULL;
 278 }