lib/system-controller/CicoSCWlInputMgrIF.cpp

   1 /*
   2  * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
   3  *
   4  * This program is licensed under the terms and conditions of the
   5  * Apache License, version 2.0.  The full tWlExt of the Apache License is at
   6  * http://www.apache.org/licenses/LICENSE-2.0
   7  *
   8  */
   9
  10 //==========================================================================
  11 /**
  12  *  @file   CicoSCWlInputMgrIF.cpp
  13  *
  14  *  @brief  This file implementation of CicoSCInputDev class
  15  */
  16 //==========================================================================
  17
  18 #include <cstring>
  19
  20 #include <string>
  21 using namespace std;
  22
  23 #include "CicoSCWlInputMgrIF.h"
  24 #include "CicoSCWayland.h"
  25 #include "CicoLog.h"
  26
  27 //--------------------------------------------------------------------------
  28 /**
  29  *  @brief  default constructor
  30  */
  31 //--------------------------------------------------------------------------
  32 CicoSCWlInputMgrIF::CicoSCWlInputMgrIF()
  33     : m_inputmgr(NULL), m_exinput(NULL), m_inputmgrdev(NULL)
  34 {
  35     // ico_exinput listener
  36     m_exInputListener.capabilities = wlCapabilitiesCB;
  37     m_exInputListener.code         = wlCodeCB;
  38     m_exInputListener.input        = wlInputCB;
  39
  40     // ico_input_mgr_device listener
  41     m_devListener.input_regions    = wlRegionCB;
  42 }
  43
  44 //--------------------------------------------------------------------------
  45 /**
  46  *  @brief  destructor
  47  */
  48 //--------------------------------------------------------------------------
  49 CicoSCWlInputMgrIF::~CicoSCWlInputMgrIF()
  50 {
  51 }
  52
  53 //--------------------------------------------------------------------------
  54 /**
  55  *  @brief  initialize ico_input_mgr interfaces
  56  *
  57  *  @param [in] data        user data
  58  *  @param [in] registry    wayland registry
  59  *  @param [in] name        wayland display id
  60  *  @parma [in] interface   wayland interface name
  61  *  @parma [in] version     wayland interface version number
  62  */
  63 //--------------------------------------------------------------------------
  64 void
  65 CicoSCWlInputMgrIF::initInterface(void               *data,
  66                                   struct wl_registry *registry,
  67                                   uint32_t           name,
  68                                   const char         *interface,
  69                                   uint32_t           version)
  70 {
  71     ICO_TRA("CicoSCWlInputMgrIF::initInterface : Enter(interface=%s)",
  72             interface);
  73
  74     if (0 == strcmp(interface, ICO_WL_INPUT_MGR_CTRL_IF)) {
  75         // get interface instance
  76         ICO_DBG("called: wl_registry_bind");
  77         void *wlProxy = wl_registry_bind(registry,
  78                                          name,
  79                                          &ico_input_mgr_control_interface,
  80                                          1);
  81         if (NULL == wlProxy) {
  82             ICO_WRN("interface(%s) wl_registry_bind failed.", interface);
  83             ICO_TRA("CicoSCWlInputMgrIF::initInterface Leave",
  84                     "(binding failed)");
  85             return;
  86         }
  87         m_inputmgr = (struct ico_input_mgr_control*)wlProxy;
  88     }
  89     else if (0 == strcmp(interface, ICO_WL_EXINPUT_IF)) {
  90         // get interface instance
  91         ICO_DBG("called: wl_registry_bind");
  92         void *wlProxy = wl_registry_bind(registry,
  93                                          name,
  94                                          &ico_exinput_interface,
  95                                          1);
  96         if (NULL == wlProxy) {
  97             ICO_WRN("interface(%s) wl_registry_bind failed.", interface);
  98             ICO_TRA("CicoSCWlInputMgrIF::initInterface Leave",
  99                     "(binding failed)");
 100             return;
 101         }
 102
 103         m_exinput = (struct ico_exinput*)wlProxy;
 104         ico_exinput_add_listener(m_exinput,
 105                                  &m_exInputListener,
 106                                  this);
 107     }
 108     else if (0 == strcmp(interface, ICO_WL_INPUT_MGR_DEV_IF)) {
 109         // get interface instance
 110         ICO_DBG("called: wl_registry_bind");
 111         void *wlProxy = wl_registry_bind(registry,
 112                                          name,
 113                                          &ico_input_mgr_device_interface,
 114                                          1);
 115         if (NULL == wlProxy) {
 116             ICO_WRN("interface(%s) wl_registry_bind failed.", interface);
 117             ICO_TRA("CicoSCWlInputMgrIF::initInterface Leave"
 118                     "(binding failed)");
 119             return;
 120         }
 121
 122         m_inputmgrdev = (struct ico_input_mgr_device*)wlProxy;
 123         ico_input_mgr_device_add_listener(m_inputmgrdev,
 124                                           &m_devListener,
 125                                           this);
 126     }
 127
 128     if ((NULL != m_inputmgrdev) &&
 129         (NULL != m_inputmgr) &&
 130         (NULL != m_exinput)) {
 131         m_initialized = true;
 132     }
 133     ICO_TRA("CicoSCWlInputMgrIF::initInterface Leave");
 134 }
 135
 136 //--------------------------------------------------------------------------
 137 /**
 138  *  @brief  wrapper function ico_input_mgr_control_add_input_app
 139  *
 140  *  @param [in] appid   application id
 141  *  @param [in] device  input device name
 142  *  @param [in] input   input number
 143  *  @parma [in] fix     fixed assign flag
 144  *  @parma [in] keycode assigned keycode value
 145  */
 146 //--------------------------------------------------------------------------
 147 void
 148 CicoSCWlInputMgrIF::addInputApp(const string &appid,
 149                                 const string &device,
 150                                 int          input,
 151                                 int          fix,
 152                                 int          keycode)
 153 {
 154     ICO_DBG("called: ico_input_mgr_control_add_input_app"
 155             "(appid=%s device=%s input=%d fix=%d keycode=%d)",
 156             appid.c_str(), device.c_str(), input, fix, keycode);
 157     ico_input_mgr_control_add_input_app(m_inputmgr,appid.c_str(),
 158                                         device.c_str(), input, fix, keycode);
 159     // flush display
 160     CicoSCWayland::getInstance()->flushDisplay();
 161 }
 162
 163 //--------------------------------------------------------------------------
 164 /**
 165  *  @brief  wrapper function ico_input_mgr_control_del_input_app
 166  *
 167  *  @param [in] appid   application id
 168  *  @param [in] device  input device name
 169  *  @param [in] input   input number
 170  */
 171 //--------------------------------------------------------------------------
 172 void
 173 CicoSCWlInputMgrIF::delInputApp(const string &appid,
 174                                 const string &device,
 175                                 int          input)
 176 {
 177     ICO_DBG("called: ico_input_mgr_control_del_input_app"
 178             "(appid=%s device=%s input=%d)",
 179             appid.c_str(), device.c_str(), input);
 180     ico_input_mgr_control_del_input_app(m_inputmgr, appid.c_str(),
 181                                         device.c_str(), input);
 182     // flush display
 183     CicoSCWayland::getInstance()->flushDisplay();
 184 }
 185
 186 //--------------------------------------------------------------------------
 187 /**
 188  *  @brief  wrapper function ico_exinput_set_input_region
 189  *
 190  *  @param [in] target    target window name(winname@appid)
 191  *  @param [in] x         region x positon
 192  *  @param [in] y         region y positon
 193  *  @param [in] width     region width
 194  *  @param [in] height    region height
 195  *  @param [in] hotspot_x hotspot x position
 196  *  @param [in] hotspot_y hotspot y position
 197  *  @param [in] cursor_x  cursor x position
 198  *  @param [in] cursor_y  cursor y position
 199  *  @param [in] cursor_width  cursor width
 200  *  @param [in] cursor_height cursor height
 201  *  @param [in] attr      region attribute
 202  */
 203 //--------------------------------------------------------------------------
 204 void
 205 CicoSCWlInputMgrIF::setInputRegion(const string &target,
 206                                    int x,
 207                                    int y,
 208                                    int width,
 209                                    int height,
 210                                    int hotspot_x,
 211                                    int hotspot_y,
 212                                    int cursor_x,
 213                                    int cursor_y,
 214                                    int cursor_width,
 215                                    int cursor_height,
 216                                    int attr)
 217 {
 218     ICO_DBG("called: ico_exinput_set_input_region"
 219             "(target=%s x/y=%d/%d w/h=%d/%d hot=%d/%d "
 220             "cursor=%d/%d-%d/%d attr=%d)",
 221             target.c_str(), x, y, width, height, hotspot_x, hotspot_y,
 222             cursor_x, cursor_y, cursor_width, cursor_height, attr);
 223     ico_exinput_set_input_region(m_exinput, target.c_str(), x, y,
 224                                  width, height, hotspot_x, hotspot_y, cursor_x,
 225                                  cursor_y, cursor_width, cursor_height,attr);
 226     // flush display
 227     CicoSCWayland::getInstance()->flushDisplay();
 228 }
 229
 230 //--------------------------------------------------------------------------
 231 /**
 232  *  @brief  wrapper function ico_exinput_unset_input_region
 233  *
 234  *  @param [in] target    target window name(winname@appid)
 235  *  @param [in] x         region x positon
 236  *  @param [in] y         region y positon
 237  *  @param [in] width     region width
 238  *  @param [in] height    region height
 239  */
 240 //--------------------------------------------------------------------------
 241 void
 242 CicoSCWlInputMgrIF::unsetInputRegion(const string &target,
 243                                      int x,
 244                                      int y,
 245                                      int width,
 246                                      int height)
 247 {
 248     ICO_DBG("called: ico_exinput_unset_input_region"
 249             "(target=%s x=%d y=%d width=%d height=%d",
 250             target.c_str(), x, y, width, height);
 251     ico_exinput_unset_input_region(m_exinput, target.c_str(),
 252                                    x, y, width, height);
 253     // flush display
 254     CicoSCWayland::getInstance()->flushDisplay();
 255 }
 256
 257 //--------------------------------------------------------------------------
 258 /**
 259  *  @brief  callback to application for input switch information
 260  *
 261  *  @param [in] data        user data
 262  *  @param [in] ico_exinput wayland ico_exinput interface
 263  *  @param [in] device      input device name
 264  *  @param [in] type        input device type (as enum type)
 265  *  @param [in] swname      input switch name
 266  *  @param [in] input       input switch number
 267  *  @param [in] codename    input code name
 268  *  @param [in] code        input code number
 269  */
 270 //--------------------------------------------------------------------------
 271 void
 272 CicoSCWlInputMgrIF::capabilitiesCB(void               *data,
 273                                    struct ico_exinput *ico_exinput,
 274                                    const char         *device,
 275                                    int32_t            type,
 276                                    const char         *swname,
 277                                    int32_t            input,
 278                                    const char         *codename,
 279                                    int32_t            code)
 280 {
 281     ICO_WRN("CicoSCWlInputMgrIF::capabilitiesCB called.");
 282 }
 283
 284 //--------------------------------------------------------------------------
 285 /**
 286  *  @brief  callback to application for input code information
 287  *
 288  *  @param [in] data        user data
 289  *  @param [in] ico_exinput wayland ico_exinput interface
 290  *  @param [in] device      input device name
 291  *  @param [in] input       input switch number
 292  *  @param [in] codename    input code name
 293  *  @param [in] code        input code number
 294  */
 295 //--------------------------------------------------------------------------
 296 void
 297 CicoSCWlInputMgrIF::codeCB(void               *data,
 298                            struct ico_exinput *ico_exinput,
 299                            const char         *device,
 300                            int32_t            input,
 301                            const char         *codename,
 302                            int32_t            code)
 303 {
 304     ICO_WRN("CicoSCWlInputMgrIF::codeCB called.");
 305 }
 306
 307 //--------------------------------------------------------------------------
 308 /**
 309  *  @brief  callback to application for switch input
 310  *
 311  *  @param [in] data        user data
 312  *  @param [in] ico_exinput wayland ico_exinput interface
 313  *  @param [in] time        input time of millisecond
 314  *  @param [in] device      input device name
 315  *  @param [in] input       input switch number
 316  *  @param [in] code        input switch code
 317  *  @param [in] state       Of/Off status
 318  */
 319 //--------------------------------------------------------------------------
 320 void
 321 CicoSCWlInputMgrIF::inputCB(void               *data,
 322                             struct ico_exinput *ico_exinput,
 323                             uint32_t           time,
 324                             const char         *device,
 325                             int32_t            input,
 326                             int32_t            code,
 327                             int32_t            state)
 328 {
 329     ICO_WRN("CicoSCWlInputMgrIF::inputCB called.");
 330 }
 331
 332 //--------------------------------------------------------------------------
 333 /**
 334  *  @brief  callback to application for change input region
 335  *
 336  *  @param [in] data                user data
 337  *  @param [in] ico_input_mgr_dev   wayland ico_exinput interface
 338  *  @param [in] region              input regions
 339  */
 340 //--------------------------------------------------------------------------
 341 void
 342 CicoSCWlInputMgrIF::regionCB(void                        *data,
 343                              struct ico_input_mgr_device *ico_input_mgr_dev,
 344                              struct wl_array             *region)
 345 {
 346     ICO_WRN("CicoSCWlInputMgrIF::regionCB called.");
 347 }
 348
 349 //==========================================================================
 350 // private method
 351 //==========================================================================
 352
 353 //--------------------------------------------------------------------------
 354 /**
 355  *  @brief  callback to application for input switch information
 356  *
 357  *  @param [in] data        user data
 358  *  @param [in] ico_exinput wayland ico_exinput interface
 359  *  @param [in] device      input device name
 360  *  @param [in] type        input device type (as enum type)
 361  *  @param [in] swname      input switch name
 362  *  @param [in] input       input switch number
 363  *  @param [in] codename    input code name
 364  *  @param [in] code        input code number
 365  */
 366 //--------------------------------------------------------------------------
 367 void
 368 CicoSCWlInputMgrIF::wlCapabilitiesCB(void               *data,
 369                                      struct ico_exinput *ico_exinput,
 370                                      const char         *device,
 371                                      int32_t            type,
 372                                      const char         *swname,
 373                                      int32_t            input,
 374                                      const char         *codename,
 375                                      int32_t            code)
 376 {
 377 //    ICO_TRA("CicoSCWlInputMgrIF::wlCapabilitiesCB Enter");
 378
 379     if (NULL == data) {
 380         ICO_WRN("wlCapabilitiesCB: data is null");
 381         return;
 382     }
 383     static_cast<CicoSCWlInputMgrIF*>(data)->capabilitiesCB(data, ico_exinput,
 384                                                            device, type,
 385                                                            swname, input,
 386                                                            codename, code);
 387 //    ICO_TRA("CicoSCWlInputMgrIF::wlCapabilitiesCB Leave");
 388 }
 389
 390 //--------------------------------------------------------------------------
 391 /**
 392  *  @brief  callback to application for input code information
 393  *
 394  *  @param [in] data        user data
 395  *  @param [in] ico_exinput wayland ico_exinput interface
 396  *  @param [in] device      input device name
 397  *  @param [in] input       input switch number
 398  *  @param [in] codename    input code name
 399  *  @param [in] code        input code number
 400  */
 401 //--------------------------------------------------------------------------
 402 void
 403 CicoSCWlInputMgrIF::wlCodeCB(void               *data,
 404                              struct ico_exinput *ico_exinput,
 405                              const char         *device,
 406                              int32_t            input,
 407                              const char         *codename,
 408                              int32_t            code)
 409 {
 410 //    ICO_TRA("CicoSCWlInputMgrIF::wlCodeCB Enter");
 411
 412     if (NULL == data) {
 413         ICO_WRN("wlCodeCB: data is null");
 414         return;
 415     }
 416     static_cast<CicoSCWlInputMgrIF*>(data)->codeCB(data, ico_exinput,
 417                                                    device, input,
 418                                                    codename, code);
 419
 420 //    ICO_TRA("CicoSCWlInputMgrIF::wlCodeCB Leave");
 421 }
 422
 423 //--------------------------------------------------------------------------
 424 /**
 425  *  @brief  callback to application for switch input
 426  *
 427  *  @param [in] data        user data
 428  *  @param [in] ico_exinput wayland ico_exinput interface
 429  *  @param [in] time        input time of millisecond
 430  *  @param [in] device      input device name
 431  *  @param [in] input       input switch number
 432  *  @param [in] code        input switch code
 433  *  @param [in] state       Of/Off status
 434  */
 435 //--------------------------------------------------------------------------
 436 void
 437 CicoSCWlInputMgrIF::wlInputCB(void               *data,
 438                               struct ico_exinput *ico_exinput,
 439                               uint32_t           time,
 440                               const char         *device,
 441                               int32_t            input,
 442                               int32_t            code,
 443                               int32_t            state)
 444 {
 445 //    ICO_TRA("CicoSCWlInputMgrIF::wlInputCB Enter");
 446
 447     if (NULL == data) {
 448         ICO_WRN("wlInputCB: data is null");
 449         return;
 450     }
 451     static_cast<CicoSCWlInputMgrIF*>(data)->inputCB(data, ico_exinput,
 452                                                     time, device, input,
 453                                                     code, state);
 454
 455 //    ICO_TRA("CicoSCWlInputMgrIF::wlInputCB Leave");
 456 }
 457
 458 //--------------------------------------------------------------------------
 459 /**
 460  *  @brief  callback to application for change input region
 461  *
 462  *  @param [in] data                user data
 463  *  @param [in] ico_input_mgr_dev   wayland ico_exinput interface
 464  *  @param [in] region              input regions
 465  */
 466 //--------------------------------------------------------------------------
 467 void
 468 CicoSCWlInputMgrIF::wlRegionCB(void                        *data,
 469                                struct ico_input_mgr_device *ico_input_mgr_dev,
 470                                struct wl_array             *region)
 471 {
 472 //    ICO_TRA("CicoSCWlInputMgrIF::wlRegionCB Enter");
 473
 474     if (NULL == data) {
 475         ICO_WRN("wlRegionCB: data is null");
 476         return;
 477     }
 478     static_cast<CicoSCWlInputMgrIF*>(data)->regionCB(data, ico_input_mgr_dev,
 479                                                      region);
 480
 481 //    ICO_TRA("CicoSCWlInputMgrIF::wlRegionCB Leave");
 482 }
 483 // vim:set expandtab ts=4 sw=4: