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
  36 #include "gdbus/gdbus.h"
  37
  38 #include "log.h"
  39
  40 #include "dbus-common.h"
  41
  42 static DBusConnection *connection = NULL;
  43
  44 static void append_variant(DBusMessageIter *iter, int type, void *val)
  45 {
  46         DBusMessageIter value;
  47         char sig[2] = { type, '\0' };
  48
  49         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, sig, &value);
  50
  51         dbus_message_iter_append_basic(&value, type, val);
  52
  53         dbus_message_iter_close_container(iter, &value);
  54 }
  55
  56 static void append_array_variant(DBusMessageIter *iter, int type, void *val,
  57                                                         int n_elements)
  58 {
  59         DBusMessageIter variant, array;
  60         char type_sig[2] = { type, '\0' };
  61         char array_sig[3] = { DBUS_TYPE_ARRAY, type, '\0' };
  62
  63         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  64                                                 array_sig, &variant);
  65
  66         dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
  67                                                 type_sig, &array);
  68
  69         if (dbus_type_is_fixed(type) == TRUE) {
  70                 dbus_message_iter_append_fixed_array(&array, type, val,
  71                                                         n_elements);
  72         } else if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH) {
  73                 const char ***str_array = val;
  74                 int i;
  75
  76                 for (i = 0; i < n_elements; i++)
  77                         dbus_message_iter_append_basic(&array, type,
  78                                                         &((*str_array)[i]));
  79         }
  80
  81         dbus_message_iter_close_container(&variant, &array);
  82
  83         dbus_message_iter_close_container(iter, &variant);
  84 }
  85
  86 void dict_append_entry(DBusMessageIter *dict,
  87                         const char *key, int type, void *val)
  88 {
  89         DBusMessageIter entry;
  90
  91         if (type == DBUS_TYPE_STRING) {
  92                 const char *str = *((const char **) val);
  93                 if (str == NULL)
  94                         return;
  95         }
  96
  97         dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
  98                                                         NULL, &entry);
  99
 100         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 101
 102         append_variant(&entry, type, val);
 103
 104         dbus_message_iter_close_container(dict, &entry);
 105 }
 106
 107 void dict_append_array(DBusMessageIter *dict, const char *key, int type,
 108                         void *val, int n_elements)
 109 {
 110         DBusMessageIter entry;
 111
 112         dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
 113                                                 NULL, &entry);
 114
 115         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 116
 117         append_array_variant(&entry, type, val, n_elements);
 118
 119         dbus_message_iter_close_container(dict, &entry);
 120 }
 121
 122 void set_dbus_connection(DBusConnection *conn)
 123 {
 124         connection = conn;
 125 }
 126
 127 DBusConnection *btd_get_dbus_connection(void)
 128 {
 129         return connection;
 130 }
 131
 132 const char *class_to_icon(uint32_t class)
 133 {
 134         switch ((class & 0x1f00) >> 8) {
 135         case 0x01:
 136                 return "computer";
 137         case 0x02:
 138                 switch ((class & 0xfc) >> 2) {
 139                 case 0x01:
 140                 case 0x02:
 141                 case 0x03:
 142                 case 0x05:
 143                         return "phone";
 144                 case 0x04:
 145                         return "modem";
 146                 }
 147                 break;
 148         case 0x03:
 149                 return "network-wireless";
 150         case 0x04:
 151                 switch ((class & 0xfc) >> 2) {
 152                 case 0x01:
 153                 case 0x02:
 154                         return "audio-card";    /* Headset */
 155                 case 0x06:
 156                         return "audio-card";    /* Headphone */
 157                 case 0x0b: /* VCR */
 158                 case 0x0c: /* Video Camera */
 159                 case 0x0d: /* Camcorder */
 160                         return "camera-video";
 161                 default:
 162                         return "audio-card";    /* Other audio device */
 163                 }
 164                 break;
 165         case 0x05:
 166                 switch ((class & 0xc0) >> 6) {
 167                 case 0x00:
 168                         switch ((class & 0x1e) >> 2) {
 169                         case 0x01:
 170                         case 0x02:
 171                                 return "input-gaming";
 172                         }
 173                         break;
 174                 case 0x01:
 175                         return "input-keyboard";
 176                 case 0x02:
 177                         switch ((class & 0x1e) >> 2) {
 178                         case 0x05:
 179                                 return "input-tablet";
 180                         default:
 181                                 return "input-mouse";
 182                         }
 183                 }
 184                 break;
 185         case 0x06:
 186                 if (class & 0x80)
 187                         return "printer";
 188                 if (class & 0x20)
 189                         return "camera-photo";
 190                 break;
 191         }
 192
 193         return NULL;
 194 }
 195
 196 const char *gap_appearance_to_icon(uint16_t appearance)
 197 {
 198         switch ((appearance & 0xffc0) >> 6) {
 199         case 0x00:
 200                 return "unknown";
 201         case 0x01:
 202                 return "phone";
 203         case 0x02:
 204                 return "computer";
 205         case 0x05:
 206                 return "video-display";
 207         case 0x0a:
 208                 return "multimedia-player";
 209         case 0x0b:
 210                 return "scanner";
 211         case 0x0f: /* HID Generic */
 212                 switch (appearance & 0x3f) {
 213                 case 0x01:
 214                         return "input-keyboard";
 215                 case 0x02:
 216                         return "input-mouse";
 217                 case 0x03:
 218                 case 0x04:
 219                         return "input-gaming";
 220                 case 0x05:
 221                         return "input-tablet";
 222                 case 0x08:
 223                         return "scanner";
 224                 }
 225                 break;
 226         }
 227
 228         return NULL;
 229 }