alarm-manager-registry.c

   1 /*
   2  *  alarm-manager
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Venkatesha Sarpangala <sarpangala.v@samsung.com>, Jayoun Lee <airjany@samsung.com>,
   7  * Sewook Park <sewook7.park@samsung.com>, Jaeho Lee <jaeho81.lee@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23
  24
  25
  26 #include<stdio.h>
  27 #include<stdlib.h>
  28 #include<time.h>
  29 #include<signal.h>
  30 #include<string.h>
  31 #include<sys/types.h>
  32
  33 #include<dbus/dbus.h>
  34 #include<glib.h>
  35 #include <db-util.h>
  36 #include <glib/gmacros.h>
  37
  38 #include"alarm.h"
  39 #include"alarm-internal.h"
  40
  41 #define SIG_TIMER 0x32
  42
  43 #define MAX_GCONF_PATH_LEN 256
  44 #define MAX_QUERY_LEN 4096
  45
  46 extern __alarm_server_context_t alarm_context;
  47 extern sqlite3 *alarmmgr_db;
  48
  49 #ifdef __ALARM_BOOT
  50 extern bool enable_power_on_alarm;
  51 #endif
  52
  53 bool _save_alarms(__alarm_info_t *__alarm_info);
  54 bool _update_alarms(__alarm_info_t *__alarm_info);
  55 bool _delete_alarms(alarm_id_t alarm_id);
  56 #ifdef __ALARM_BOOT
  57 bool _update_power_on(bool on_off);
  58 #endif
  59 bool _load_alarms_from_registry(void);
  60
  61 bool _save_alarms(__alarm_info_t *__alarm_info)
  62 {
  63         char query[MAX_QUERY_LEN] = {0,};
  64         char *error_message = NULL;
  65         alarm_info_t *alarm_info =
  66             (alarm_info_t *) &(__alarm_info->alarm_info);
  67         alarm_date_t *start = &alarm_info->start;
  68         alarm_mode_t *mode = &alarm_info->mode;
  69
  70         snprintf(query, MAX_QUERY_LEN, "insert into alarmmgr( alarm_id, start,\
  71                         end, pid, app_unique_name, app_service_name, app_service_name_mod, bundle, year,\
  72                         month, day, hour, min, sec, day_of_week, repeat,\
  73                         alarm_type, reserved_info, dst_service_name, dst_service_name_mod)\
  74                         values (%d,%d,%d,%d,'%s','%s','%s','%s',%d,%d,%d,%d,%d,%d,%d,%d,\
  75                         %d,%d,'%s','%s')",\
  76                         __alarm_info->alarm_id,
  77                         (int)__alarm_info->start,
  78                         (int)__alarm_info->end,
  79                         __alarm_info->pid,
  80                         (char *)g_quark_to_string(
  81                                 __alarm_info->quark_app_unique_name),
  82                         (char *)g_quark_to_string(
  83                                 __alarm_info->quark_app_service_name),
  84                         (char *)g_quark_to_string(
  85                                 __alarm_info->quark_app_service_name_mod),
  86                         (char *)g_quark_to_string(
  87                                 __alarm_info->quark_bundle),
  88                         start->year,
  89                         start->month,
  90                         start->day,
  91                         start->hour,
  92                         start->min,
  93                         start->sec,
  94                         mode->u_interval.day_of_week,
  95                         mode->repeat,
  96                         alarm_info->alarm_type,
  97                         alarm_info->reserved_info,
  98                         (char *)g_quark_to_string(
  99                         __alarm_info->quark_dst_service_name),
 100                         (char *)g_quark_to_string(
 101                         __alarm_info->quark_dst_service_name_mod));
 102
 103         if (SQLITE_OK !=
 104             sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 105                 ALARM_MGR_EXCEPTION_PRINT(
 106                     "Don't execute query = %s, error message = %s\n", query,
 107                      error_message);
 108                 return false;
 109         }
 110
 111         return true;
 112 }
 113
 114 bool _update_alarms(__alarm_info_t *__alarm_info)
 115 {
 116         char query[MAX_QUERY_LEN] = {0,};
 117         char *error_message = NULL;
 118         alarm_info_t *alarm_info =
 119             (alarm_info_t *) &(__alarm_info->alarm_info);
 120         alarm_date_t *start = &alarm_info->start;
 121         alarm_mode_t *mode = &alarm_info->mode;
 122
 123         snprintf(query, MAX_QUERY_LEN, "update alarmmgr set start=%d, end=%d,\
 124                         pid=%d, app_unique_name='%s', app_service_name='%s', app_service_name_mod='%s',\
 125                         bundle='%s', year=%d, month=%d, day=%d, hour=%d, min=%d, sec=%d,\
 126                         day_of_week=%d, repeat=%d, alarm_type=%d,\
 127                         reserved_info=%d, dst_service_name='%s', dst_service_name_mod='%s',\
 128                         where alarm_id=%d",\
 129                         (int)__alarm_info->start,
 130                         (int)__alarm_info->end,
 131                         __alarm_info->pid,
 132                         (char *)g_quark_to_string(
 133                                 __alarm_info->quark_app_unique_name),
 134                         (char *)g_quark_to_string(
 135                                 __alarm_info->quark_app_service_name),
 136                         (char *)g_quark_to_string(
 137                                 __alarm_info->quark_app_service_name_mod),
 138                         (char *)g_quark_to_string(
 139                                 __alarm_info->quark_bundle),
 140                         start->year,
 141                         start->month,
 142                         start->day,
 143                         start->hour,
 144                         start->min,
 145                         start->sec,
 146                         mode->u_interval.day_of_week,
 147                         mode->repeat,
 148                         alarm_info->alarm_type,
 149                         alarm_info->reserved_info,
 150                         (char *)g_quark_to_string(
 151                                 __alarm_info->quark_dst_service_name),
 152                         (char *)g_quark_to_string(
 153                                 __alarm_info->quark_dst_service_name_mod),
 154                         __alarm_info->alarm_id);
 155
 156         if (SQLITE_OK !=
 157             sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 158                 ALARM_MGR_EXCEPTION_PRINT(
 159                     "Don't execute query = %s, error message = %s\n", query,
 160                      error_message);
 161                 return false;
 162         }
 163
 164         return true;
 165
 166 }
 167
 168 bool _delete_alarms(alarm_id_t alarm_id)
 169 {
 170         char query[MAX_QUERY_LEN] = {0};
 171         char *error_message = NULL;
 172
 173         snprintf(query, MAX_QUERY_LEN, "delete from alarmmgr where alarm_id=%d",
 174                  alarm_id);
 175
 176         if (SQLITE_OK !=
 177             sqlite3_exec(alarmmgr_db, query, NULL, NULL, &error_message)) {
 178                 ALARM_MGR_EXCEPTION_PRINT(
 179                     "Don't execute query = %s, error message = %s\n", query,
 180                      error_message);
 181                 return false;
 182         }
 183
 184         return true;
 185
 186 }
 187
 188 #ifdef __ALARM_BOOT
 189 bool _update_power_on(bool on_off)
 190 {
 191 /*      GConfClient* pGCC;
 192         char key[MAX_GCONF_PATH_LEN];
 193         GError* error = NULL;
 194
 195         g_type_init();
 196         pGCC = gconf_client_get_default();
 197
 198         if(!pGCC)
 199         {
 200                 ALARM_MGR_EXCEPTION_PRINT(" gconf get failed.. \n");
 201                 return false;
 202         }
 203
 204         sprintf(key,"/Services/AlarmMgr/Auto_poweron");
 205
 206
 207         if(!gconf_client_set_bool(pGCC, key, on_off, &error))
 208         {
 209                 ALARM_MGR_EXCEPTION_PRINT("set string has failed...\n");
 210                 return false;
 211         }
 212
 213         gconf_client_suggest_sync(pGCC, NULL);
 214         g_object_unref(pGCC);
 215 */
 216         return false;
 217 }
 218 #endif
 219
 220 bool _load_alarms_from_registry()
 221 {
 222         int i = 0;
 223         char query[MAX_QUERY_LEN] = {0,};
 224         sqlite3_stmt *stmt = NULL;
 225         const char *tail = NULL;
 226         alarm_info_t *alarm_info = NULL;
 227         __alarm_info_t *__alarm_info = NULL;
 228         alarm_date_t *start = NULL;
 229         alarm_mode_t *mode = NULL;
 230         char app_unique_name[MAX_SERVICE_NAME_LEN] = {0,};
 231         char app_service_name[MAX_SERVICE_NAME_LEN] = {0,};
 232         char app_service_name_mod[MAX_SERVICE_NAME_LEN] = {0,};
 233         char dst_service_name[MAX_SERVICE_NAME_LEN] = {0,};
 234         char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = {0,};
 235         char bundle[MAX_BUNDLE_NAME_LEN] = {0,};
 236
 237 #ifdef __ALARM_BOOT
 238         /*sprintf(path, "/Services/AlarmMgr/Auto_poweron"); */
 239
 240         enable_power_on_alarm = 0;
 241         /*gconf_client_get_bool(pGCC, path, NULL); */
 242 #endif
 243
 244         snprintf(query, MAX_QUERY_LEN, "select * from alarmmgr");
 245
 246         if (SQLITE_OK !=
 247             sqlite3_prepare(alarmmgr_db, query, strlen(query), &stmt, &tail)) {
 248                 ALARM_MGR_EXCEPTION_PRINT("sqlite3_prepare error\n");
 249                 return false;
 250         }
 251
 252         for (i = 0; SQLITE_ROW == sqlite3_step(stmt); i++) {
 253                 __alarm_info = malloc(sizeof(__alarm_info_t));
 254
 255                 if (G_UNLIKELY(__alarm_info == NULL)){
 256                         ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Malloc failed\n");
 257                         return false;
 258                 }
 259                 alarm_info = (alarm_info_t *) &(__alarm_info->alarm_info);
 260                 start = &alarm_info->start;
 261                 mode = &alarm_info->mode;
 262
 263                 memset(app_service_name, 0, MAX_SERVICE_NAME_LEN);
 264                 memset(app_service_name_mod, 0, MAX_SERVICE_NAME_LEN);
 265                 memset(dst_service_name, 0, MAX_SERVICE_NAME_LEN);
 266                 memset(dst_service_name_mod, 0, MAX_SERVICE_NAME_LEN);
 267
 268                 __alarm_info->alarm_id = sqlite3_column_int(stmt, 0);
 269                 __alarm_info->start = sqlite3_column_int(stmt, 1);
 270                 __alarm_info->end = sqlite3_column_int(stmt, 2);
 271                 __alarm_info->pid = sqlite3_column_int(stmt, 3);
 272                 strncpy(app_unique_name, (const char *)sqlite3_column_text(stmt, 4),
 273                         MAX_SERVICE_NAME_LEN - 1);
 274                 strncpy(app_service_name, (const char *)sqlite3_column_text(stmt, 5),
 275                         MAX_SERVICE_NAME_LEN - 1);
 276                 strncpy(app_service_name_mod, (const char *)sqlite3_column_text(stmt, 6),
 277                         MAX_SERVICE_NAME_LEN - 1);
 278                 strncpy(bundle, (const char *)sqlite3_column_text(stmt, 7),
 279                         MAX_BUNDLE_NAME_LEN - 1);
 280                 start->year = sqlite3_column_int(stmt, 8);
 281                 start->month = sqlite3_column_int(stmt, 9);
 282                 start->day = sqlite3_column_int(stmt, 10);
 283                 start->hour = sqlite3_column_int(stmt, 11);
 284                 start->min = sqlite3_column_int(stmt, 12);
 285                 start->sec = sqlite3_column_int(stmt, 13);
 286                 mode->u_interval.day_of_week = sqlite3_column_int(stmt, 14);
 287                 mode->repeat = sqlite3_column_int(stmt, 15);
 288                 alarm_info->alarm_type = sqlite3_column_int(stmt, 16);
 289                 alarm_info->reserved_info = sqlite3_column_int(stmt, 17);
 290                 strncpy(dst_service_name, (const char *)sqlite3_column_text(stmt, 18),
 291                         MAX_SERVICE_NAME_LEN - 1);
 292                 strncpy(dst_service_name_mod, (const char *)sqlite3_column_text(stmt, 19),
 293                         MAX_SERVICE_NAME_LEN - 1);
 294
 295                 __alarm_info->quark_app_unique_name =
 296                     g_quark_from_string(app_unique_name);
 297                 __alarm_info->quark_app_service_name =
 298                     g_quark_from_string(app_service_name);
 299                 __alarm_info->quark_app_service_name_mod=
 300                     g_quark_from_string(app_service_name_mod);
 301                 __alarm_info->quark_dst_service_name =
 302                     g_quark_from_string(dst_service_name);
 303                 __alarm_info->quark_dst_service_name_mod=
 304                     g_quark_from_string(dst_service_name_mod);
 305                 __alarm_info->quark_bundle = g_quark_from_string(bundle);
 306
 307                 _alarm_next_duetime(__alarm_info);
 308                 alarm_context.alarms =
 309                     g_slist_append(alarm_context.alarms, __alarm_info);
 310         }
 311
 312         if (SQLITE_OK != sqlite3_finalize(stmt)) {
 313                 ALARM_MGR_EXCEPTION_PRINT("error : sqlite3_finalize\n");
 314                 return false;
 315         }
 316
 317         _alarm_schedule();
 318
 319         return true;
 320 }