src/dbus_gesture_adapter.c

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "dbus_gesture_adapter.h"
  18 #include "logger.h"
  19
  20 #include <Eldbus.h>
  21
  22 #define E_A11Y_SERVICE_BUS_NAME "com.samsung.EModule"
  23 #define E_A11Y_SERVICE_NAVI_IFC_NAME "com.samsung.GestureNavigation"
  24 #define E_A11Y_SERVICE_NAVI_OBJ_PATH "/com/samsung/GestureNavigation"
  25
  26 static Eldbus_Connection *conn;
  27 static Eldbus_Service_Interface *service;
  28
  29 enum _Signals {
  30         GESTURE_DETECTED = 0,
  31 };
  32
  33 static const Eldbus_Signal _signals[] = {
  34         [GESTURE_DETECTED] = {"GestureDetected", ELDBUS_ARGS({"siiiiu", NULL}), 0},
  35         {NULL, ELDBUS_ARGS({NULL, NULL}), 0}
  36 };
  37
  38 static const Eldbus_Service_Interface_Desc desc = {
  39         E_A11Y_SERVICE_NAVI_IFC_NAME, NULL, _signals, NULL, NULL, NULL
  40 };
  41
  42 void _on_get_a11y_address(void *data, const Eldbus_Message * msg, Eldbus_Pending * pending)
  43 {
  44         const char *sock_addr;
  45         const char *errname, *errmsg;
  46         Eldbus_Connection *session = data;
  47
  48         if (eldbus_message_error_get(msg, &errname, &errmsg)) {
  49                 ERROR("GetAddress failed: %s %s", errname, errmsg);
  50                 return;
  51         }
  52
  53         if (!eldbus_message_arguments_get(msg, "s", &sock_addr) || !sock_addr) {
  54                 ERROR("Could not get A11Y Bus socket address.");
  55                 goto end;
  56         }
  57
  58         if (!(conn = eldbus_address_connection_get(sock_addr))) {
  59                 ERROR("Failed to connect to %s", sock_addr);
  60                 goto end;
  61         }
  62
  63         if (!(service = eldbus_service_interface_register(conn, E_A11Y_SERVICE_NAVI_OBJ_PATH, &desc))) {
  64                 ERROR("Failed to register %s interface", E_A11Y_SERVICE_NAVI_IFC_NAME);
  65                 eldbus_connection_unref(conn);
  66                 conn = NULL;
  67                 goto end;
  68         }
  69
  70         eldbus_name_request(conn, E_A11Y_SERVICE_BUS_NAME, ELDBUS_NAME_REQUEST_FLAG_DO_NOT_QUEUE, NULL, NULL);
  71
  72  end:
  73         eldbus_connection_unref(session);
  74 }
  75
  76 void dbus_gesture_adapter_init(void)
  77 {
  78         Eldbus_Connection *session;
  79         Eldbus_Message *msg;
  80
  81         eldbus_init();
  82
  83         if (!(session = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION))) {
  84                 ERROR("Unable to get session bus");
  85                 return;
  86         }
  87
  88         if (!(msg = eldbus_message_method_call_new("org.a11y.Bus", "/org/a11y/bus", "org.a11y.Bus", "GetAddress"))) {
  89                 ERROR("DBus message allocation failed");
  90                 goto fail_msg;
  91         }
  92
  93         if (!eldbus_connection_send(session, msg, _on_get_a11y_address, session, -1)) {
  94                 ERROR("Message send failed");
  95                 goto fail_send;
  96         }
  97
  98         return;
  99
 100  fail_send:
 101         eldbus_message_unref(msg);
 102  fail_msg:
 103         eldbus_connection_unref(session);
 104 }
 105
 106 void dbus_gesture_adapter_shutdown(void)
 107 {
 108         if (service)
 109                 eldbus_service_object_unregister(service);
 110         if (conn)
 111                 eldbus_connection_unref(conn);
 112
 113         conn = NULL;
 114         service = NULL;
 115
 116         eldbus_shutdown();
 117 }
 118
 119 static const char *_gesture_enum_to_string(Gesture g)
 120 {
 121         switch (g) {
 122         case ONE_FINGER_HOVER:
 123                 return "OneFingerHover";
 124         case TWO_FINGERS_HOVER:
 125                 return "TwoFingersHover";
 126         case THREE_FINGERS_HOVER:
 127                 return "ThreeFingersHover";
 128         case ONE_FINGER_FLICK_LEFT:
 129                 return "OneFingerFlickLeft";
 130         case ONE_FINGER_FLICK_RIGHT:
 131                 return "OneFingerFlickRight";
 132         case ONE_FINGER_FLICK_UP:
 133                 return "OneFingerFlickUp";
 134         case ONE_FINGER_FLICK_DOWN:
 135                 return "OneFingerFlickDown";
 136         case TWO_FINGERS_FLICK_UP:
 137                 return "TwoFingersFlickUp";
 138         case TWO_FINGERS_FLICK_DOWN:
 139                 return "TwoFingersFlickDown";
 140         case TWO_FINGERS_FLICK_LEFT:
 141                 return "TwoFingersFlickLeft";
 142         case TWO_FINGERS_FLICK_RIGHT:
 143                 return "TwoFingersFlickRight";
 144         case THREE_FINGERS_FLICK_LEFT:
 145                 return "ThreeFingersFlickLeft";
 146         case THREE_FINGERS_FLICK_RIGHT:
 147                 return "ThreeFingersFlickRight";
 148         case THREE_FINGERS_FLICK_UP:
 149                 return "ThreeFingersFlickUp";
 150         case THREE_FINGERS_FLICK_DOWN:
 151                 return "ThreeFingersFlickDown";
 152         case ONE_FINGER_SINGLE_TAP:
 153                 return "OneFingerSingleTap";
 154         case ONE_FINGER_DOUBLE_TAP:
 155                 return "OneFingerDoubleTap";
 156         case ONE_FINGER_TRIPLE_TAP:
 157                 return "OneFingerTripleTap";
 158         case TWO_FINGERS_SINGLE_TAP:
 159                 return "TwoFingersSingleTap";
 160         case TWO_FINGERS_DOUBLE_TAP:
 161                 return "TwoFingersDoubleTap";
 162         case TWO_FINGERS_TRIPLE_TAP:
 163                 return "TwoFingersTripleTap";
 164         case THREE_FINGERS_SINGLE_TAP:
 165                 return "ThreeFingersSingleTap";
 166         case THREE_FINGERS_DOUBLE_TAP:
 167                 return "ThreeFingersDoubleTap";
 168         case THREE_FINGERS_TRIPLE_TAP:
 169                 return "ThreeFingersTripleTap";
 170         case ONE_FINGER_FLICK_LEFT_RETURN:
 171                 return "OneFingerFlickLeftReturn";
 172         case ONE_FINGER_FLICK_RIGHT_RETURN:
 173                 return "OneFingerFlickRightReturn";
 174         case ONE_FINGER_FLICK_UP_RETURN:
 175                 return "OneFingerFlickUpReturn";
 176         case ONE_FINGER_FLICK_DOWN_RETURN:
 177                 return "OneFingerFlickDownReturn";
 178         case TWO_FINGERS_FLICK_LEFT_RETURN:
 179                 return "TwoFingersFlickLeftReturn";
 180         case TWO_FINGERS_FLICK_RIGHT_RETURN:
 181                 return "TwoFingersFlickRightReturn";
 182         case TWO_FINGERS_FLICK_UP_RETURN:
 183                 return "TwoFingersFlickUpReturn";
 184         case TWO_FINGERS_FLICK_DOWN_RETURN:
 185                 return "TwoFingersFlickDownReturn";
 186         case THREE_FINGERS_FLICK_LEFT_RETURN:
 187                 return "ThreeFingersFlickLeftReturn";
 188         case THREE_FINGERS_FLICK_RIGHT_RETURN:
 189                 return "ThreeFingersFlickRightReturn";
 190         case THREE_FINGERS_FLICK_UP_RETURN:
 191                 return "ThreeFingersFlickUpReturn";
 192         case THREE_FINGERS_FLICK_DOWN_RETURN:
 193                 return "ThreeFingersFlickDownReturn";
 194         default:
 195                 ERROR("unhandled gesture enum");
 196                 return NULL;
 197         }
 198 }
 199
 200 void dbus_gesture_adapter_emit(const Gesture_Info * info)
 201 {
 202         const char *name;
 203
 204         if (!service)
 205                 return;
 206
 207         name = _gesture_enum_to_string(info->type);
 208         if (!name)
 209                 return;
 210
 211         if (!eldbus_service_signal_emit(service, GESTURE_DETECTED, name, info->x_beg, info->y_beg, info->x_end, info->y_end, info->state)) {
 212                 ERROR("Unable to send GestureDetected signal");
 213         } else
 214                 DEBUG("Successfullt send GestureDetected singal");
 215 }