src/usb/usb-client-dbus.c

   1 /*
   2  * deviced
   3  *
   4  * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License);
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <vconf.h>
  20 #include <limits.h>
  21 #include "usb-client.h"
  22 #include "core/edbus-handler.h"
  23
  24 #define CHANGE_USB_MODE "ChangeUsbMode"
  25
  26 #define METHOD_GET_STATE      "GetState"
  27 #define METHOD_GET_MODE       "GetMode"
  28 #define SIGNAL_STATE_CHANGED  "StateChanged"
  29 #define SIGNAL_MODE_CHANGED   "ModeChanged"
  30
  31 #define USB_STATE_MAX   UINT_MAX
  32 #define USB_MODE_MAX    UINT_MAX
  33
  34 enum usbclient_state {
  35         USBCLIENT_STATE_DISCONNECTED = 0x00,
  36         USBCLIENT_STATE_CONNECTED    = 0x01,
  37         USBCLIENT_STATE_AVAILABLE    = 0x02,
  38 };
  39
  40 static void change_usb_client_mode(void *data, DBusMessage *msg)
  41 {
  42         DBusError err;
  43         int mode, debug;
  44
  45         if (dbus_message_is_signal(msg, DEVICED_INTERFACE_USB, CHANGE_USB_MODE) == 0) {
  46                 _E("The signal is not for changing usb mode");
  47                 return;
  48         }
  49
  50         dbus_error_init(&err);
  51
  52         if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &mode, DBUS_TYPE_INVALID) == 0) {
  53                 _E("FAIL: dbus_message_get_args");
  54                 goto out;
  55         }
  56
  57         switch (mode){
  58         case SET_USB_DEFAULT:
  59         case SET_USB_RNDIS:
  60         case SET_USB_RNDIS_DIAG:
  61         case SET_USB_DIAG_RMNET:
  62                 debug = 0;
  63                 break;
  64         case SET_USB_SDB:
  65         case SET_USB_SDB_DIAG:
  66         case SET_USB_RNDIS_SDB:
  67                 debug = 1;
  68                 break;
  69         default:
  70                 _E("(%d) is unknown usb mode", mode);
  71                 goto out;
  72         }
  73
  74         if (vconf_set_int(VCONFKEY_USB_SEL_MODE, mode) != 0)
  75                 _E("Failed to set usb mode (%d)", mode);
  76
  77         if (vconf_set_bool(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, debug) != 0)
  78                 _E("Failed to set usb debug toggle (%d)", debug);
  79
  80 out:
  81         dbus_error_free(&err);
  82         return;
  83 }
  84
  85
  86 int register_usb_client_change_request(void)
  87 {
  88         return register_edbus_signal_handler(DEVICED_PATH_USB,
  89                         DEVICED_INTERFACE_USB,
  90                         CHANGE_USB_MODE, change_usb_client_mode);
  91 }
  92
  93 static unsigned int get_usb_state(void)
  94 {
  95         unsigned int state = USBCLIENT_STATE_DISCONNECTED;
  96
  97         if (get_current_usb_physical_state() == 0) {
  98                 state |= USBCLIENT_STATE_DISCONNECTED;
  99                 goto out;
 100         }
 101
 102         state |= USBCLIENT_STATE_CONNECTED;
 103
 104         if (get_current_usb_logical_state() > 0
 105                         && get_current_usb_mode() > SET_USB_NONE)
 106                 state |= USBCLIENT_STATE_AVAILABLE;
 107
 108 out:
 109         return state;
 110 }
 111
 112 static unsigned int get_usb_mode(void)
 113 {
 114         return get_current_usb_gadget_info(get_current_usb_mode());
 115 }
 116
 117 void send_msg_usb_state_changed(void)
 118 {
 119         char *param[1];
 120         char text[16];
 121         unsigned int state;
 122         static unsigned int prev_state = USB_STATE_MAX;
 123
 124         state = get_usb_state();
 125         if (state == prev_state)
 126                 return;
 127         prev_state = state;
 128
 129         _I("USB state changed (%u)", state);
 130
 131         snprintf(text, sizeof(text), "%u", state);
 132         param[0] = text;
 133
 134         if (broadcast_edbus_signal(
 135                                 DEVICED_PATH_USB,
 136                                 DEVICED_INTERFACE_USB,
 137                                 SIGNAL_STATE_CHANGED,
 138                                 "u", param) < 0)
 139                 _E("Failed to send dbus signal");
 140 }
 141
 142 void send_msg_usb_mode_changed(void)
 143 {
 144         char *param[1];
 145         char text[16];
 146         unsigned int mode;
 147         static unsigned int prev_mode = USB_MODE_MAX;
 148
 149         mode = get_usb_mode();
 150         if (mode == prev_mode)
 151                 return;
 152         prev_mode = mode;
 153
 154         snprintf(text, sizeof(text), "%u", mode);
 155         param[0] = text;
 156
 157         _I("USB mode changed (%u)", mode);
 158
 159         if (broadcast_edbus_signal(
 160                                 DEVICED_PATH_USB,
 161                                 DEVICED_INTERFACE_USB,
 162                                 SIGNAL_MODE_CHANGED,
 163                                 "u", param) < 0)
 164                 _E("Failed to send dbus signal");
 165 }
 166
 167 static DBusMessage *get_usb_client_state(E_DBus_Object *obj, DBusMessage *msg)
 168 {
 169         DBusMessageIter iter;
 170         DBusMessage *reply;
 171         unsigned int state;
 172
 173         state = get_usb_state();
 174
 175         reply = dbus_message_new_method_return(msg);
 176         dbus_message_iter_init_append(reply, &iter);
 177         dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &state);
 178         return reply;
 179 }
 180
 181 static DBusMessage *get_usb_client_mode(E_DBus_Object *obj, DBusMessage *msg)
 182 {
 183         DBusMessageIter iter;
 184         DBusMessage *reply;
 185         unsigned int mode;
 186
 187         mode = get_usb_mode();
 188
 189         reply = dbus_message_new_method_return(msg);
 190         dbus_message_iter_init_append(reply, &iter);
 191         dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &mode);
 192         return reply;
 193 }
 194
 195 static const struct edbus_method edbus_methods[] = {
 196         { METHOD_GET_STATE    ,  NULL, "u" ,  get_usb_client_state },
 197         { METHOD_GET_MODE     ,  NULL, "u" ,  get_usb_client_mode  },
 198 };
 199
 200 int register_usbclient_dbus_methods(void)
 201 {
 202         return register_edbus_method(DEVICED_PATH_USB, edbus_methods, ARRAY_SIZE(edbus_methods));
 203 }