probe_capi/capi_appfw.c

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Jaewon Lim <jaewon81.lim@samsung.com>
   9  * Woojin Jung <woojin2.jung@samsung.com>
  10  * Juyoung Kim <j0.kim@samsung.com>
  11  * Anastasia Lyupa <a.lyupa@samsung.com>
  12  *
  13  * This library is free software; you can redistribute it and/or modify it under
  14  * the terms of the GNU Lesser General Public License as published by the
  15  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  16  * any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  20  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  21  * License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  25  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  26  *
  27  * Contributors:
  28  * - S-Core Co., Ltd
  29  * - Samsung RnD Institute Russia
  30  *
  31  */
  32
  33 #include <app.h>
  34 #include <Ecore.h>
  35 #include "damaps.h"
  36 #include "daprobe.h"
  37 #include "dahelper.h"
  38 #include "probeinfo.h"
  39 #include "binproto.h"
  40 #include "real_functions.h"
  41 #include "common_probe_init.h"
  42 #include "api_config.h"
  43
  44 Ecore_Event_Handler *register_orientation_event_listener();
  45 void unregister_orientation_event_listener(Ecore_Event_Handler *handler);
  46
  47 app_event_callback_s gAppCallback;
  48 ui_app_lifecycle_callback_s uiAppCallback;
  49
  50 #define PACK_ORIGINAL_APPFWCYCLE(API_ID, RTYPE, RVAL, INPUTFORMAT, ...)         \
  51         newerrno = errno;                                                       \
  52         do {                                                                    \
  53                 PREPARE_LOCAL_BUF();                                    \
  54                 PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE, API_ID, INPUTFORMAT, __VA_ARGS__);       \
  55                 PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult);    \
  56                 FLUSH_LOCAL_BUF();                                      \
  57         } while(0);                                                             \
  58         errno = (newerrno != 0) ? newerrno : olderrno
  59
  60 static bool _dalc_app_create(void *user_data)
  61 {
  62         bool bret = false;
  63         DECLARE_ERRNO_VARS;
  64         int blockresult = 1;
  65
  66         bret = gAppCallback.create(user_data);
  67
  68         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_create, 'b', bret, "p",
  69                                  voidp_to_uint64(user_data));
  70
  71         return bret;
  72 }
  73
  74 static void _dalc_app_terminate(void *user_data)
  75 {
  76         DECLARE_ERRNO_VARS;
  77         int blockresult = 1;
  78
  79         gAppCallback.terminate(user_data);
  80
  81         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_terminate, 'v', 0, "p",
  82                                  voidp_to_uint64(user_data));
  83 }
  84
  85 static void _dalc_app_pause(void *user_data)
  86 {
  87         DECLARE_ERRNO_VARS;
  88         int blockresult = 1;
  89
  90         gAppCallback.pause(user_data);
  91
  92         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_pause, 'v', 0, "p",
  93                                  voidp_to_uint64(user_data));
  94 }
  95
  96 static void _dalc_app_resume(void *user_data)
  97 {
  98         DECLARE_ERRNO_VARS;
  99         int blockresult = 1;
 100
 101         gAppCallback.resume(user_data);
 102
 103         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_resume, 'v', 0, "p",
 104                                  voidp_to_uint64(user_data));
 105 }
 106
 107 #ifdef PRIVATE_CAPI_APPFW
 108 static void _dalc_app_control(app_control_h handle, void *user_data)
 109 #else /* !PRIVATE_CAPI_APPFW */
 110 static void _dalc_app_service(service_h handle, void *user_data)
 111 #endif /* PRIVATE_CAPI_APPFW */
 112 {
 113         DECLARE_ERRNO_VARS;
 114         int blockresult = 1;
 115
 116 #ifdef PRIVATE_CAPI_APPFW
 117         gAppCallback.app_control(handle, user_data);
 118 #else /* !PRIVATE_CAPI_APPFW */
 119         gAppCallback.service(handle, user_data);
 120 #endif /* PRIVATE_CAPI_APPFW */
 121
 122         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_service, 'v', 0, "dp",
 123                                  (unsigned int)handle,
 124                                  voidp_to_uint64(user_data));
 125 }
 126
 127 static void _dalc_app_deviceorientationchanged(app_device_orientation_e orientation, void *user_data)
 128 {
 129         on_orientation_changed((int)orientation, true);
 130
 131         if (gAppCallback.device_orientation)
 132                 gAppCallback.device_orientation(orientation, user_data);
 133 }
 134
 135 int app_efl_main(int *argc, char ***argv, app_event_callback_s *callback, void *user_data)
 136 {
 137         static int (*app_efl_mainp)(int *argc, char ***argv, app_event_callback_s *callback, void *user_data);
 138         Ecore_Event_Handler* handler;
 139         int ret;
 140
 141         GET_REAL_FUNCP_RTLD_NEXT(app_efl_main, app_efl_mainp);
 142
 143         probeBlockStart();
 144         handler = register_orientation_event_listener();
 145         gAppCallback.create = callback->create;
 146         gAppCallback.terminate = callback->terminate;
 147         gAppCallback.pause = callback->pause;
 148         gAppCallback.resume = callback->resume;
 149 #ifdef PRIVATE_CAPI_APPFW
 150         gAppCallback.app_control = callback->app_control;
 151 #else /* !PRIVATE_CAPI_APPFW */
 152         gAppCallback.service = callback->service;
 153 #endif /* PRIVATE_CAPI_APPFW */
 154         gAppCallback.device_orientation = callback->device_orientation;
 155
 156         if (callback->create)
 157                 callback->create = _dalc_app_create;
 158         if (callback->terminate)
 159                 callback->terminate = _dalc_app_terminate;
 160         if (callback->pause)
 161                 callback->pause = _dalc_app_pause;
 162         if (callback->resume)
 163                 callback->resume = _dalc_app_resume;
 164 #ifdef PRIVATE_CAPI_APPFW
 165         if (callback->app_control)
 166                 callback->app_control = _dalc_app_control;
 167 #else /* !PRIVATE_CAPI_APPFW */
 168         if (callback->service)
 169                 callback->service = _dalc_app_service;
 170 #endif /* PRIVATE_CAPI_APPFW */
 171         callback->device_orientation = _dalc_app_deviceorientationchanged;
 172         probeBlockEnd();
 173
 174         ret = app_efl_mainp(argc, argv, callback, user_data);
 175
 176         probeBlockStart();
 177         unregister_orientation_event_listener(handler);
 178         callback->create = gAppCallback.create;
 179         callback->terminate = gAppCallback.terminate;
 180         callback->pause = gAppCallback.pause;
 181         callback->resume = gAppCallback.resume;
 182 #ifdef PRIVATE_CAPI_APPFW
 183         callback->app_control = gAppCallback.app_control;
 184 #else /* !PRIVATE_CAPI_APPFW */
 185         callback->service = gAppCallback.service;
 186 #endif /* PRIVATE_CAPI_APPFW */
 187         callback->device_orientation = gAppCallback.device_orientation;
 188         probeBlockEnd();
 189
 190         return ret;
 191 }
 192
 193
 194 /************************************ UI APP ******************************************/
 195 static bool _ui_dalc_app_create(void *user_data)
 196 {
 197         bool bret = false;
 198         DECLARE_ERRNO_VARS;
 199         int blockresult = 1;
 200
 201         bret = uiAppCallback.create(user_data);
 202
 203         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_create, 'b', bret, "p",
 204                                  voidp_to_uint64(user_data));
 205
 206         return bret;
 207 }
 208
 209 static void _ui_dalc_app_terminate(void *user_data)
 210 {
 211         DECLARE_ERRNO_VARS;
 212         int blockresult = 1;
 213
 214         uiAppCallback.terminate(user_data);
 215
 216         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_terminate, 'v', 0, "p",
 217                                  voidp_to_uint64(user_data));
 218 }
 219
 220 static void _ui_dalc_app_pause(void *user_data)
 221 {
 222         DECLARE_ERRNO_VARS;
 223         int blockresult = 1;
 224
 225         uiAppCallback.pause(user_data);
 226
 227         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_pause, 'v', 0, "p",
 228                                  voidp_to_uint64(user_data));
 229 }
 230
 231 static void _ui_dalc_app_resume(void *user_data)
 232 {
 233         DECLARE_ERRNO_VARS;
 234         int blockresult = 1;
 235
 236         uiAppCallback.resume(user_data);
 237
 238         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_resume, 'v', 0, "p",
 239                                  voidp_to_uint64(user_data));
 240 }
 241
 242 static void _ui_dalc_app_control(app_control_h handle, void *user_data)
 243 {
 244         DECLARE_ERRNO_VARS;
 245         int blockresult = 1;
 246
 247         uiAppCallback.app_control(handle, user_data);
 248
 249         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_service, 'v', 0, "dp",
 250                                  (unsigned int)handle,
 251                                  voidp_to_uint64(user_data));
 252 }
 253
 254 int ui_app_main(int argc, char **argv, ui_app_lifecycle_callback_s *callback, void *user_data)
 255 {
 256         static int (*ui_app_mainp)(int argc, char **argv, ui_app_lifecycle_callback_s *callback, void *user_data);
 257         Ecore_Event_Handler* handler;
 258         int ret;
 259
 260         GET_REAL_FUNCP_RTLD_NEXT(ui_app_main, ui_app_mainp);
 261
 262         probeBlockStart();
 263         handler = register_orientation_event_listener();
 264         uiAppCallback.create = callback->create;
 265         uiAppCallback.terminate = callback->terminate;
 266         uiAppCallback.pause = callback->pause;
 267         uiAppCallback.resume = callback->resume;
 268
 269         uiAppCallback.app_control = callback->app_control;
 270
 271         if (callback->create)
 272                 callback->create = _ui_dalc_app_create;
 273         if (callback->terminate)
 274                 callback->terminate = _ui_dalc_app_terminate;
 275         if (callback->pause)
 276                 callback->pause = _ui_dalc_app_pause;
 277         if (callback->resume)
 278                 callback->resume = _ui_dalc_app_resume;
 279
 280         if (callback->app_control)
 281                 callback->app_control = _ui_dalc_app_control;
 282
 283         probeBlockEnd();
 284
 285         ret = ui_app_mainp(argc, argv, callback, user_data);
 286
 287         probeBlockStart();
 288         unregister_orientation_event_listener(handler);
 289
 290         callback->create = uiAppCallback.create;
 291         callback->terminate = uiAppCallback.terminate;
 292         callback->pause = uiAppCallback.pause;
 293         callback->resume = uiAppCallback.resume;
 294         callback->app_control = uiAppCallback.app_control;
 295
 296         probeBlockEnd();
 297
 298         return ret;
 299 }