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 static enum DaOptions _sopt = OPT_ALWAYSON;
  54
  55 static bool _dalc_app_create(void* user_data)
  56 {
  57         bool bret;
  58         DECLARE_VARIABLE_STANDARD;
  59
  60         bfiltering = false;
  61         PRE_PROBEBLOCK();
  62
  63         bret = gAppCallback.create(user_data);
  64
  65         AFTER_ORIGINAL_APPFWCYCLE(VT_INT, bret, usercallback_app_create,
  66                         "%p", user_data);
  67
  68         return bret;
  69 }
  70
  71 static void _dalc_app_terminate(void* user_data)
  72 {
  73         DECLARE_VARIABLE_STANDARD;
  74
  75         bfiltering = false;
  76         PRE_PROBEBLOCK();
  77
  78         gAppCallback.terminate(user_data);
  79
  80         AFTER_ORIGINAL_APPFWCYCLE(VT_NULL, NULL, usercallback_app_terminate,
  81                         "%p", user_data);
  82 }
  83
  84 static void _dalc_app_pause(void* user_data)
  85 {
  86         DECLARE_VARIABLE_STANDARD;
  87
  88         bfiltering = false;
  89         PRE_PROBEBLOCK();
  90
  91         gAppCallback.pause(user_data);
  92
  93         AFTER_ORIGINAL_APPFWCYCLE(VT_NULL, NULL, usercallback_app_pause,
  94                         "%p", user_data);
  95 }
  96
  97 static void _dalc_app_resume(void* user_data)
  98 {
  99         DECLARE_VARIABLE_STANDARD;
 100
 101         bfiltering = false;
 102         PRE_PROBEBLOCK();
 103
 104         gAppCallback.resume(user_data);
 105
 106         AFTER_ORIGINAL_APPFWCYCLE(VT_NULL, NULL, usercallback_app_resume,
 107                         "%p", user_data);
 108 }
 109
 110 static void _dalc_app_service(service_h service, void* user_data)
 111 {
 112         DECLARE_VARIABLE_STANDARD;
 113
 114         bfiltering = false;
 115         PRE_PROBEBLOCK();
 116
 117         gAppCallback.service(service, user_data);
 118
 119         AFTER_ORIGINAL_APPFWCYCLE(VT_NULL, NULL, usercallback_app_service,
 120                         "%u, %p", (unsigned int)service, user_data);
 121 }
 122
 123 static void _dalc_app_deviceorientationchanged(app_device_orientation_e orientation, void* user_data)
 124 {
 125         on_orientation_changed((int)orientation, true);
 126
 127         if(gAppCallback.device_orientation)
 128                 gAppCallback.device_orientation(orientation, user_data);
 129 }
 130
 131 int app_efl_main(int *argc, char ***argv, app_event_callback_s *callback, void *user_data)
 132 {
 133         static int (*app_efl_mainp)(int* argc, char*** argv, app_event_callback_s* callback, void* user_data);
 134         int ret;
 135
 136         GET_REAL_FUNC(app_efl_main, LIBCAPI_APPFW_APPLICATION);
 137
 138         gAppCallback.create = callback->create;
 139         gAppCallback.terminate = callback->terminate;
 140         gAppCallback.pause = callback->pause;
 141         gAppCallback.resume = callback->resume;
 142         gAppCallback.service = callback->service;
 143         gAppCallback.device_orientation = callback->device_orientation;
 144
 145         if(callback->create)
 146                 callback->create = _dalc_app_create;
 147         if(callback->terminate)
 148                 callback->terminate = _dalc_app_terminate;
 149         if(callback->pause)
 150                 callback->pause = _dalc_app_pause;
 151         if(callback->resume)
 152                 callback->resume = _dalc_app_resume;
 153         if(callback->service)
 154                 callback->service = _dalc_app_service;
 155         callback->device_orientation = _dalc_app_deviceorientationchanged;
 156
 157         ret = app_efl_mainp(argc, argv, callback, user_data);
 158
 159         callback->create = gAppCallback.create;
 160         callback->terminate = gAppCallback.terminate;
 161         callback->pause = gAppCallback.pause;
 162         callback->resume = gAppCallback.resume;
 163         callback->service = gAppCallback.service;
 164         callback->device_orientation = gAppCallback.device_orientation;
 165
 166         return ret;
 167 }
 168