src/minicontrol-provider.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *  http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <Elementary.h>
  18
  19 #include "minicontrol-error.h"
  20 #include "minicontrol-type.h"
  21 #include "minicontrol-internal.h"
  22 #include "minicontrol-provider.h"
  23 #include "minicontrol-log.h"
  24
  25 #define MINICTRL_PRIORITY_SUFFIX_TOP "__minicontrol_top"
  26 #define MINICTRL_PRIORITY_SUFFIX_LOW "__minicontrol_low"
  27 #define MINICTRL_DATA_KEY "__minictrl_data_internal"
  28
  29 enum {
  30         MINICTRL_STATE_READY =0,
  31         MINICTRL_STATE_RUNNING,
  32 };
  33
  34 struct _provider_data {
  35         char *name;
  36         int state;
  37         minicontrol_priority_e priority;
  38         Evas_Object *obj;
  39         minictrl_sig_handle *sh;
  40 };
  41
  42 static void __provider_data_free(struct _provider_data *pd)
  43 {
  44         if (pd) {
  45                 if (pd->name)
  46                         free(pd->name);
  47
  48                 if (pd->sh)
  49                         _minictrl_dbus_sig_handle_dettach(pd->sh);
  50
  51                 free(pd);
  52         }
  53 }
  54
  55 static int __str_has_suffix(const char *str, const char *suffix)
  56 {
  57         int str_len;
  58         int suffix_len;
  59
  60         if (!str)
  61                 return -1;
  62
  63         if (!suffix)
  64                 return -1;
  65
  66         str_len = strlen (str);
  67         suffix_len = strlen (suffix);
  68
  69         if (str_len < suffix_len)
  70                 return -1;
  71
  72         return strcmp(str + str_len - suffix_len, suffix);
  73 }
  74
  75 static void _running_req_cb(void *data, DBusMessage *msg)
  76 {
  77         struct _provider_data *pd;
  78
  79         if (!data) {
  80                 ERR("data is NULL");
  81                 return;
  82         }
  83         pd = data;
  84
  85         if (pd->state == MINICTRL_STATE_RUNNING) {
  86                 Evas_Coord w = 0;
  87                 Evas_Coord h = 0;
  88                 evas_object_geometry_get(pd->obj, NULL, NULL, &w, &h);
  89                 _minictrl_provider_message_send(MINICTRL_DBUS_SIG_START,
  90                                         pd->name, w, h, pd->priority);
  91         }
  92 }
  93
  94 static int minicontrol_win_start(Evas_Object *mincontrol)
  95 {
  96         struct _provider_data *pd;
  97         int ret = MINICONTROL_ERROR_NONE;
  98
  99         if (!mincontrol) {
 100                 ERR("mincontrol is NULL, invaild parameter");
 101                 return MINICONTROL_ERROR_INVALID_PARAMETER;
 102         }
 103
 104         pd = evas_object_data_get(mincontrol, MINICTRL_DATA_KEY);
 105         if (!pd) {
 106                 ERR("pd is NULL, invaild parameter");
 107                 return MINICONTROL_ERROR_INVALID_PARAMETER;
 108         }
 109
 110         if (!pd->name) {
 111                 ERR("pd name is NULL, invaild parameter");
 112                 return MINICONTROL_ERROR_INVALID_PARAMETER;
 113         }
 114
 115         if (pd->state != MINICTRL_STATE_RUNNING) {
 116                 Evas_Coord w = 0;
 117                 Evas_Coord h = 0;
 118                 pd->state = MINICTRL_STATE_RUNNING;
 119
 120                 evas_object_geometry_get(mincontrol, NULL, NULL, &w, &h);
 121                 _minictrl_provider_proc_send(MINICONTROL_DBUS_PROC_EXCLUDE);
 122                 ret = _minictrl_provider_message_send(MINICTRL_DBUS_SIG_START,
 123                                         pd->name, w, h, pd->priority);
 124         }
 125
 126         return ret;
 127 }
 128
 129 static int minicontrol_win_stop(Evas_Object *mincontrol)
 130 {
 131         struct _provider_data *pd;
 132         int ret = MINICONTROL_ERROR_NONE;
 133
 134         if (!mincontrol) {
 135                 ERR("mincontrol is NULL, invaild parameter");
 136                 return MINICONTROL_ERROR_INVALID_PARAMETER;
 137         }
 138
 139         pd = evas_object_data_get(mincontrol, MINICTRL_DATA_KEY);
 140         if (!pd) {
 141                 ERR("pd is NULL, invaild parameter");
 142                 return MINICONTROL_ERROR_INVALID_PARAMETER;
 143         }
 144
 145         if (!pd->name) {
 146                 ERR("pd name is NULL, invaild parameter");
 147                 return MINICONTROL_ERROR_INVALID_PARAMETER;
 148         }
 149         if (pd->state != MINICTRL_STATE_READY) {
 150                 pd->state = MINICTRL_STATE_READY;
 151                 _minictrl_provider_proc_send(MINICONTROL_DBUS_PROC_INCLUDE);
 152                 ret = _minictrl_provider_message_send(MINICTRL_DBUS_SIG_STOP,
 153                                         pd->name, 0, 0, pd->priority);
 154         }
 155
 156         return ret;
 157 }
 158
 159 static void _minictrl_win_del(void *data, Evas *e,
 160                         Evas_Object *obj, void *event_info)
 161 {
 162         struct _provider_data *pd = NULL;
 163
 164         minicontrol_win_stop(obj);
 165
 166         pd = evas_object_data_get(obj, MINICTRL_DATA_KEY);
 167         __provider_data_free(pd);
 168
 169         evas_object_data_set(obj, MINICTRL_DATA_KEY, NULL);
 170 }
 171
 172 static void _minictrl_win_hide(void *data, Evas *e,
 173                         Evas_Object *obj, void *event_info)
 174 {
 175         minicontrol_win_stop(obj);
 176 }
 177
 178 static void _minictrl_win_show(void *data, Evas *e,
 179                         Evas_Object *obj, void *event_info)
 180 {
 181         minicontrol_win_start(obj);
 182 }
 183
 184 static void _minictrl_win_resize(void *data, Evas *e,
 185                         Evas_Object *obj, void *event_info)
 186 {
 187         struct _provider_data *pd;
 188
 189         if (!data) {
 190                 ERR("data is NULL, invaild parameter");
 191                 return;
 192         }
 193         pd = data;
 194
 195         if (pd->state == MINICTRL_STATE_RUNNING) {
 196                 Evas_Coord w = 0;
 197                 Evas_Coord h = 0;
 198
 199                 evas_object_geometry_get(obj, NULL, NULL, &w, &h);
 200                 _minictrl_provider_message_send(MINICTRL_DBUS_SIG_RESIZE,
 201                                         pd->name, w, h, pd->priority);
 202         }
 203 }
 204
 205 static char *_minictrl_create_name(const char *name)
 206 {
 207         char *buf;
 208         int size = 0;
 209
 210         if (!name) {
 211                 ERR("name is NULL, invaild parameter");
 212                 return NULL;
 213         }
 214
 215         size = snprintf(NULL, 0, "[%s]", name) + 1;
 216         buf = (char *)malloc(sizeof(char) * size);
 217         if (!buf) {
 218                ERR("fail to alloc buf");
 219                return NULL;
 220         }
 221
 222         snprintf(buf, size, "[%s]", name);
 223
 224         return buf;
 225 }
 226
 227 static minicontrol_priority_e _minictrl_get_priroty_by_name(const char *name)
 228 {
 229         minicontrol_priority_e priority = MINICONTROL_PRIORITY_MIDDLE;
 230
 231         if (!__str_has_suffix(name, MINICTRL_PRIORITY_SUFFIX_TOP))
 232                 priority = MINICONTROL_PRIORITY_TOP;
 233         else if (!__str_has_suffix(name, MINICTRL_PRIORITY_SUFFIX_LOW))
 234                 priority = MINICONTROL_PRIORITY_LOW;
 235
 236         return priority;
 237 }
 238
 239 EXPORT_API Evas_Object *minicontrol_win_add(const char *name)
 240 {
 241         Evas_Object *win = NULL;
 242         char *name_inter = NULL;
 243         struct _provider_data *pd;
 244
 245         if (!name)
 246                 return NULL;
 247
 248         win = elm_win_add(NULL, "minicontrol", ELM_WIN_SOCKET_IMAGE);
 249         if (!win)
 250                 return NULL;
 251
 252         name_inter = _minictrl_create_name(name);
 253         if (!name_inter) {
 254
 255                 ERR("Fail to create name_inter for : %s", name);
 256                 evas_object_del(win);
 257                 return NULL;
 258         }
 259
 260         if (!elm_win_socket_listen(win, name_inter, 0, EINA_TRUE)) {
 261                 ERR("Fail to elm win socket listen");
 262                 evas_object_del(win);
 263                 free(name_inter);
 264                 return NULL;
 265         }
 266
 267         pd = malloc(sizeof(struct _provider_data));
 268         if (!pd) {
 269                 ERR("Fail to alloc memory");
 270                 evas_object_del(win);
 271                 free(name_inter);
 272                 return NULL;
 273
 274         }
 275         memset(pd, 0x00, sizeof(struct _provider_data));
 276         pd->name = name_inter;
 277         pd->state = MINICTRL_STATE_READY;
 278         pd->obj = win;
 279         pd->priority = _minictrl_get_priroty_by_name(name);
 280
 281         evas_object_data_set(win ,MINICTRL_DATA_KEY,pd);
 282
 283         elm_win_autodel_set(win, EINA_TRUE);
 284
 285         evas_object_event_callback_add(win, EVAS_CALLBACK_DEL,
 286                                         _minictrl_win_del, pd);
 287
 288         evas_object_event_callback_add(win, EVAS_CALLBACK_SHOW,
 289                                         _minictrl_win_show, pd);
 290
 291         evas_object_event_callback_add(win, EVAS_CALLBACK_HIDE,
 292                                         _minictrl_win_hide, pd);
 293
 294         evas_object_event_callback_add(win, EVAS_CALLBACK_RESIZE,
 295                                         _minictrl_win_resize, pd);
 296
 297         pd->sh = _minictrl_dbus_sig_handle_attach(MINICTRL_DBUS_SIG_RUNNING_REQ,
 298                                         _running_req_cb, pd);
 299
 300         INFO("new minicontrol created - %s", pd->name);
 301         return win;
 302 }
 303
 304 EXPORT_API minicontrol_error_e minicontrol_request(Evas_Object *mincontrol, minicontrol_request_e request)
 305 {
 306         struct _provider_data *pd;
 307         int ret = MINICONTROL_ERROR_NONE;
 308
 309         if (!mincontrol) {
 310                 ERR("mincontrol is NULL, invaild parameter");
 311                 return MINICONTROL_ERROR_INVALID_PARAMETER;
 312         }
 313
 314         pd = evas_object_data_get(mincontrol, MINICTRL_DATA_KEY);
 315         if (!pd) {
 316                 ERR("pd is NULL, invaild parameter");
 317                 return MINICONTROL_ERROR_INVALID_PARAMETER;
 318         }
 319
 320         if (!pd->name) {
 321                 ERR("pd name is NULL, invaild parameter");
 322                 return MINICONTROL_ERROR_INVALID_PARAMETER;
 323         }
 324
 325         if (pd->state == MINICTRL_STATE_RUNNING) {
 326                 ret = _minictrl_provider_message_send(MINICTRL_DBUS_SIG_REQUEST,
 327                                         pd->name, request, request, pd->priority);
 328         }
 329
 330         return ret;
 331 }