probe_tizenapi/tizen_appfw.c

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (c) 2000 - 2013 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, 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(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;
  63         DECLARE_VARIABLE_STANDARD;
  64
  65         bfiltering = false;
  66         PRE_PROBEBLOCK();
  67
  68         bret = gAppCallback.create(user_data);
  69
  70         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_create, bret, "p", 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, 0, "p", user_data);
  85 }
  86
  87 static void _dalc_app_pause(void* user_data)
  88 {
  89         DECLARE_VARIABLE_STANDARD;
  90
  91         bfiltering = false;
  92         PRE_PROBEBLOCK();
  93
  94         gAppCallback.pause(user_data);
  95
  96         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_pause, 0, "p", user_data);
  97 }
  98
  99 static void _dalc_app_resume(void* user_data)
 100 {
 101         DECLARE_VARIABLE_STANDARD;
 102
 103         bfiltering = false;
 104         PRE_PROBEBLOCK();
 105
 106         gAppCallback.resume(user_data);
 107
 108         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_resume, 0, "p", user_data);
 109 }
 110
 111 static void _dalc_app_service(service_h service, void* user_data)
 112 {
 113         DECLARE_VARIABLE_STANDARD;
 114
 115         bfiltering = false;
 116         PRE_PROBEBLOCK();
 117
 118         gAppCallback.service(service, user_data);
 119
 120         PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_service, 0, "dp", (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         Ecore_Event_Handler* handler;
 135         int ret;
 136
 137         GET_REAL_FUNC(app_efl_main, LIBCAPI_APPFW_APPLICATION);
 138
 139         probeBlockStart();
 140         handler = register_orientation_event_listener();
 141         gAppCallback.create = callback->create;
 142         gAppCallback.terminate = callback->terminate;
 143         gAppCallback.pause = callback->pause;
 144         gAppCallback.resume = callback->resume;
 145         gAppCallback.service = callback->service;
 146         gAppCallback.device_orientation = callback->device_orientation;
 147
 148         if(callback->create)
 149                 callback->create = _dalc_app_create;
 150         if(callback->terminate)
 151                 callback->terminate = _dalc_app_terminate;
 152         if(callback->pause)
 153                 callback->pause = _dalc_app_pause;
 154         if(callback->resume)
 155                 callback->resume = _dalc_app_resume;
 156         if(callback->service)
 157                 callback->service = _dalc_app_service;
 158         callback->device_orientation = _dalc_app_deviceorientationchanged;
 159         probeBlockEnd();
 160
 161         ret = app_efl_mainp(argc, argv, callback, user_data);
 162
 163         probeBlockStart();
 164         unregister_orientation_event_listener(handler);
 165         callback->create = gAppCallback.create;
 166         callback->terminate = gAppCallback.terminate;
 167         callback->pause = gAppCallback.pause;
 168         callback->resume = gAppCallback.resume;
 169         callback->service = gAppCallback.service;
 170         callback->device_orientation = gAppCallback.device_orientation;
 171         probeBlockEnd();
 172
 173         return ret;
 174 }
 175