manager/gestured_client_manager.cpp

   1 #include <stdlib.h>
   2 #include "gestured_client_manager.h"
   3
   4 #ifdef LOG_TAG
   5 #undef LOG_TAG
   6 #endif
   7 #define LOG_TAG "GESTURED_CLIENT_MANAGER"
   8
   9 static GList* g_client_list = NULL;
  10
  11 gesture_manager_client_s* GestureManagerClientCreate(const char* pkg_name)
  12 {
  13         LOGD("Create client");
  14
  15         if (NULL == pkg_name) {
  16                 LOGE("Invalid parameter");
  17                 return NULL;
  18         }
  19
  20         gesture_manager_client_s* client;
  21         client = (gesture_manager_client_s*)calloc(1, sizeof(gesture_manager_client_s));
  22         if (NULL == client) {
  23                 LOGE("Fail to allocate memory");
  24                 return NULL;
  25         }
  26
  27         client->pkg_name = strdup(pkg_name);
  28         if (NULL == client->pkg_name) {
  29                 LOGE("Fail to strdup");
  30                 free(client);
  31                 client = NULL;
  32                 return NULL;
  33         }
  34
  35         client->gestureType = -1;
  36         client->requestTypeCount = -1;
  37         client->clientLib = GESTURE_CLIENT_LIB_NONE;
  38         client->request_uid = -1;
  39         client->gdbus_bus_name = NULL;
  40         client->gdbus_watch_id = -1;
  41         client->gdbus_connection = NULL;
  42         client->state = CLIENT_STATE_NONE;
  43         client->response_cb = NULL;
  44         client->is_permitted = false;
  45
  46         return client;
  47 }
  48
  49 void GestureManagerClientDestroy(gpointer data)
  50 {
  51         LOGD("Destroy client");
  52
  53         if (NULL == data)
  54                 return;
  55
  56         gesture_manager_client_s* client_h = (gesture_manager_client_s*)data;
  57
  58         if (NULL != client_h->pkg_name) {
  59                 free(client_h->pkg_name);
  60                 client_h->pkg_name = NULL;
  61         }
  62
  63         if (NULL != client_h->gdbus_bus_name) {
  64                 free(client_h->gdbus_bus_name);
  65                 client_h->gdbus_bus_name = NULL;
  66         }
  67
  68         if (NULL != client_h->gdbus_connection) {
  69                 free(client_h->gdbus_connection);
  70                 client_h->gdbus_connection = NULL;
  71         }
  72
  73         if (NULL != client_h->response_cb) {
  74                 free(client_h->response_cb);
  75                 client_h->response_cb = NULL;
  76         }
  77
  78         free(client_h);
  79         client_h = NULL;
  80
  81         return;
  82 }
  83
  84 int GestureManagerClientAdd(gesture_manager_client_s* client_h)
  85 {
  86         LOGD("Add a client to client list");
  87
  88         if (NULL == client_h) {
  89                 LOGE("Invalid parameter");
  90                 return GESTURED_ERROR_INVALID_PARAMETER;
  91         }
  92
  93         g_client_list = g_list_append(g_client_list, client_h);
  94
  95         return GESTURED_ERROR_NONE;
  96 }
  97
  98 int GestureManagerClientRemove(gesture_manager_client_s* client_h)
  99 {
 100         LOGD("Remove a client from client list");
 101
 102         if (NULL == client_h) {
 103                 LOGE("Invalid parameter");
 104                 return GESTURED_ERROR_INVALID_PARAMETER;
 105         }
 106
 107         g_client_list = g_list_remove(g_client_list, client_h);
 108         GestureManagerClientDestroy(client_h);
 109
 110         return GESTURED_ERROR_NONE;
 111 }
 112
 113 int GestureManagerClientNums()
 114 {
 115         LOGD("Length of client list");
 116
 117         int count = 0;
 118         count = g_list_length(g_client_list);
 119
 120         return count;
 121 }
 122
 123 gesture_manager_client_s* GestureManagerClientGet(const char* pkg_name)
 124 {
 125         LOGD("Get client. pkg_name(%s)", pkg_name);
 126
 127         if (NULL == pkg_name) {
 128                 LOGE("Invalid parameter");
 129                 return NULL;
 130         }
 131
 132         GList* iter = NULL;
 133         gesture_manager_client_s* data = NULL;
 134
 135         if (g_list_length(g_client_list) > 0) {
 136                 iter = g_list_first(g_client_list);
 137
 138                 while (NULL != iter) {
 139                         data = (gesture_manager_client_s *)iter->data;
 140                         if (NULL != data) {
 141                                 if (0 == strncmp(pkg_name, data->pkg_name, strlen(pkg_name))) {
 142                                         LOGD("pkg_name(%s)", data->pkg_name);
 143                                         return data;
 144                                 }
 145                         }
 146
 147                         /* next item */
 148                         iter = g_list_next(iter);
 149                 }
 150         }
 151         LOGD("client doesn't exist");
 152
 153         return NULL;
 154 }
 155
 156 gesture_manager_client_s* GestureManagerClientGetWithBusName(const char* bus_name)
 157 {
 158         LOGD("Get client. bus_name(%s)", bus_name);
 159
 160         if (NULL == bus_name) {
 161                 LOGE("Invalid parameter");
 162                 return NULL;
 163         }
 164
 165         GList* iter = NULL;
 166         gesture_manager_client_s* data = NULL;
 167
 168         if (g_list_length(g_client_list) > 0) {
 169                 iter = g_list_first(g_client_list);
 170
 171                 while (NULL != iter) {
 172                         data = (gesture_manager_client_s *)iter->data;
 173                         if (NULL != data) {
 174                                 if (0 == strncmp(bus_name, data->gdbus_bus_name, strlen(bus_name))) {
 175                                         LOGD("gdbus_bus_name(%s)", data->gdbus_bus_name);
 176                                         return data;
 177                                 }
 178                         }
 179
 180                         /* next item */
 181                         iter = g_list_next(iter);
 182                 }
 183         }
 184         LOGD("client doesn't exist");
 185
 186         return NULL;
 187 }
 188
 189 char* GestureManagerClientGetBusName(int num)
 190 {
 191         LOGD("Get client bus name. num(%d)", num);
 192
 193         gpointer element_data = g_list_nth_data(g_client_list, num);
 194         gesture_manager_client_s* client = (gesture_manager_client_s*)element_data;
 195         if (client == NULL) {
 196                 LOGE("Error : Can not found %d th bus info", num);
 197                 return NULL;
 198         }
 199         return client->gdbus_bus_name;
 200 }
 201
 202 int GestureManagerClientClear()
 203 {
 204         LOGD("Clear all clients from client list");
 205
 206         if (g_client_list) {
 207                 g_list_free_full(g_client_list, GestureManagerClientDestroy);
 208                 g_client_list = NULL;
 209         }
 210
 211         return GESTURED_ERROR_NONE;
 212 }
 213
 214 bool GestureManagerClientAlreadyRegisterd(const char *bus_name)
 215 {
 216         LOGD("Check already registered client. bus_name(%s)", bus_name);
 217
 218         if (NULL == bus_name) {
 219                 LOGE("Invalid parameter");
 220                 return false;
 221         }
 222
 223         GList* iter = NULL;
 224         gesture_manager_client_s* data = NULL;
 225
 226         if (g_list_length(g_client_list) > 0) {
 227                 iter = g_list_first(g_client_list);
 228
 229                 while (NULL != iter) {
 230                         data = (gesture_manager_client_s *)iter->data;
 231                         if (NULL != data) {
 232                                 if (0 == strncmp(bus_name, data->gdbus_bus_name, strlen(bus_name))) {
 233                                         LOGD("gdbus_bus_name(%s)", data->gdbus_bus_name);
 234                                         return true;
 235                                 }
 236                         }
 237
 238                         /* next item */
 239                         iter = g_list_next(iter);
 240                 }
 241         }
 242         LOGD("client is not yet registered. Need to register to server");
 243
 244         return false;
 245 }
 246
 247 int GestureManagerClientGetStatus(const char* pkg_name, gesture_manager_client_state_e* state)
 248 {
 249         LOGD("get state. pkg_name(%s)", pkg_name);
 250
 251         if (NULL == pkg_name) {
 252                 LOGE("Invalid parameter");
 253                 return GESTURED_ERROR_INVALID_PARAMETER;
 254         }
 255
 256         gesture_manager_client_s* client;
 257         client = GestureManagerClientGet(pkg_name);
 258         if (NULL == client) {
 259                 LOGE("Invalid uid");
 260                 return GESTURED_ERROR_INVALID_PARAMETER;
 261         }
 262
 263         *state = client->state;
 264
 265         return 0;
 266 }
 267
 268 int GestureManagerClientSetStatus(const char* pkg_name, gesture_manager_client_state_e state)
 269 {
 270         LOGD("set state. pkg_name(%s), state(%d)", pkg_name, state);
 271
 272         if (NULL == pkg_name) {
 273                 LOGE("Invalid parameter");
 274                 return GESTURED_ERROR_INVALID_PARAMETER;
 275         }
 276
 277         gesture_manager_client_s* client;
 278         client = GestureManagerClientGet(pkg_name);
 279         if (NULL == client) {
 280                 LOGE("Invalid pkg_name");
 281                 return GESTURED_ERROR_INVALID_PARAMETER;
 282         }
 283
 284         client->state = state;
 285
 286         return 0;
 287 }