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 "daprobe.h"
  36 #include "dahelper.h"
  37 #include "probeinfo.h"
  38 #include "binproto.h"
  39
  40 Ecore_Event_Handler *register_orientation_event_listener();
  41 void unregister_orientation_event_listener(Ecore_Event_Handler *handler);
  42
  43 app_event_callback_s gAppCallback;
  44
  45 #define PACK_ORIGINAL_APPFWCYCLE(API_ID, RTYPE, RVAL, INPUTFORMAT, ...)         \
  46         newerrno = errno;                                                       \
  47         do {                                                                    \
  48                 if(postBlockBegin(blockresult)) {                               \
  49                         PREPARE_LOCAL_BUF();                                    \
  50                         PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE, API_ID, INPUTFORMAT, __VA_ARGS__);       \
  51                         PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult);    \
  52                         FLUSH_LOCAL_BUF();                                      \
  53                         postBlockEnd();                                         \
  54                 }                                                               \
  55         } while(0);                                                             \
  56         errno = (newerrno != 0) ? newerrno : olderrno
  57
  58 static enum DaOptions _sopt = OPT_ALWAYSON;
  59
  60 static bool _dalc_app_create(void *user_data)
  61 {
  62         bool bret = false;
  63         DECLARE_VARIABLE_STANDARD;
  64
  65         bfiltering = false;
  66         PRE_PROBEBLOCK();
  67         bret = gAppCallback.create(user_data);
  68
  69         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_create, 'b', bret, "p",
  70                                  voidp_to_uint64(user_data));
  71
  72         return bret;
  73 }
  74
  75 static void _dalc_app_terminate(void *user_data)
  76 {
  77         DECLARE_VARIABLE_STANDARD;
  78
  79         bfiltering = false;
  80         PRE_PROBEBLOCK();
  81
  82         gAppCallback.terminate(user_data);
  83
  84         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_terminate, 'v', 0, "p",
  85                                  voidp_to_uint64(user_data));
  86 }
  87
  88 static void _dalc_app_pause(void *user_data)
  89 {
  90         DECLARE_VARIABLE_STANDARD;
  91
  92         bfiltering = false;
  93         PRE_PROBEBLOCK();
  94
  95         gAppCallback.pause(user_data);
  96
  97         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_pause, 'v', 0, "p",
  98                                  voidp_to_uint64(user_data));
  99 }
 100
 101 static void _dalc_app_resume(void *user_data)
 102 {
 103         DECLARE_VARIABLE_STANDARD;
 104
 105         bfiltering = false;
 106         PRE_PROBEBLOCK();
 107
 108         gAppCallback.resume(user_data);
 109
 110         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_resume, 'v', 0, "p",
 111                                  voidp_to_uint64(user_data));
 112 }
 113
 114 #ifdef PRIVATE_CAPI_APPFW
 115 static void _dalc_app_control(app_control_h handle, void *user_data)
 116 #else /* !PRIVATE_CAPI_APPFW */
 117 static void _dalc_app_service(service_h handle, void *user_data)
 118 #endif /* PRIVATE_CAPI_APPFW */
 119 {
 120         DECLARE_VARIABLE_STANDARD;
 121
 122         bfiltering = false;
 123         PRE_PROBEBLOCK();
 124
 125 #ifdef PRIVATE_CAPI_APPFW
 126         gAppCallback.app_control(handle, user_data);
 127 #else /* !PRIVATE_CAPI_APPFW */
 128         gAppCallback.service(handle, user_data);
 129 #endif /* PRIVATE_CAPI_APPFW */
 130
 131         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_service, 'v', 0, "dp",
 132                                  (unsigned int)handle,
 133                                  voidp_to_uint64(user_data));
 134 }
 135
 136 static void _dalc_app_deviceorientationchanged(app_device_orientation_e orientation, void *user_data)
 137 {
 138         on_orientation_changed((int)orientation, true);
 139
 140         if (gAppCallback.device_orientation)
 141                 gAppCallback.device_orientation(orientation, user_data);
 142 }
 143
 144 int app_efl_main(int *argc, char ***argv, app_event_callback_s *callback, void *user_data)
 145 {
 146         static int (*app_efl_mainp)(int *argc, char ***argv, app_event_callback_s *callback, void *user_data);
 147         Ecore_Event_Handler* handler;
 148         int ret;
 149
 150         GET_REAL_FUNCP_RTLD_NEXT(app_efl_main, app_efl_mainp);
 151
 152         probeBlockStart();
 153         handler = register_orientation_event_listener();
 154         gAppCallback.create = callback->create;
 155         gAppCallback.terminate = callback->terminate;
 156         gAppCallback.pause = callback->pause;
 157         gAppCallback.resume = callback->resume;
 158 #ifdef PRIVATE_CAPI_APPFW
 159         gAppCallback.app_control = callback->app_control;
 160 #else /* !PRIVATE_CAPI_APPFW */
 161         gAppCallback.service = callback->service;
 162 #endif /* PRIVATE_CAPI_APPFW */
 163         gAppCallback.device_orientation = callback->device_orientation;
 164
 165         if (callback->create)
 166                 callback->create = _dalc_app_create;
 167         if (callback->terminate)
 168                 callback->terminate = _dalc_app_terminate;
 169         if (callback->pause)
 170                 callback->pause = _dalc_app_pause;
 171         if (callback->resume)
 172                 callback->resume = _dalc_app_resume;
 173 #ifdef PRIVATE_CAPI_APPFW
 174         if (callback->app_control)
 175                 callback->app_control = _dalc_app_control;
 176 #else /* !PRIVATE_CAPI_APPFW */
 177         if (callback->service)
 178                 callback->service = _dalc_app_service;
 179 #endif /* PRIVATE_CAPI_APPFW */
 180         callback->device_orientation = _dalc_app_deviceorientationchanged;
 181         probeBlockEnd();
 182
 183         ret = app_efl_mainp(argc, argv, callback, user_data);
 184
 185         probeBlockStart();
 186         unregister_orientation_event_listener(handler);
 187         callback->create = gAppCallback.create;
 188         callback->terminate = gAppCallback.terminate;
 189         callback->pause = gAppCallback.pause;
 190         callback->resume = gAppCallback.resume;
 191 #ifdef PRIVATE_CAPI_APPFW
 192         callback->app_control = gAppCallback.app_control;
 193 #else /* !PRIVATE_CAPI_APPFW */
 194         callback->service = gAppCallback.service;
 195 #endif /* PRIVATE_CAPI_APPFW */
 196         callback->device_orientation = gAppCallback.device_orientation;
 197         probeBlockEnd();
 198
 199         return ret;
 200 }