src/fw-plugins/common-public/slp-sysnoti-alarm/src/plugin_interface.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
  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 #include <glib.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <glib-object.h>
  22 #include <glib/gprintf.h>
  23 #include <vconf-keys.h>
  24 #include <vconf.h>
  25
  26 #include <alarm.h>
  27
  28 #include "plugin/platform_monitor_interface.h"
  29
  30 //#include "slp_callback.h"
  31
  32 /* for alarm service */
  33 //#include "slp_alarm.h"
  34 #include "plugin_slp_sysnoti_alarm.h"
  35
  36 /* for log */
  37 #include "utility/sync_util.h"
  38
  39 #ifndef EXPORT_API
  40 #define EXPORT_API __attribute__ ((visibility("default")))
  41 #endif
  42
  43 #ifndef SYNC_AGENT_LOG
  44 #undef LOG_TAG
  45 #define LOG_TAG "PLUGIN_PM_SYSNOTI_ALARM"
  46 #endif
  47
  48 static int _convert_service_time(char *temp_time, alarm_date_t * out_time);
  49 static int _convert_fw_time(alarm_date_t * temp_time, char **out_time);
  50
  51 EXPORT_API void sync_agent_plugin_init_service_noti(void *data)
  52 {
  53         _EXTERN_FUNC_ENTER;
  54
  55         retm_if(data == NULL, "data is NULL. FAIL !!!");
  56
  57         sync_agent_pm_register_data_s *reg_data = (sync_agent_pm_register_data_s *) data;
  58         if (reg_data == NULL) {
  59                 _DEBUG_ERROR("data is NULL !!");
  60                 goto free_part;
  61         }
  62
  63         _DEBUG_INFO("pkg_name : %s", reg_data->pkg_name);
  64
  65         int ret = alarmmgr_init(reg_data->pkg_name);
  66         if (ret != ALARMMGR_RESULT_SUCCESS) {
  67                 _DEBUG_ERROR("alarmmgr_init() failed ( err_code : %d ) !!", ret);
  68         } else {
  69                 _DEBUG_INFO("alarmmgr_init() success !!");
  70         }
  71
  72  free_part:
  73         if (reg_data != NULL) {
  74                 if (reg_data->pkg_name != NULL)
  75                         free(reg_data->pkg_name);
  76
  77                 free(reg_data);
  78
  79                 _DEBUG_INFO("free sync_agent_pm_register_data_s !!");
  80         }
  81
  82         _EXTERN_FUNC_EXIT;
  83 }
  84
  85 EXPORT_API sync_agent_pm_return_e sync_agent_plugin_unregister_service_noti(void)
  86 {
  87         _EXTERN_FUNC_ENTER;
  88
  89         sync_agent_pm_return_e ret = SYNC_AGENT_PM_SUCCESS;
  90
  91         /* not support destroy alarm api */
  92         _DEBUG_INFO("not support destroy alarm api !!");
  93
  94         _EXTERN_FUNC_EXIT;
  95
  96         return ret;
  97 }
  98
  99 EXPORT_API sync_agent_pm_return_e sync_agent_plugin_add_service_data(void *add_data, int *added_data_id)
 100 {
 101         _EXTERN_FUNC_ENTER;
 102
 103         retvm_if(add_data == NULL, SYNC_AGENT_PM_FAIL, "add_data is NULL. FAIL !!!");
 104
 105         int err = 0;
 106         sync_agent_pm_return_e ret = SYNC_AGENT_PM_SUCCESS;
 107
 108         pmci_alarm_s *temp_add_data = (pmci_alarm_s *) add_data;
 109
 110         _DEBUG_INFO("temp_add_data start_alarm_time[%s], repeat_type[%d], repeat_value[%d], is_disposable[%d]", temp_add_data->start_alarm_time, temp_add_data->repeat_type, temp_add_data->repeat_value, temp_add_data->is_disposable);
 111         int appsync_alarm = 0;
 112
 113
 114         if(appsync_alarm == 0) {
 115
 116
 117                 /* allocate service alarm struct */
 118                 alarm_entry_t *service_add_data = NULL;
 119                 service_add_data = alarmmgr_create_alarm();
 120                 if (service_add_data == NULL)
 121                         goto return_part;
 122
 123                 /* convert fw struct to service struct  */
 124
 125                 /* setting start alarm time */
 126                 if (temp_add_data->start_alarm_time != NULL) {
 127                         alarm_date_t expire_time;
 128                         memset(&expire_time, 0x00, sizeof(alarm_date_t));
 129                         err = _convert_service_time(temp_add_data->start_alarm_time, &expire_time);
 130                         if (err != 1)
 131                                 _DEBUG_ERROR("__convert_alarm_time() failed (err_code : %d ) !!", err);
 132
 133                         err = alarmmgr_set_time(service_add_data, expire_time);
 134                         if (err != ALARMMGR_RESULT_SUCCESS)
 135                                 _DEBUG_ERROR("alarmmgr_set_time() failed ( err_code : %d ) !!", err);
 136                 }
 137
 138                 /* setting repeat mode and repeat value */
 139                 alarm_repeat_mode_t repeat_mode = 0;
 140                 if (temp_add_data->repeat_type != REPEAT_NO_TYPE) {
 141                         switch (temp_add_data->repeat_type) {
 142                         case ONCE:
 143                                 repeat_mode = ALARM_REPEAT_MODE_ONCE;
 144                                 break;
 145                         case REPEAT:
 146                                 repeat_mode = ALARM_REPEAT_MODE_REPEAT;
 147                                 break;
 148                         case REPEAT_WEEKLY:
 149                                 repeat_mode = ALARM_REPEAT_MODE_WEEKLY;
 150                                 break;
 151                         case REPEAT_MONTHLY:
 152                                 repeat_mode = ALARM_REPEAT_MODE_MONTHLY;
 153                                 break;
 154                         case REPEAT_ANNUALLY:
 155                                 repeat_mode = ALARM_REPEAT_MODE_ANNUALLY;
 156                                 break;
 157                         default:
 158                                 break;
 159                         }
 160                 }
 161
 162                 alarm_day_of_week_t repeat_value = 0;
 163                 if (temp_add_data->repeat_value != DAY_NO_TYPE) {
 164                         switch (temp_add_data->repeat_type) {
 165                         case ONCE:
 166                         case REPEAT:
 167                                 {
 168                                         repeat_value = temp_add_data->repeat_value;
 169                                 }
 170                                 break;
 171                         case REPEAT_ANNUALLY:
 172                         case REPEAT_MONTHLY:
 173                         case REPEAT_WEEKLY:
 174                                 {
 175                                         int tmp;
 176                                         int num = 1;
 177
 178                                         int i;
 179                                         for (i = 1; i <= DAY_CNT; i++) {
 180                                                 tmp = (temp_add_data->repeat_value >> i);
 181                                                 switch (tmp) {
 182                                                 case DAY_SUN:
 183                                                         repeat_value |= ALARM_WDAY_SUNDAY;
 184                                                         break;
 185                                                 case DAY_MON:
 186                                                         repeat_value |= ALARM_WDAY_MONDAY;
 187                                                         break;
 188                                                 case DAY_TUE:
 189                                                         repeat_value |= ALARM_WDAY_TUESDAY;
 190                                                         break;
 191                                                 case DAY_WED:
 192                                                         repeat_value |= ALARM_WDAY_WEDNESDAY;
 193                                                         break;
 194                                                 case DAY_THU:
 195                                                         repeat_value |= ALARM_WDAY_THURSDAY;
 196                                                         break;
 197                                                 case DAY_FRI:
 198                                                         repeat_value |= ALARM_WDAY_FRIDAY;
 199                                                         break;
 200                                                 case DAY_SAT:
 201                                                         repeat_value |= ALARM_WDAY_SATURDAY;
 202                                                         break;
 203                                                 default:
 204                                                         break;
 205                                                 }
 206
 207                                                 num *= 2;
 208                                         }
 209                                 }
 210                                 break;
 211                         default:
 212                                 break;
 213                         }
 214                 }
 215
 216                 err = alarmmgr_set_repeat_mode(service_add_data, repeat_mode, repeat_value);
 217                 if (err != ALARMMGR_RESULT_SUCCESS)
 218                         _DEBUG_ERROR("alarmmgr_set_repeat_mode() failed ( err_code : %d ) !!", err);
 219
 220                 /* set alarm type */
 221                 int alarm_type = 0;
 222                 if (temp_add_data->is_disposable != 0) {
 223                         alarm_type = ALARM_TYPE_VOLATILE;
 224                 } else {
 225                         alarm_type = ALARM_TYPE_DEFAULT;
 226                 }
 227
 228                 err = alarmmgr_set_type(service_add_data, alarm_type);
 229                 if (err != ALARMMGR_RESULT_SUCCESS)
 230                         _DEBUG_ERROR("alarmmgr_set_type() failed ( err_code : %d ) !!", err);
 231
 232                 /* insert add alarm item */
 233                 int alarm_id = 0;
 234                 int result = alarmmgr_add_alarm_with_localtime(service_add_data, 0, &alarm_id);
 235                 if (result != ALARMMGR_RESULT_SUCCESS) {
 236                         _DEBUG_ERROR("alarmmgr_add_alarm() failed ( err_code : %d ) !!", result);
 237                         err = 0;
 238                 } else {
 239                         _DEBUG_INFO("alarmmgr_add_alarm() success ( alarm_id : %d ) !!", alarm_id);
 240                         *added_data_id = alarm_id;
 241                         err = 1;
 242                 }
 243
 244                 if (service_add_data != NULL)
 245                         alarmmgr_free_alarm(service_add_data);
 246         }
 247
 248  return_part:
 249         if (err != 1) {
 250                 ret = SYNC_AGENT_PM_FAIL;
 251         } else {
 252                 ret = SYNC_AGENT_PM_SUCCESS;
 253         }
 254
 255         _EXTERN_FUNC_EXIT;
 256
 257         return ret;
 258 }
 259
 260 EXPORT_API sync_agent_pm_return_e sync_agent_plugin_remove_service_data(int remove_data_id)
 261 {
 262         _EXTERN_FUNC_ENTER;
 263
 264         sync_agent_pm_return_e ret = SYNC_AGENT_PM_SUCCESS;
 265
 266         int result = alarmmgr_remove_alarm(remove_data_id);
 267         if (result != ALARMMGR_RESULT_SUCCESS) {
 268                 _DEBUG_ERROR("alarmmgr_remove_alarm() failed ( err_code : %d ) !!", result);
 269                 ret = SYNC_AGENT_PM_FAIL;
 270         } else {
 271                 _DEBUG_INFO("alarmmgr_remove_alarm() success !!");
 272         }
 273
 274         _EXTERN_FUNC_EXIT;
 275
 276         return ret;
 277 }
 278
 279 EXPORT_API sync_agent_pm_return_e sync_agent_plugin_get_service_data(int get_data_id, void **service_data)
 280 {
 281         _EXTERN_FUNC_ENTER;
 282
 283         sync_agent_pm_return_e ret = SYNC_AGENT_PM_SUCCESS;
 284
 285         alarm_entry_t *alarm = alarmmgr_create_alarm();
 286         int result = alarmmgr_get_info(get_data_id, alarm);
 287         if (result != ALARMMGR_RESULT_SUCCESS) {
 288                 _DEBUG_ERROR("alarmmgr_get_info() failed ( err_code : %d ) !!", result);
 289                 result = alarmmgr_free_alarm(alarm);
 290                 return SYNC_AGENT_PM_FAIL;
 291         }
 292
 293         /* converting */
 294         pmci_alarm_s *agent_alarm_info = (pmci_alarm_s *) calloc(1, sizeof(pmci_alarm_s));
 295         if (agent_alarm_info == NULL) {
 296                 _DEBUG_ERROR("calloc failed !!!");
 297                 return SYNC_AGENT_PM_FAIL;
 298         }
 299
 300         int alarm_type = 0;
 301         result = alarmmgr_get_type(alarm, &alarm_type);
 302         if (result != ALARMMGR_RESULT_SUCCESS) {
 303                 _DEBUG_ERROR("alarmmgr_get_type() failed ( err_code : %d ) !!", result);
 304                 return SYNC_AGENT_PM_FAIL;
 305         }
 306         _DEBUG_INFO("alarm_type : %d", alarm_type);
 307
 308         if (alarm_type == ALARM_TYPE_DEFAULT) {
 309                 agent_alarm_info->is_disposable = false;
 310         } else {
 311                 agent_alarm_info->is_disposable = true;
 312         }
 313
 314         alarm_repeat_mode_t repeat_mode;
 315         alarm_day_of_week_t repeat_value;
 316         result = alarmmgr_get_repeat_mode(alarm, &repeat_mode, (int *)(&repeat_value));
 317         if (result != ALARMMGR_RESULT_SUCCESS) {
 318                 _DEBUG_ERROR("alarmmgr_get_repeat_mode() failed ( err_code : %d ) !!", result);
 319                 return SYNC_AGENT_PM_FAIL;
 320         }
 321         _DEBUG_INFO("repeat_mode : %d, repeat_value : %d", repeat_mode, repeat_value);
 322
 323         switch (repeat_mode) {
 324         case ALARM_REPEAT_MODE_ONCE:
 325                 {
 326                         _DEBUG_INFO("ALARM_REPEAT_ONCE");
 327                         agent_alarm_info->repeat_type = ONCE;
 328                         agent_alarm_info->repeat_value = repeat_value;
 329                 }
 330                 break;
 331         case ALARM_REPEAT_MODE_REPEAT:
 332                 {
 333                         _DEBUG_INFO("ALARM_REPEAT_MODE_REPEAT");
 334                         agent_alarm_info->repeat_type = REPEAT;
 335                         agent_alarm_info->repeat_value = repeat_value;
 336                 }
 337                 break;
 338         case ALARM_REPEAT_MODE_WEEKLY:
 339         case ALARM_REPEAT_MODE_MONTHLY:
 340         case ALARM_REPEAT_MODE_ANNUALLY:
 341                 {
 342                         _DEBUG_INFO("ALARM_REPEAT_MODE_WEEKLY, MONTHLY, ANNUALLY");
 343                         int tmp;
 344                         int num = 1;
 345
 346                         int i;
 347                         for (i = 1; i <= DAY_CNT; i++) {
 348                                 tmp = (repeat_value >> i);
 349                                 switch (tmp) {
 350                                 case DAY_SUN:
 351                                         agent_alarm_info->repeat_value |= DAY_SUN;
 352                                         break;
 353                                 case DAY_MON:
 354                                         agent_alarm_info->repeat_value |= DAY_MON;
 355                                         break;
 356                                 case DAY_TUE:
 357                                         agent_alarm_info->repeat_value |= DAY_TUE;
 358                                         break;
 359                                 case DAY_WED:
 360                                         agent_alarm_info->repeat_value |= DAY_WED;
 361                                         break;
 362                                 case DAY_THU:
 363                                         agent_alarm_info->repeat_value |= DAY_THU;
 364                                         break;
 365                                 case DAY_FRI:
 366                                         agent_alarm_info->repeat_value |= DAY_FRI;
 367                                         break;
 368                                 case DAY_SAT:
 369                                         agent_alarm_info->repeat_value |= DAY_SAT;
 370                                         break;
 371                                 default:
 372                                         break;
 373                                 }
 374                                 num *= 2;
 375                         }
 376                 }
 377                 break;
 378         default:
 379                 break;
 380         }
 381
 382         alarm_date_t alarm_time;
 383         result = alarmmgr_get_time(alarm, &alarm_time);
 384         if (result != ALARMMGR_RESULT_SUCCESS) {
 385                 _DEBUG_ERROR("alarmmgr_get_info() failed ( err_code : %d ) !!", result);
 386                 return SYNC_AGENT_PM_FAIL;
 387         }
 388
 389         char *alarm_time_s = NULL;
 390         _convert_fw_time(&alarm_time, &alarm_time_s);
 391         _DEBUG_INFO("alarm_time_s : %s", alarm_time_s);
 392         agent_alarm_info->start_alarm_time = alarm_time_s;
 393
 394         *service_data = agent_alarm_info;
 395
 396         if (alarm != NULL)
 397                 alarmmgr_free_alarm(alarm);
 398
 399         _EXTERN_FUNC_EXIT;
 400
 401         return ret;
 402 }
 403
 404 EXPORT_API void sync_agent_plugin_set_user_callback(int callback_counts, va_list list)
 405 {
 406         _EXTERN_FUNC_ENTER;
 407
 408         int result = ALARMMGR_RESULT_SUCCESS;
 409         int i = 0;
 410
 411         for (; i < callback_counts; i++) {
 412                 result = alarmmgr_set_cb(va_arg(list, sync_agent_user_callback_cb_plugin), 0);
 413                 if (result != ALARMMGR_RESULT_SUCCESS) {
 414                         _DEBUG_ERROR("alarmmgr_set_cb() failed ( err_code : %d ) !!", result);
 415                 } else {
 416                         _DEBUG_INFO("alarmmgr_set_cb() success !!");
 417                 }
 418         }
 419
 420         _EXTERN_FUNC_EXIT;
 421 }
 422
 423 static int _convert_service_time(char *temp_time, alarm_date_t * out_time)
 424 {
 425         _INNER_FUNC_ENTER;
 426
 427         retvm_if(temp_time == NULL, 0, "temp_time is NULL. FAIL !!!");
 428
 429         _DEBUG_TRACE("temp_time = %s", temp_time);
 430
 431         char *delimiter = "-";
 432
 433         char *day_ptr = strstr(temp_time, "T");
 434         if(day_ptr == NULL) {
 435                 _DEBUG_TRACE("day_ptr is NULL!!");
 436                 return 0;
 437         }
 438         _DEBUG_TRACE("Day_ptr = %s", day_ptr);
 439
 440         int length1 = strlen(day_ptr);
 441         _DEBUG_TRACE("length1 = %d", length1);
 442
 443         char *day = (char *)calloc(length1 + 1, sizeof(char));
 444         if (day == NULL) {
 445                 _DEBUG_ERROR("calloc fail !!");
 446                 return 0;
 447         }
 448         strncpy(day, temp_time, length1);
 449         _DEBUG_TRACE("Day = %s", day);
 450
 451         /* get year */
 452         char *ptr = strtok(day, delimiter);
 453         if (ptr == NULL) {
 454                 free(day);
 455                 return 0;
 456         }
 457         _DEBUG_TRACE("Year = %s\n", ptr);
 458         (out_time)->year = atoi(ptr);
 459
 460         /* get month */
 461         ptr = strtok(0, delimiter);
 462         if (ptr == NULL) {
 463                 free(day);
 464                 return 0;
 465         }
 466         _DEBUG_TRACE("Month = %s\n", ptr);
 467         (out_time)->month = atoi(ptr);
 468
 469         /* get day */
 470         ptr = strtok(0, delimiter);
 471         if (ptr == NULL) {
 472                 free(day);
 473                 return 0;
 474         }
 475         _DEBUG_TRACE("Day = %s\n", ptr);
 476         (out_time)->day = atoi(ptr);
 477
 478         if (day != NULL)
 479                 free(day);
 480
 481         char *time_ptr = strstr(day_ptr, "Z");
 482         _DEBUG_TRACE("time_ptr = %s", time_ptr);
 483
 484         int length2 = strlen(temp_time) - strlen(day_ptr) - 2;
 485         _DEBUG_TRACE("length2 = %d", length2);
 486
 487         char *time = (char *)calloc(length2, sizeof(char));
 488         if (time == NULL) {
 489                 _DEBUG_ERROR("calloc fail !!");
 490                 return 0;
 491         }
 492         strncpy(time, day_ptr + 1, length2);
 493         _DEBUG_TRACE("Time = %s", time);
 494         delimiter = ":";
 495
 496         /* get hour */
 497         ptr = strtok(time, delimiter);
 498         if (ptr == NULL) {
 499                 free(time);
 500                 return 0;
 501         }
 502         _DEBUG_TRACE("hour = %s\n", ptr);
 503         (out_time)->hour = atoi(ptr);
 504
 505         /* get min */
 506         ptr = strtok(0, delimiter);
 507         if (ptr == NULL) {
 508                 free(time);
 509                 return 0;
 510         }
 511         _DEBUG_TRACE("min = %s\n", ptr);
 512         (out_time)->min = atoi(ptr);
 513
 514         /* get sec */
 515         ptr = strtok(0, delimiter);
 516         if (ptr == NULL) {
 517                 free(time);
 518                 return 0;
 519         }
 520         _DEBUG_TRACE("sec = %s\n", ptr);
 521         (out_time)->sec = atoi(ptr);
 522
 523         if (time != NULL)
 524                 free(time);
 525
 526         _INNER_FUNC_EXIT;
 527
 528         return 1;
 529 }
 530
 531 static int _convert_fw_time(alarm_date_t * temp_time, char **out_time)
 532 {
 533         _INNER_FUNC_ENTER;
 534
 535         retvm_if(temp_time == NULL, 0, "temp_time is NULL. FAIL !!!");
 536
 537         *out_time = g_strdup_printf("%.2d-%.2d-%.2dT%.2d:%.2d:%.2dZ", temp_time->year, temp_time->month, temp_time->day, temp_time->hour, temp_time->min, temp_time->sec);
 538         _DEBUG_TRACE("out_time = %s\n", *out_time);
 539
 540         _INNER_FUNC_EXIT;
 541
 542         return 1;
 543 }