probe_tizenapi/tizen_appfw.c

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (c) 2000 - 2011 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  *
  12  * This library is free software; you can redistribute it and/or modify it under
  13  * the terms of the GNU Lesser General Public License as published by the
  14  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  15  * any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  20  * License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  24  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25  *
  26  * Contributors:
  27  * - S-Core Co., Ltd
  28  *
  29  */
  30
  31 #include <app.h>
  32 #include "daprobe.h"
  33 #include "dahelper.h"
  34 #include "probeinfo.h"
  35
  36 app_event_callback_s gAppCallback;
  37
  38 #define AFTER_ORIGINAL_APPFWCYCLE(RTYPE, RVAL, FUNCNAME, INPUTFORMAT, ...)      \
  39         newerrno = errno;                                                                                                               \
  40         do {                                                                                                                                    \
  41                 if(postBlockBegin(blockresult)) {                                                                       \
  42                         INIT_LOG;                                                                                                               \
  43                         APPEND_LOG_BASIC_NAME(LC_LIFECYCLE, #FUNCNAME);                                 \
  44                         APPEND_LOG_INPUT(INPUTFORMAT, __VA_ARGS__);                                             \
  45                         APPEND_LOG_RESULT(RTYPE, RVAL);                                                                 \
  46                         __appendTypeLog(&log, 1, NULL, VT_INT, 0);                                              \
  47                         printLog(&log, MSG_LOG);                                                                                \
  48                         postBlockEnd();                                                                                                 \
  49                 }                                                                                                                                       \
  50         } while(0);                                                                                                                             \
  51         errno = (newerrno != 0) ? newerrno : olderrno
  52
  53
  54 static bool _dalc_app_create(void* user_data)
  55 {
  56         bool bret;
  57         DECLARE_VARIABLE_STANDARD;
  58
  59         bfiltering = false;
  60         PRE_PROBEBLOCK();
  61
  62         bret = gAppCallback.create(user_data);
  63
  64         AFTER_ORIGINAL_APPFWCYCLE(VT_INT, bret, usercallback_app_create,
  65                         "%p", user_data);
  66
  67         return bret;
  68 }
  69
  70 static void _dalc_app_terminate(void* user_data)
  71 {
  72         DECLARE_VARIABLE_STANDARD;
  73
  74         bfiltering = false;
  75         PRE_PROBEBLOCK();
  76
  77         gAppCallback.terminate(user_data);
  78
  79         AFTER_ORIGINAL_APPFWCYCLE(VT_NULL, NULL, usercallback_app_terminate,
  80                         "%p", user_data);
  81 }
  82
  83 static void _dalc_app_pause(void* user_data)
  84 {
  85         DECLARE_VARIABLE_STANDARD;
  86
  87         bfiltering = false;
  88         PRE_PROBEBLOCK();
  89
  90         gAppCallback.pause(user_data);
  91
  92         AFTER_ORIGINAL_APPFWCYCLE(VT_NULL, NULL, usercallback_app_pause,
  93                         "%p", user_data);
  94 }
  95
  96 static void _dalc_app_resume(void* user_data)
  97 {
  98         DECLARE_VARIABLE_STANDARD;
  99
 100         bfiltering = false;
 101         PRE_PROBEBLOCK();
 102
 103         gAppCallback.resume(user_data);
 104
 105         AFTER_ORIGINAL_APPFWCYCLE(VT_NULL, NULL, usercallback_app_resume,
 106                         "%p", user_data);
 107 }
 108
 109 static void _dalc_app_service(service_h service, void* user_data)
 110 {
 111         DECLARE_VARIABLE_STANDARD;
 112
 113         bfiltering = false;
 114         PRE_PROBEBLOCK();
 115
 116         gAppCallback.service(service, user_data);
 117
 118         AFTER_ORIGINAL_APPFWCYCLE(VT_NULL, NULL, usercallback_app_service,
 119                         "%u, %p", (unsigned int)service, user_data);
 120 }
 121
 122 static void _dalc_app_deviceorientationchanged(app_device_orientation_e orientation, void* user_data)
 123 {
 124         on_orientation_changed((int)orientation, true);
 125
 126         if(gAppCallback.device_orientation)
 127                 gAppCallback.device_orientation(orientation, user_data);
 128 }
 129
 130 int app_efl_main(int *argc, char ***argv, app_event_callback_s *callback, void *user_data)
 131 {
 132         static int (*app_efl_mainp)(int* argc, char*** argv, app_event_callback_s* callback, void* user_data);
 133         int ret;
 134
 135         GET_REAL_FUNC(app_efl_main, libcapi-appfw-application.so.0);
 136
 137         gAppCallback.create = callback->create;
 138         gAppCallback.terminate = callback->terminate;
 139         gAppCallback.pause = callback->pause;
 140         gAppCallback.resume = callback->resume;
 141         gAppCallback.service = callback->service;
 142         gAppCallback.device_orientation = callback->device_orientation;
 143
 144         if(callback->create)
 145                 callback->create = _dalc_app_create;
 146         if(callback->terminate)
 147                 callback->terminate = _dalc_app_terminate;
 148         if(callback->pause)
 149                 callback->pause = _dalc_app_pause;
 150         if(callback->resume)
 151                 callback->resume = _dalc_app_resume;
 152         if(callback->service)
 153                 callback->service = _dalc_app_service;
 154         callback->device_orientation = _dalc_app_deviceorientationchanged;
 155
 156         ret = app_efl_mainp(argc, argv, callback, user_data);
 157
 158         callback->create = gAppCallback.create;
 159         callback->terminate = gAppCallback.terminate;
 160         callback->pause = gAppCallback.pause;
 161         callback->resume = gAppCallback.resume;
 162         callback->service = gAppCallback.service;
 163         callback->device_orientation = gAppCallback.device_orientation;
 164
 165         return ret;
 166 }
 167