Add multi-user support
[platform/core/appfw/app-core.git] / src / appcore.c
1 /*
2  *  app-core
3  *
4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
5  *
6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>, Jaeho Lee <jaeho81.lee@samsung.com>
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  *
20  */
21
22
23 #define _GNU_SOURCE
24
25 #include <errno.h>
26 #include <string.h>
27 #include <stdlib.h>
28 #include <sys/types.h>
29 #include <unistd.h>
30 #include <malloc.h>
31 #include <locale.h>
32 #include <linux/limits.h>
33 #include <glib.h>
34 #include <sys/time.h>
35 #include <dlfcn.h>
36 #include <vconf.h>
37 #include <aul.h>
38 #include <tzplatform_config.h>
39 #include "appcore-internal.h"
40
41 #define SQLITE_FLUSH_MAX                (1024*1024)
42
43 #define PKGNAME_MAX 256
44 #define PATH_APP_ROOT tzplatform_getenv(TZ_USER_APP)
45 #define PATH_RO_APP_ROOT tzplatform_getenv(TZ_SYS_RO_APP)
46 #define PATH_RES "/res"
47 #define PATH_LOCALE "/locale"
48
49 static struct appcore core;
50 static pid_t _pid;
51
52 static enum appcore_event to_ae[SE_MAX] = {
53         APPCORE_EVENT_UNKNOWN,  /* SE_UNKNOWN */
54         APPCORE_EVENT_LOW_MEMORY,       /* SE_LOWMEM */
55         APPCORE_EVENT_LOW_BATTERY,      /* SE_LOWBAT */
56         APPCORE_EVENT_LANG_CHANGE,      /* SE_LANGCGH */
57         APPCORE_EVENT_REGION_CHANGE,
58 };
59
60
61 enum cb_type {                  /* callback */
62         _CB_NONE,
63         _CB_SYSNOTI,
64         _CB_APPNOTI,
65         _CB_VCONF,
66 };
67
68 struct evt_ops {
69         enum cb_type type;
70         union {
71                 enum appcore_event sys;
72                 enum app_event app;
73                 const char *vkey;
74         } key;
75
76         int (*cb_pre) (void *);
77         int (*cb) (void *);
78         int (*cb_post) (void *);
79
80         int (*vcb_pre) (void *, void *);
81         int (*vcb) (void *, void *);
82         int (*vcb_post) (void *, void *);
83 };
84
85 struct open_s {
86         int (*callback) (void *);
87         void *cbdata;
88 };
89
90 static struct open_s open;
91
92 static int __app_terminate(void *data);
93 static int __app_resume(void *data);
94 static int __app_reset(void *data, bundle *k);
95
96 static int __sys_lowmem_post(void *data, void *evt);
97 static int __sys_lowmem(void *data, void *evt);
98 static int __sys_lowbatt(void *data, void *evt);
99 static int __sys_langchg_pre(void *data, void *evt);
100 static int __sys_langchg(void *data, void *evt);
101 static int __sys_regionchg_pre(void *data, void *evt);
102 static int __sys_regionchg(void *data, void *evt);
103 extern void aul_finalize();
104
105
106 static struct evt_ops evtops[] = {
107         {
108          .type = _CB_VCONF,
109          .key.vkey = VCONFKEY_SYSMAN_LOW_MEMORY,
110          .vcb_post = __sys_lowmem_post,
111          .vcb = __sys_lowmem,
112          },
113         {
114          .type = _CB_VCONF,
115          .key.vkey = VCONFKEY_SYSMAN_BATTERY_STATUS_LOW,
116          .vcb = __sys_lowbatt,
117          },
118         {
119          .type = _CB_VCONF,
120          .key.vkey = VCONFKEY_LANGSET,
121          .vcb_pre = __sys_langchg_pre,
122          .vcb = __sys_langchg,
123          },
124         {
125          .type = _CB_VCONF,
126          .key.vkey = VCONFKEY_REGIONFORMAT,
127          .vcb_pre = __sys_regionchg_pre,
128          .vcb = __sys_regionchg,
129          },
130         {
131          .type = _CB_VCONF,
132          .key.vkey = VCONFKEY_REGIONFORMAT_TIME1224,
133          .vcb = __sys_regionchg,
134          },
135 };
136
137 static int __get_dir_name(char *dirname)
138 {
139         char pkg_name[PKGNAME_MAX];
140         int r;
141         int pid;
142
143         pid = getpid();
144         if (pid < 0)
145                 return -1;
146
147         if (aul_app_get_pkgname_bypid(pid, pkg_name, PKGNAME_MAX) != AUL_R_OK)
148                 return -1;
149
150         r = snprintf(dirname, PATH_MAX, "%s/%s" PATH_RES PATH_LOCALE,
151                         PATH_APP_ROOT, pkg_name);
152         if (r < 0)
153                 return -1;
154         if (access(dirname, R_OK) == 0) return 0;
155         r = snprintf(dirname, PATH_MAX, "%s/%s" PATH_RES PATH_LOCALE,
156                         PATH_RO_APP_ROOT, pkg_name);
157         if (r < 0)
158                 return -1;
159
160         return 0;
161 }
162
163 static int __app_terminate(void *data)
164 {
165         struct appcore *ac = data;
166
167         _retv_if(ac == NULL || ac->ops == NULL, -1);
168         _retv_if(ac->ops->cb_app == NULL, 0);
169
170         ac->ops->cb_app(AE_TERMINATE, ac->ops->data, NULL);
171
172         return 0;
173 }
174
175 static gboolean __prt_ltime(gpointer data)
176 {
177         int msec;
178
179         msec = appcore_measure_time_from(NULL);
180         if (msec)
181                 _DBG("[APP %d] first idle after reset: %d msec", _pid, msec);
182
183         return FALSE;
184 }
185
186 static int __app_reset(void *data, bundle * k)
187 {
188         struct appcore *ac = data;
189         _retv_if(ac == NULL || ac->ops == NULL, -1);
190         _retv_if(ac->ops->cb_app == NULL, 0);
191
192         g_idle_add(__prt_ltime, ac);
193
194         ac->ops->cb_app(AE_RESET, ac->ops->data, k);
195
196         return 0;
197 }
198
199 static int __app_resume(void *data)
200 {
201 #ifdef WAYLAND
202         struct appcore *ac = data;
203
204         _retv_if(ac == NULL || ac->ops == NULL, -1);
205         _retv_if(ac->ops->cb_app == NULL, 0);
206
207         ac->ops->cb_app(AE_RESUME, ac->ops->data, NULL);
208
209 #else
210         x_raise_win(getpid());
211 #endif
212         return 0;
213 }
214
215 static int __sys_do_default(struct appcore *ac, enum sys_event event)
216 {
217         int r;
218
219         switch (event) {
220         case SE_LOWBAT:
221                 /*r = __def_lowbatt(ac);*/
222                 r = 0;
223                 break;
224         default:
225                 r = 0;
226                 break;
227         };
228
229         return r;
230 }
231
232 static int __sys_do(struct appcore *ac, enum sys_event event)
233 {
234         struct sys_op *op;
235
236         _retv_if(ac == NULL || event >= SE_MAX, -1);
237
238         op = &ac->sops[event];
239
240         if (op->func == NULL)
241                 return __sys_do_default(ac, event);
242
243         return op->func(op->data);
244 }
245
246 static int __sys_lowmem_post(void *data, void *evt)
247 {
248         keynode_t *key = evt;
249         int val;
250
251         val = vconf_keynode_get_int(key);
252
253         if (val >= VCONFKEY_SYSMAN_LOW_MEMORY_SOFT_WARNING)     {
254 #if defined(MEMORY_FLUSH_ACTIVATE)
255                 struct appcore *ac = data;
256                 ac->ops->cb_app(AE_LOWMEM_POST, ac->ops->data, NULL);
257 #else
258                 malloc_trim(0);
259 #endif
260         }
261         return 0;
262 }
263
264 static int __sys_lowmem(void *data, void *evt)
265 {
266         keynode_t *key = evt;
267         int val;
268
269         val = vconf_keynode_get_int(key);
270
271         if (val >= VCONFKEY_SYSMAN_LOW_MEMORY_SOFT_WARNING)
272                 return __sys_do(data, SE_LOWMEM);
273
274         return 0;
275 }
276
277 static int __sys_lowbatt(void *data, void *evt)
278 {
279         keynode_t *key = evt;
280         int val;
281
282         val = vconf_keynode_get_int(key);
283
284         /* VCONFKEY_SYSMAN_BAT_CRITICAL_LOW or VCONFKEY_SYSMAN_POWER_OFF */
285         if (val <= VCONFKEY_SYSMAN_BAT_CRITICAL_LOW)
286                 return __sys_do(data, SE_LOWBAT);
287
288         return 0;
289 }
290
291 static int __sys_langchg_pre(void *data, void *evt)
292 {
293         update_lang();
294         return 0;
295 }
296
297 static int __sys_langchg(void *data, void *evt)
298 {
299         return __sys_do(data, SE_LANGCHG);
300 }
301
302 static int __sys_regionchg_pre(void *data, void *evt)
303 {
304         update_region();
305         return 0;
306 }
307
308 static int __sys_regionchg(void *data, void *evt)
309 {
310         return __sys_do(data, SE_REGIONCHG);
311 }
312
313 static void __vconf_do(struct evt_ops *eo, keynode_t * key, void *data)
314 {
315         _ret_if(eo == NULL);
316
317         if (eo->vcb_pre)
318                 eo->vcb_pre(data, key);
319
320         if (eo->vcb)
321                 eo->vcb(data, key);
322
323         if (eo->vcb_post)
324                 eo->vcb_post(data, key);
325 }
326
327 static void __vconf_cb(keynode_t *key, void *data)
328 {
329         int i;
330         const char *name;
331
332         name = vconf_keynode_get_name(key);
333         _ret_if(name == NULL);
334
335         _DBG("[APP %d] vconf changed: %s", _pid, name);
336
337         for (i = 0; i < sizeof(evtops) / sizeof(evtops[0]); i++) {
338                 struct evt_ops *eo = &evtops[i];
339
340                 switch (eo->type) {
341                 case _CB_VCONF:
342                         if (!strcmp(name, eo->key.vkey))
343                                 __vconf_do(eo, key, data);
344                         break;
345                 default:
346                         /* do nothing */
347                         break;
348                 }
349         }
350 }
351
352 static int __add_vconf(struct appcore *ac)
353 {
354         int i;
355         int r;
356
357         for (i = 0; i < sizeof(evtops) / sizeof(evtops[0]); i++) {
358                 struct evt_ops *eo = &evtops[i];
359
360                 switch (eo->type) {
361                 case _CB_VCONF:
362                         r = vconf_notify_key_changed(eo->key.vkey, __vconf_cb,
363                                                      ac);
364                         break;
365                 default:
366                         /* do nothing */
367                         break;
368                 }
369         }
370
371         return 0;
372 }
373
374 static int __del_vconf(void)
375 {
376         int i;
377         int r;
378
379         for (i = 0; i < sizeof(evtops) / sizeof(evtops[0]); i++) {
380                 struct evt_ops *eo = &evtops[i];
381
382                 switch (eo->type) {
383                 case _CB_VCONF:
384                         r = vconf_ignore_key_changed(eo->key.vkey, __vconf_cb);
385                         break;
386                 default:
387                         /* do nothing */
388                         break;
389                 }
390         }
391
392         return 0;
393 }
394
395 static int __aul_handler(aul_type type, bundle *b, void *data)
396 {
397         int ret;
398
399         switch (type) {
400         case AUL_START:
401                 _DBG("[APP %d]     AUL event: AUL_START", _pid);
402                 __app_reset(data, b);
403                 break;
404         case AUL_RESUME:
405                 _DBG("[APP %d]     AUL event: AUL_RESUME", _pid);
406                 if(open.callback) {
407                         ret = open.callback(open.cbdata);
408                         if (ret == 0)
409                                 __app_resume(data);
410                 } else {
411                         __app_resume(data);
412                 }
413                 break;
414         case AUL_TERMINATE:
415                 _DBG("[APP %d]     AUL event: AUL_TERMINATE", _pid);
416                 __app_terminate(data);
417                 break;
418         default:
419                 _DBG("[APP %d]     AUL event: %d", _pid, type);
420                 /* do nothing */
421                 break;
422         }
423
424         return 0;
425 }
426
427
428 static void __clear(struct appcore *ac)
429 {
430         memset(ac, 0, sizeof(struct appcore));
431 }
432
433 EXPORT_API int appcore_set_open_cb(int (*cb) (void *),
434                                        void *data)
435 {
436         open.callback = cb;
437         open.cbdata = data;
438
439         return 0;
440 }
441
442 EXPORT_API int appcore_set_event_callback(enum appcore_event event,
443                                           int (*cb) (void *), void *data)
444 {
445         struct appcore *ac = &core;
446         struct sys_op *op;
447         enum sys_event se;
448
449         for (se = SE_UNKNOWN; se < SE_MAX; se++) {
450                 if (event == to_ae[se])
451                         break;
452         }
453
454         if (se == SE_UNKNOWN || se >= SE_MAX) {
455                 _ERR("Unregistered event");
456                 errno = EINVAL;
457                 return -1;
458         }
459
460         op = &ac->sops[se];
461
462         op->func = cb;
463         op->data = data;
464
465         return 0;
466 }
467
468
469
470 EXPORT_API int appcore_init(const char *name, const struct ui_ops *ops,
471                             int argc, char **argv)
472 {
473         int r;
474         char dirname[PATH_MAX];
475
476         if (core.state != 0) {
477                 _ERR("Already in use");
478                 errno = EALREADY;
479                 return -1;
480         }
481
482         if (ops == NULL || ops->cb_app == NULL) {
483                 _ERR("ops or callback function is null");
484                 errno = EINVAL;
485                 return -1;
486         }
487
488         r = __get_dir_name(dirname);
489         r = set_i18n(name, dirname);
490         _retv_if(r == -1, -1);
491
492         r = __add_vconf(&core);
493         if (r == -1) {
494                 _ERR("Add vconf callback failed");
495                 goto err;
496         }
497
498         r = aul_launch_init(__aul_handler, &core);
499         if (r < 0) {
500                 _ERR("Aul init failed: %d", r);
501                 goto err;
502         }
503
504         r = aul_launch_argv_handler(argc, argv);
505         if (r < 0) {
506                 _ERR("Aul argv handler failed: %d", r);
507                 goto err;
508         }
509
510         core.ops = ops;
511         core.state = 1;         /* TODO: use enum value */
512
513         _pid = getpid();
514
515         return 0;
516  err:
517         __del_vconf();
518         __clear(&core);
519         return -1;
520 }
521
522 EXPORT_API void appcore_exit(void)
523 {
524         if (core.state) {
525                 __del_vconf();
526                 __clear(&core);
527         }
528         aul_finalize();
529 }
530
531 EXPORT_API int appcore_flush_memory(void)
532 {
533         int (*flush_fn) (int);
534         int size = 0;
535
536         struct appcore *ac = &core;
537
538         if (!core.state) {
539                 _ERR("Appcore not initialized");
540                 return -1;
541         }
542
543         _DBG("[APP %d] Flushing memory ...", _pid);
544
545         if (ac->ops->cb_app) {
546                 ac->ops->cb_app(AE_MEM_FLUSH, ac->ops->data, NULL);
547         }
548
549         flush_fn = dlsym(RTLD_DEFAULT, "sqlite3_release_memory");
550         if (flush_fn) {
551                 size = flush_fn(SQLITE_FLUSH_MAX);
552         }
553
554         malloc_trim(0);
555         /*
556         *Disabled - the impact of stack_trim() is unclear
557         *stack_trim();
558         */
559
560         _DBG("[APP %d] Flushing memory DONE", _pid);
561
562         return 0;
563 }