ug/list/ug.c

   1 /*
   2   *
   3   *  Copyright 2012  Samsung Electronics Co., Ltd
   4   *
   5   *  Licensed under the Flora License, Version 1.0 (the "License");
   6   *  you may not use this file except in compliance with the License.
   7   *  You may obtain a copy of the License at
   8   *
   9   *       http://www.tizenopensource.org/license
  10   *
  11   *  Unless required by applicable law or agreed to in writing, software
  12   *  distributed under the License is distributed on an "AS IS" BASIS,
  13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14   *  See the License for the specific language governing permissions and
  15   *  limitations under the License.
  16   */
  17
  18
  19 #include <calendar-svc-provider.h>
  20 #include <libintl.h>
  21 #include <vconf.h>
  22 #include <vconf-keys.h>
  23
  24 #include "cld.h"
  25 #include "ug.h"
  26
  27 // TODO: get full path from caller
  28 #define VFILE_PATH "/opt/data/ug-calendar"
  29
  30 extern int appcore_set_i18n(const char *, const char *);
  31
  32 static char* __cal_ug_get_caller(service_h b, const char *key)
  33 {
  34         char *v;
  35
  36         int r = service_get_extra_data(b, key, &v);
  37         c_retv_if(r != SERVICE_ERROR_NONE, NULL);
  38
  39         if (!v || v[0] == '\0')
  40                 return strdup("Unknown");
  41
  42         return v;
  43 }
  44
  45 static char* __cal_ug_get_file_name(service_h b, const char *key)
  46 {
  47         char *v;
  48         char path[FILENAME_MAX];
  49
  50         int r = service_get_extra_data(b, key, &v);
  51         c_retv_if(r != SERVICE_ERROR_NONE, NULL);
  52
  53         // TODO: check full path or not
  54
  55         snprintf(path, sizeof(path), "%s/%s", VFILE_PATH, v);
  56
  57         free(v);
  58
  59         r = access(path, R_OK);
  60         if (r == -1)
  61         {
  62                 ERR("UG: Access failed: %s", path);
  63                 return NULL;
  64         }
  65
  66         return strdup(path);
  67 }
  68
  69 static enum cld_ug_mode __cal_ug_get_mode(service_h service, const char *key)
  70 {
  71         c_retv_if(!service, _MODE_UNKNOWN);
  72         c_retv_if(!key, _MODE_UNKNOWN);
  73
  74         char *value = NULL;
  75
  76         int r = service_get_extra_data(service, key, &value);
  77         c_retvm_if(r != SERVICE_ERROR_NONE, _MODE_UNKNOWN, "%d", r);
  78
  79         enum cld_ug_mode ret = _MODE_UNKNOWN;
  80
  81         if (!CAL_STRCMP(value, "file"))
  82                 ret =  _MODE_GET_VCS;
  83
  84         if (!CAL_STRCMP(value, "text"))
  85                 ret =  _MODE_GET_EVT;
  86
  87         if (!CAL_STRCMP(value, "view"))
  88                 ret =  _MODE_VIEW_VCS;
  89
  90         free(value);
  91
  92         return ret;
  93 }
  94
  95 static inline int __cal_ug_set_ug_data(struct ug_data *ugd, service_h service)
  96 {
  97         c_retv_if(!service, -1);
  98         int r,val;
  99
 100         ugd->mode = __cal_ug_get_mode(service, "mode");
 101         if (ugd->mode == _MODE_UNKNOWN) {
 102
 103                 char *value = NULL;
 104
 105                 r = service_get_extra_data(service, "pickType", &value);
 106                 c_retvm_if(r != SERVICE_ERROR_NONE, -1, "%d", r);
 107
 108                 if (!CAL_STRCMP(value, "multiple"))
 109                         ugd->is_multiple = EINA_TRUE;
 110                 else {
 111                         // TODO: Single select
 112                         ugd->is_multiple = EINA_TRUE;
 113                 }
 114                 free(value);
 115                 value = NULL;
 116
 117                 r = service_get_extra_data(service, "itemType", &value);
 118                 c_retvm_if(r != SERVICE_ERROR_NONE, -1, "%d", r);
 119
 120                 if (!CAL_STRCMP(value, "event"))
 121                         ugd->is_event = EINA_TRUE;
 122                 else
 123                         ugd->is_event = EINA_FALSE;
 124
 125                 free(value);
 126                 value = NULL;
 127
 128                 ugd->mode = _MODE_GET_VCS;
 129         }
 130
 131         r = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &val);
 132         if (r < 0)
 133                 ugd->is_hour24 = 0;
 134         else if( val == 1 || val == 2)
 135                 ugd->is_hour24 = val -1;
 136         else
 137                 ERR("vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, &val); error");
 138
 139         switch (ugd->mode) {
 140         case _MODE_GET_VCS:
 141                 ugd->caller = __cal_ug_get_caller(service, "caller");
 142                 break;
 143         case _MODE_VIEW_VCS:
 144                 ugd->vcs_file = __cal_ug_get_file_name(service, "file");
 145                 if (!ugd->vcs_file)
 146                 {
 147                         ERR("UG: Invalid filename");
 148                         return -1;
 149                 }
 150                 break;
 151         default:
 152                 // do nothing
 153                 break;
 154         }
 155
 156         return 0;
 157 }
 158
 159 static void __cal_ug_back_button_callback(void *data, Evas_Object *obj, void *ei)
 160 {
 161         struct ug_data *ugd = data;
 162
 163         if (ugd && ugd->ug)
 164                 ug_destroy_me(ugd->ug);
 165 }
 166
 167 static void __cal_ug_add_back_button(struct ug_data *ugd)
 168 {
 169         Evas_Object *bt;
 170
 171         bt = elm_button_add(ugd->nv);
 172         if (!bt)
 173                 return;
 174
 175         elm_object_style_set(bt, "naviframe/back_btn/default");
 176         // TODO: i18n
 177         elm_object_text_set(bt, "Back");
 178         evas_object_show(bt);
 179
 180         Elm_Object_Item* navi_item = elm_naviframe_top_item_get(ugd->nv);
 181
 182         elm_object_item_part_content_set(navi_item, "prev_btn", bt);
 183
 184         evas_object_smart_callback_add(bt, "clicked", __cal_ug_back_button_callback, ugd);
 185 }
 186
 187 extern  void cal_vcs_viewer_ug_create(struct ug_data *ugd);
 188
 189 static Evas_Object *__cal_ug_create(Evas_Object *parent, struct ug_data *ugd)
 190 {
 191         ugd->base = cal_util_add_layout(parent, NULL);
 192         CAL_ASSERT(ugd->base);
 193
 194         ugd->nv = elm_naviframe_add(parent);
 195         CAL_ASSERT(ugd->nv);
 196
 197         ugd->bg = cal_util_add_bg(ugd->base, EINA_FALSE);
 198         CAL_ASSERT(ugd->bg);
 199
 200         elm_object_theme_set(ugd->nv, ugd->theme);
 201         elm_object_part_content_set(ugd->base, "elm.swallow.content", ugd->nv);
 202         elm_object_part_content_set(ugd->base, "elm.swallow.bg", ugd->bg);
 203
 204         switch (ugd->mode) {
 205         case _MODE_GET_EVT:
 206         case _MODE_GET_VCS:
 207                 cal_list_ug_create(S_("IDS_COM_BODY_CALENDAR"), ugd);
 208                 break;
 209         case _MODE_VIEW_VCS:
 210                 cal_vcs_viewer_ug_create(ugd);
 211                 break;
 212         default:
 213                 // do nothing
 214                 break;
 215         }
 216
 217         if (!ugd->cont) {
 218                 evas_object_del(ugd->base);
 219                 return NULL;
 220         }
 221
 222         __cal_ug_add_back_button(ugd);
 223
 224         return ugd->base;
 225 }
 226
 227 static void __cal_ug_free_data(struct ug_data *ugd)
 228 {
 229         free(ugd->caller);
 230
 231         free(ugd->vcs_file);
 232 }
 233
 234 static void *__cal_ug_create_callback(ui_gadget_h ug, enum ug_mode mode, service_h service, void *priv)
 235 {
 236         c_retv_if(!ug, NULL);
 237         c_retv_if(!service, NULL);
 238         c_retv_if(!priv, NULL);
 239
 240         struct ug_data *ugd;
 241         int r = 0;
 242         Evas_Object *base;
 243
 244         ugd = priv;
 245         ugd->ug = ug;
 246
 247         cal_util_connect_pattern_generator();
 248
 249         if (mode != UG_MODE_FULLVIEW)
 250                 return NULL;
 251
 252         Evas_Object *parent = ug_get_parent_layout(ug);
 253         c_retv_if(!parent, NULL);
 254
 255         r = __cal_ug_set_ug_data(ugd, service);
 256         c_retv_if(r, NULL);
 257
 258         r = CALENDAR_SVC_CONNECT();
 259         if (r != CAL_SUCCESS) {
 260                 ERR("UG: calendar service connect failed");
 261                 __cal_ug_free_data(ugd);
 262                 return NULL;
 263         }
 264
 265         base = __cal_ug_create(parent, ugd);
 266         if (!base) {
 267                 CALENDAR_SVC_DISCONNECT();
 268                 __cal_ug_free_data(ugd);
 269                 return NULL;
 270         }
 271
 272         return base;
 273 }
 274
 275 static void __cal_ug_destroy_callback(ui_gadget_h ug, service_h data, void *priv)
 276 {
 277         struct ug_data *ugd;
 278
 279         if (!ug || !priv)
 280                 return;
 281
 282         ugd = priv;
 283
 284         CALENDAR_SVC_DISCONNECT();
 285
 286         cal_util_disconnect_pattern_generator();
 287
 288         __cal_ug_free_data(ugd);
 289
 290         cal_util_delete_evas_object(&ugd->base);
 291 }
 292
 293 static void __cal_ug_key_callback(ui_gadget_h ug, enum ug_key_event evt,        service_h data, void *priv)
 294 {
 295         if (!ug)
 296                 return;
 297
 298         DBG("UG: key event %d", evt);
 299
 300         switch (evt)
 301         {
 302         case UG_KEY_EVENT_END:
 303                 ug_destroy_me(ug);
 304                 break;
 305         default:
 306                 break;
 307         }
 308 }
 309
 310 static inline void __cal_ug_bind_text_domain()
 311 {
 312         const char *r;
 313
 314         r = bindtextdomain(UGNAME, UGLOCALE);
 315         if (!r)
 316                 ERR("UG: bindtextdomain error");
 317 }
 318
 319 API int UG_MODULE_INIT(struct ug_module_ops *ops)
 320 {
 321         struct ug_data *ugd;
 322
 323         if (!ops)
 324                 return -1;
 325
 326         CAL_CALLOC(ugd, 1, struct ug_data);
 327
 328         ops->create = __cal_ug_create_callback;
 329         ops->destroy = __cal_ug_destroy_callback;
 330         ops->key_event = __cal_ug_key_callback;
 331         ops->priv = ugd;
 332         ops->opt = UG_OPT_INDICATOR_ENABLE;
 333
 334         __cal_ug_bind_text_domain();
 335
 336         appcore_set_i18n(CALENDAR_PACKAGE, LOCALEDIR);
 337
 338         return 0;
 339 }
 340
 341 API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 342 {
 343         struct ug_data *ugd;
 344
 345         if (!ops)
 346                 return;
 347
 348         ugd = ops->priv;
 349         free(ugd);
 350 }