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