probe_event/gesture.cpp

   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 "daprobe.h"
  34 #include "dahelper.h"
  35 #include "probeinfo.h"
  36 #include "tizen_probe.h"
  37 #include "dacollection.h"
  38 #include "da_event.h"
  39 #include "gesture.h"
  40 #include "binproto.h"
  41
  42 #define PACK_GESTURE_EVENT(API_ID, _GESTURETYPE, _X, _Y, _INFO1, _INFO2, _ARGDETECTOR) \
  43         do {                                                                                                                                            \
  44                 char info1_str[16];                                                                                                             \
  45                 setProbePoint(&probeInfo);                                                                                              \
  46                 PREPARE_LOCAL_BUF();                                                                                                    \
  47                 PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, API_ID, "p", voidp_to_uint64(_ARGDETECTOR));       \
  48                 PACK_COMMON_END('v', 0, 0, 0);                                                                                          \
  49                 sprintf(info1_str, "%d", _INFO1);                                                                               \
  50                 PACK_UIEVENT(_EVENT_GESTURE, _GESTURETYPE, _X, _Y, info1_str, _INFO2);  \
  51                 FLUSH_LOCAL_BUF();                                                                                                              \
  52         } while (0)
  53
  54 GestureEventListener GestureEventListener::rInstance;
  55
  56 GestureEventListener::GestureEventListener()
  57 {
  58
  59 }
  60
  61 GestureEventListener::~GestureEventListener()
  62 {
  63
  64 }
  65
  66 void GestureEventListener::OnCustomGestureCanceled (TouchGestureDetector &gestureDetector)
  67 {
  68         probeInfo_t     probeInfo;
  69
  70         if(isOptionEnabled(OPT_EVENT))
  71         {
  72                 probeBlockStart();
  73                 PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnCustomGestureCanceled__TouchGestureDetector__gestureDetector_,
  74                                    _GESTURE_CUSTOM, 0, 0, 0, 0, &gestureDetector);
  75                 probeBlockEnd();
  76         }
  77 }
  78
  79 void GestureEventListener::OnCustomGestureChanged (TouchGestureDetector &gestureDetector)
  80 {
  81         probeInfo_t     probeInfo;
  82
  83         if(isOptionEnabled(OPT_EVENT))
  84         {
  85                 probeBlockStart();
  86                 PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnCustomGestureChanged__TouchGestureDetector__gestureDetector_,
  87                                    _GESTURE_CUSTOM, 0, 0, 0, 0, &gestureDetector);
  88                 probeBlockEnd();
  89         }
  90 }
  91
  92 void GestureEventListener::OnCustomGestureFinished (TouchGestureDetector &gestureDetector)
  93 {
  94         probeInfo_t     probeInfo;
  95
  96         if(isOptionEnabled(OPT_EVENT))
  97         {
  98                 probeBlockStart();
  99                 PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnCustomGestureFinished__TouchGestureDetector__gestureDetector_,
 100                                    _GESTURE_CUSTOM, 0, 0, 0, 0, &gestureDetector);
 101                 probeBlockEnd();
 102         }
 103 }
 104
 105 void GestureEventListener::OnCustomGestureStarted (TouchGestureDetector &gestureDetector)
 106 {
 107         probeInfo_t     probeInfo;
 108
 109         if(isOptionEnabled(OPT_EVENT))
 110         {
 111                 probeBlockStart();
 112                 PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnCustomGestureStarted__TouchGestureDetector__gestureDetector_,
 113                                    _GESTURE_CUSTOM, 0, 0, 0, 0, &gestureDetector);
 114                 probeBlockEnd();
 115         }
 116 }
 117
 118 void GestureEventListener::OnFlickGestureCanceled (TouchFlickGestureDetector &gestureDetector)
 119 {
 120         probeInfo_t     probeInfo;
 121
 122         if(isOptionEnabled(OPT_EVENT))
 123         {
 124                 probeBlockStart();
 125                 {
 126                         int x = 0, y = 0, dur = 0;
 127                         FlickDirection direction = FLICK_DIRECTION_NONE;
 128
 129                         gestureDetector.GetDistance(x, y);
 130                         dur = gestureDetector.GetDuration();
 131                         direction = gestureDetector.GetDirection();
 132                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnFlickGestureCanceled__TouchFlickGestureDetector__gestureDetector_,
 133                                            _GESTURE_FLICK, x, y, dur, (int)direction, &gestureDetector);
 134                 }
 135                 probeBlockEnd();
 136         }
 137 }
 138
 139 void GestureEventListener::OnFlickGestureDetected (TouchFlickGestureDetector &gestureDetector)
 140 {
 141         probeInfo_t     probeInfo;
 142
 143         if(isOptionEnabled(OPT_EVENT))
 144         {
 145                 probeBlockStart();
 146                 {
 147                         int x = 0, y = 0, dur = 0;
 148                         FlickDirection direction = FLICK_DIRECTION_NONE;
 149
 150                         gestureDetector.GetDistance(x, y);
 151                         dur = gestureDetector.GetDuration();
 152                         direction = gestureDetector.GetDirection();
 153                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnFlickGestureDetected__TouchFlickGestureDetector__gestureDetector_,
 154                                            _GESTURE_FLICK, x, y, dur, (int)direction, &gestureDetector);
 155                 }
 156                 probeBlockEnd();
 157         }
 158 }
 159
 160 void GestureEventListener::OnLongPressGestureCanceled (TouchLongPressGestureDetector &gestureDetector)
 161 {
 162         probeInfo_t     probeInfo;
 163
 164         if(isOptionEnabled(OPT_EVENT))
 165         {
 166                 probeBlockStart();
 167                 {
 168                         int moveallow = 0, tcount = 0, dur = 0;
 169
 170                         moveallow = gestureDetector.GetMoveAllowance();
 171                         dur = gestureDetector.GetDuration();
 172                         tcount = gestureDetector.GetTouchCount();
 173                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnLongPressGestureCanceled__TouchLongPressGestureDetector__gestureDetector_,
 174                                            _GESTURE_LONGPRESS, moveallow, 0, dur, tcount, &gestureDetector);
 175                 }
 176                 probeBlockEnd();
 177         }
 178 }
 179
 180 void GestureEventListener::OnLongPressGestureDetected (TouchLongPressGestureDetector &gestureDetector)
 181 {
 182         probeInfo_t     probeInfo;
 183
 184         if(isOptionEnabled(OPT_EVENT))
 185         {
 186                 probeBlockStart();
 187                 {
 188                         int moveallow = 0, tcount = 0, dur = 0;
 189
 190                         moveallow = gestureDetector.GetMoveAllowance();
 191                         dur = gestureDetector.GetDuration();
 192                         tcount = gestureDetector.GetTouchCount();
 193                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnLongPressGestureDetected__TouchLongPressGestureDetector__gestureDetector_,
 194                                            _GESTURE_LONGPRESS, moveallow, 0, dur, tcount, &gestureDetector);
 195                 }
 196                 probeBlockEnd();
 197         }
 198 }
 199
 200 void GestureEventListener::OnPanningGestureCanceled (TouchPanningGestureDetector &gestureDetector)
 201 {
 202         probeInfo_t     probeInfo;
 203
 204         if(isOptionEnabled(OPT_EVENT))
 205         {
 206                 probeBlockStart();
 207                 {
 208                         int tcount = 0;
 209
 210                         tcount = gestureDetector.GetTouchCount();
 211                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnPanningGestureCanceled__TouchPanningGestureDetector__gestureDetector_,
 212                                            _GESTURE_PANNING, 0, 0, 0, tcount, &gestureDetector);
 213                 }
 214                 probeBlockEnd();
 215         }
 216 }
 217
 218 void GestureEventListener::OnPanningGestureChanged (TouchPanningGestureDetector &gestureDetector)
 219 {
 220         probeInfo_t     probeInfo;
 221
 222         if(isOptionEnabled(OPT_EVENT))
 223         {
 224                 probeBlockStart();
 225                 {
 226                         int tcount = 0;
 227
 228                         tcount = gestureDetector.GetTouchCount();
 229                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnPanningGestureChanged__TouchPanningGestureDetector__gestureDetector_,
 230                                            _GESTURE_PANNING, 0, 0, 0, tcount, &gestureDetector);
 231                 }
 232                 probeBlockEnd();
 233         }
 234 }
 235
 236 void GestureEventListener::OnPanningGestureFinished (TouchPanningGestureDetector &gestureDetector)
 237 {
 238         probeInfo_t     probeInfo;
 239
 240         if(isOptionEnabled(OPT_EVENT))
 241         {
 242                 probeBlockStart();
 243                 {
 244                         int tcount = 0;
 245
 246                         tcount = gestureDetector.GetTouchCount();
 247                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnPanningGestureFinished__TouchPanningGestureDetector__gestureDetector_,
 248                                            _GESTURE_PANNING, 0, 0, 0, tcount, &gestureDetector);
 249                 }
 250                 probeBlockEnd();
 251         }
 252 }
 253
 254 void GestureEventListener::OnPanningGestureStarted (TouchPanningGestureDetector &gestureDetector)
 255 {
 256         probeInfo_t     probeInfo;
 257
 258         if(isOptionEnabled(OPT_EVENT))
 259         {
 260                 probeBlockStart();
 261                 {
 262                         int tcount = 0;
 263
 264                         tcount = gestureDetector.GetTouchCount();
 265                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnPanningGestureStarted__TouchPanningGestureDetector__gestureDetector_,
 266                                            _GESTURE_PANNING, 0, 0, 0, tcount, &gestureDetector);
 267                 }
 268                 probeBlockEnd();
 269         }
 270 }
 271
 272 void GestureEventListener::OnPinchGestureCanceled (TouchPinchGestureDetector &gestureDetector)
 273 {
 274         probeInfo_t     probeInfo;
 275
 276         if(isOptionEnabled(OPT_EVENT))
 277         {
 278                 probeBlockStart();
 279                 {
 280                         Tizen::Graphics::Point point;
 281                         int scale = 0;
 282
 283                         point = gestureDetector.GetCenterPoint();
 284                         scale = gestureDetector.GetScale();
 285                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnPinchGestureCanceled__TouchPinchGestureDetector__gestureDetector_,
 286                                            _GESTURE_PINCH, point.x, point.y, scale, 0, &gestureDetector);
 287                 }
 288                 probeBlockEnd();
 289         }
 290 }
 291
 292 void GestureEventListener::OnPinchGestureChanged (TouchPinchGestureDetector &gestureDetector)
 293 {
 294         probeInfo_t     probeInfo;
 295
 296         if(isOptionEnabled(OPT_EVENT))
 297         {
 298                 probeBlockStart();
 299                 {
 300                         Tizen::Graphics::Point point;
 301                         int scale = 0;
 302
 303                         point = gestureDetector.GetCenterPoint();
 304                         scale = gestureDetector.GetScale();
 305                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnPinchGestureChanged__TouchPinchGestureDetector__gestureDetector_,
 306                                            _GESTURE_PINCH, point.x, point.y, scale, 0, &gestureDetector);
 307                 }
 308                 probeBlockEnd();
 309         }
 310 }
 311
 312 void GestureEventListener::OnPinchGestureFinished (TouchPinchGestureDetector &gestureDetector)
 313 {
 314         probeInfo_t     probeInfo;
 315
 316         if(isOptionEnabled(OPT_EVENT))
 317         {
 318                 probeBlockStart();
 319                 {
 320                         Tizen::Graphics::Point point;
 321                         int scale = 0;
 322
 323                         point = gestureDetector.GetCenterPoint();
 324                         scale = gestureDetector.GetScale();
 325                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnPinchGestureFinished__TouchPinchGestureDetector__gestureDetector_,
 326                                            _GESTURE_PINCH, point.x, point.y, scale, 0, &gestureDetector);
 327                 }
 328                 probeBlockEnd();
 329         }
 330 }
 331
 332 void GestureEventListener::OnPinchGestureStarted (TouchPinchGestureDetector &gestureDetector)
 333 {
 334         probeInfo_t     probeInfo;
 335
 336         if(isOptionEnabled(OPT_EVENT))
 337         {
 338                 probeBlockStart();
 339                 {
 340                         Tizen::Graphics::Point point;
 341                         int scale = 0;
 342
 343                         point = gestureDetector.GetCenterPoint();
 344                         scale = gestureDetector.GetScale();
 345                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnPinchGestureStarted__TouchPinchGestureDetector__gestureDetector_,
 346                                            _GESTURE_PINCH, point.x, point.y, scale, 0, &gestureDetector);
 347                 }
 348                 probeBlockEnd();
 349         }
 350 }
 351
 352 void GestureEventListener::OnRotationGestureCanceled (TouchRotationGestureDetector &gestureDetector)
 353 {
 354         probeInfo_t     probeInfo;
 355
 356         if(isOptionEnabled(OPT_EVENT))
 357         {
 358                 probeBlockStart();
 359                 {
 360                         int distance = 0;
 361                         float angle = 0.0f;
 362
 363                         distance = gestureDetector.GetDistance();
 364                         angle = gestureDetector.GetAngle();
 365                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnRotationGestureCanceled__TouchRotationGestureDetector__gestureDetector_,
 366                                            _GESTURE_ROTATION, 0, 0, distance, static_cast<int>(angle), &gestureDetector);
 367                 }
 368                 probeBlockEnd();
 369         }
 370 }
 371
 372 void GestureEventListener::OnRotationGestureChanged (TouchRotationGestureDetector &gestureDetector)
 373 {
 374         probeInfo_t     probeInfo;
 375
 376         if(isOptionEnabled(OPT_EVENT))
 377         {
 378                 probeBlockStart();
 379                 {
 380                         int distance = 0;
 381                         float angle = 0.0f;
 382
 383                         distance = gestureDetector.GetDistance();
 384                         angle = gestureDetector.GetAngle();
 385                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnRotationGestureChanged__TouchRotationGestureDetector__gestureDetector_,
 386                                            _GESTURE_ROTATION, 0, 0, distance, static_cast<int>(angle), &gestureDetector);
 387                 }
 388                 probeBlockEnd();
 389         }
 390 }
 391
 392 void GestureEventListener::OnRotationGestureFinished (TouchRotationGestureDetector &gestureDetector)
 393 {
 394         probeInfo_t     probeInfo;
 395
 396         if(isOptionEnabled(OPT_EVENT))
 397         {
 398                 probeBlockStart();
 399                 {
 400                         int distance = 0;
 401                         float angle = 0.0f;
 402
 403                         distance = gestureDetector.GetDistance();
 404                         angle = gestureDetector.GetAngle();
 405                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnRotationGestureFinished__TouchRotationGestureDetector__gestureDetector_,
 406                                            _GESTURE_ROTATION, 0, 0, distance, static_cast<int>(angle), &gestureDetector);
 407                 }
 408                 probeBlockEnd();
 409         }
 410 }
 411
 412 void GestureEventListener::OnRotationGestureStarted (TouchRotationGestureDetector &gestureDetector)
 413 {
 414         probeInfo_t     probeInfo;
 415
 416         if(isOptionEnabled(OPT_EVENT))
 417         {
 418                 probeBlockStart();
 419                 {
 420                         int distance = 0;
 421                         float angle = 0.0f;
 422
 423                         distance = gestureDetector.GetDistance();
 424                         angle = gestureDetector.GetAngle();
 425                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnRotationGestureStarted__TouchRotationGestureDetector__gestureDetector_,
 426                                            _GESTURE_ROTATION, 0, 0, distance, static_cast<int>(angle), &gestureDetector);
 427                 }
 428                 probeBlockEnd();
 429         }
 430 }
 431
 432 void GestureEventListener::OnTapGestureCanceled (TouchTapGestureDetector &gestureDetector)
 433 {
 434         probeInfo_t     probeInfo;
 435
 436         if(isOptionEnabled(OPT_EVENT))
 437         {
 438                 probeBlockStart();
 439                 {
 440                         int move = 0, tapcount = 0, touchcount = 0, interval = 0;
 441
 442                         move = gestureDetector.GetMoveAllowance();
 443                         tapcount = gestureDetector.GetTapCount();
 444                         interval = gestureDetector.GetTapInterval();
 445                         touchcount = gestureDetector.GetTouchCount();
 446                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnTapGestureCanceled__TouchTapGestureDetector__gestureDetector_,
 447                                            _GESTURE_TAP, move, tapcount, interval, touchcount, &gestureDetector);
 448                 }
 449                 probeBlockEnd();
 450         }
 451 }
 452
 453 void GestureEventListener::OnTapGestureDetected (TouchTapGestureDetector &gestureDetector)
 454 {
 455         probeInfo_t     probeInfo;
 456
 457         if(isOptionEnabled(OPT_EVENT))
 458         {
 459                 probeBlockStart();
 460                 {
 461                         int move = 0, tapcount = 0, touchcount = 0, interval = 0;
 462
 463                         move = gestureDetector.GetMoveAllowance();
 464                         tapcount = gestureDetector.GetTapCount();
 465                         interval = gestureDetector.GetTapInterval();
 466                         touchcount = gestureDetector.GetTouchCount();
 467                         PACK_GESTURE_EVENT(API_ID_void_GestureEventListener__OnTapGestureDetected__TouchTapGestureDetector__gestureDetector_,
 468                                            _GESTURE_TAP, move, tapcount, interval, touchcount, &gestureDetector);
 469                 }
 470                 probeBlockEnd();
 471         }
 472 }
 473
 474 GestureEventListener& GestureEventListener::GetInstance()
 475 {
 476         return rInstance;
 477 }