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
  15  */
  16 //==========================================================================
  17
  18 #include <cstring>
  19 #include "CicoSCWlInputMgrIF.h"
  20 #include "CicoLog.h"
  21
  22 //==========================================================================
  23 //  static variables
  24 //==========================================================================
  25
  26 // ico_exinput listener
  27 struct ico_exinput_listener CicoSCWlInputMgrIF::ms_exInputListener = {
  28     .capabilities = CicoSCWlInputMgrIF::wlCapabilitiesCB,
  29     .code         = CicoSCWlInputMgrIF::wlCodeCB,
  30     .input        = CicoSCWlInputMgrIF::wlInputCB
  31 };
  32
  33 // ico_input_mgr_device listener
  34 struct ico_input_mgr_device_listener CicoSCWlInputMgrIF::ms_devListener = {
  35     .input_region = CicoSCWlInputMgrIF::wlRegionCB
  36 };
  37
  38 //--------------------------------------------------------------------------
  39 /**
  40  *  @brief  default constructor
  41  */
  42 //--------------------------------------------------------------------------
  43 CicoSCWlInputMgrIF::CicoSCWlInputMgrIF()
  44     : m_inputmgr(NULL), m_exinput(NULL), m_inputmgrdev(NULL)
  45 {
  46 }
  47
  48 //--------------------------------------------------------------------------
  49 /**
  50  *  @brief  destructor
  51  */
  52 //--------------------------------------------------------------------------
  53 CicoSCWlInputMgrIF::~CicoSCWlInputMgrIF()
  54 {
  55 }
  56
  57 //--------------------------------------------------------------------------
  58 /**
  59  *  @brief  initialize ico_input_mgr interfaces
  60  *
  61  *  @param [IN] data        user data
  62  *  @param [IN] registry    wayland registry
  63  *  @param [IN] name        wayland display id
  64  *  @parma [IN] interface   wayland interface name
  65  *  @parma [IN] version     wayland interface version number
  66  */
  67 //--------------------------------------------------------------------------
  68 void
  69 CicoSCWlInputMgrIF::initInterface(void               *data,
  70                                   struct wl_registry *registry,
  71                                   uint32_t           name,
  72                                   const char         *interface,
  73                                   uint32_t           version)
  74 {
  75     ICO_DBG("CicoSCWlInputMgrIF::initInterface : Enter(interface=%s)",
  76             interface);
  77
  78     if (0 == strcmp(interface, ICO_WL_INPUT_MGR_CTRL_IF)) {
  79         // get interface instance
  80         void *wlProxy = wl_registry_bind(registry,
  81                                          name,
  82                                          &ico_input_mgr_control_interface,
  83                                          1);
  84         if (NULL == wlProxy) {
  85             ICO_WRN("initInterface : interface(%s) wl_registry_bind failed.",
  86                     interface);
  87             ICO_WRN("initInterface : Leave(binding failed");
  88             return;
  89         }
  90
  91         m_inputmgr = (struct ico_input_mgr_control*)wlProxy;
  92     }
  93     else if (0 == strcmp(interface, ICO_WL_EXINPUT_IF)) {
  94         // get interface instance
  95         void *wlProxy = wl_registry_bind(registry,
  96                                          name,
  97                                          &ico_exinput_interface,
  98                                          1);
  99         if (NULL == wlProxy) {
 100             ICO_WRN("initInterface : interface(%s) wl_registry_bind failed.",
 101                     interface);
 102             ICO_WRN("initInterface : Leave(binding failed");
 103             return;
 104         }
 105
 106         m_exinput = (struct ico_exinput*)wlProxy;
 107         ico_exinput_add_listener(m_exinput,
 108                                  &ms_exInputListener,
 109                                  this);
 110 #if 0
 111         ico_exinput_set_user_data(m_exinput, NULL/*user data*/);
 112 #endif
 113     }
 114     else if (0 == strcmp(interface, ICO_WL_INPUT_MGR_DEV_IF)) {
 115         // get interface instance
 116         void *wlProxy = wl_registry_bind(registry,
 117                                          name,
 118                                          &ico_input_mgr_device_interface,
 119                                          1);
 120         if (NULL == wlProxy) {
 121             ICO_WRN("initInterface : interface(%s) wl_registry_bind failed.",
 122                     interface);
 123             ICO_WRN("initInterface : Leave(binding failed");
 124             return;
 125         }
 126
 127         m_inputmgrdev = (struct ico_input_mgr_device*)wlProxy;
 128         ico_input_mgr_device_add_listener(m_inputmgrdev,
 129                                           &ms_devListener,
 130                                           this);
 131 #if 0
 132         ico_input_mgr_device_set_user_data(m_inputmgrdev, NULL/*user data*/);
 133 #endif
 134     }
 135
 136     if ((NULL != m_inputmgrdev) &&
 137         (NULL != m_inputmgr) &&
 138         (NULL != m_exinput)) {
 139         m_initialized = true;
 140     }
 141     ICO_DBG("CicoSCWlInputMgrIF::initInterface : Leave");
 142 }
 143
 144 //--------------------------------------------------------------------------
 145 /**
 146  *  @brief  callback to application for input switch information
 147  *
 148  *  @param [IN] data        user data
 149  *  @param [IN] ico_exinput wayland ico_exinput interface
 150  *  @param [IN] device      input device name
 151  *  @param [IN] type        input device type (as enum type)
 152  *  @param [IN] swname      input switch name
 153  *  @param [IN] input       input switch number
 154  *  @param [IN] codename    input code name
 155  *  @param [IN] code        input code number
 156  */
 157 //--------------------------------------------------------------------------
 158 void
 159 CicoSCWlInputMgrIF::capabilitiesCB(void               *data,
 160                                    struct ico_exinput *ico_exinput,
 161                                    const char         *device,
 162                                    int32_t            type,
 163                                    const char         *swname,
 164                                    int32_t            input,
 165                                    const char         *codename,
 166                                    int32_t            code)
 167 {
 168     ICO_WRN("CicoSCWlInputMgrIF::capabilitiesCB called.");
 169 }
 170
 171 //--------------------------------------------------------------------------
 172 /**
 173  *  @brief  callback to application for input code information
 174  *
 175  *  @param [IN] data        user data
 176  *  @param [IN] ico_exinput wayland ico_exinput interface
 177  *  @param [IN] device      input device name
 178  *  @param [IN] input       input switch number
 179  *  @param [IN] codename    input code name
 180  *  @param [IN] code        input code number
 181  */
 182 //--------------------------------------------------------------------------
 183 void
 184 CicoSCWlInputMgrIF::codeCB(void               *data,
 185                            struct ico_exinput *ico_exinput,
 186                            const char         *device,
 187                            int32_t            input,
 188                            const char         *codename,
 189                            int32_t            code)
 190 {
 191     ICO_WRN("CicoSCWlInputMgrIF::codeCB called.");
 192 }
 193
 194 //--------------------------------------------------------------------------
 195 /**
 196  *  @brief  callback to application for switch input
 197  *
 198  *  @param [IN] data        user data
 199  *  @param [IN] ico_exinput wayland ico_exinput interface
 200  *  @param [IN] time        input time of miri-sec
 201  *  @param [IN] device      input device name
 202  *  @param [IN] input       input switch number
 203  *  @param [IN] code        input switch code
 204  *  @param [IN] state       Of/Off status
 205  */
 206 //--------------------------------------------------------------------------
 207 void
 208 CicoSCWlInputMgrIF::inputCB(void               *data,
 209                             struct ico_exinput *ico_exinput,
 210                             uint32_t           time,
 211                             const char         *device,
 212                             int32_t            input,
 213                             int32_t            code,
 214                             int32_t            state)
 215 {
 216     ICO_WRN("CicoSCWlInputMgrIF::inputCB called.");
 217 }
 218
 219 //--------------------------------------------------------------------------
 220 /**
 221  *  @brief  callback to application for change input region
 222  *
 223  *  @param [IN] data                user data
 224  *  @param [IN] ico_input_mgr_dev   wayland ico_exinput interface
 225  *  @param [IN] region              input regions
 226  */
 227 //--------------------------------------------------------------------------
 228 void
 229 CicoSCWlInputMgrIF::regionCB(void                        *data,
 230                              struct ico_input_mgr_device *ico_input_mgr_dev,
 231                              struct wl_array             *region)
 232 {
 233     ICO_WRN("CicoSCWlInputMgrIF::regionCB called.");
 234 }
 235
 236 //==========================================================================
 237 // private method
 238 //==========================================================================
 239
 240 //--------------------------------------------------------------------------
 241 /**
 242  *  @brief  callback to application for input switch information
 243  *
 244  *  @param [IN] data        user data
 245  *  @param [IN] ico_exinput wayland ico_exinput interface
 246  *  @param [IN] device      input device name
 247  *  @param [IN] type        input device type (as enum type)
 248  *  @param [IN] swname      input switch name
 249  *  @param [IN] input       input switch number
 250  *  @param [IN] codename    input code name
 251  *  @param [IN] code        input code number
 252  */
 253 //--------------------------------------------------------------------------
 254 void
 255 CicoSCWlInputMgrIF::wlCapabilitiesCB(void               *data,
 256                                      struct ico_exinput *ico_exinput,
 257                                      const char         *device,
 258                                      int32_t            type,
 259                                      const char         *swname,
 260                                      int32_t            input,
 261                                      const char         *codename,
 262                                      int32_t            code)
 263 {
 264     ICO_DBG("CicoSCWlInputMgrIF::wlCapabilitiesCB Enter");
 265
 266     if (NULL == data) {
 267         ICO_WRN("wlCapabilitiesCB: data is null");
 268         return;
 269     }
 270     static_cast<CicoSCWlInputMgrIF*>(data)->capabilitiesCB(data, ico_exinput,
 271                                                            device, type,
 272                                                            swname, input,
 273                                                            codename, code);
 274     ICO_DBG("CicoSCWlInputMgrIF::wlCapabilitiesCB Leave");
 275 }
 276
 277 //--------------------------------------------------------------------------
 278 /**
 279  *  @brief  callback to application for input code information
 280  *
 281  *  @param [IN] data        user data
 282  *  @param [IN] ico_exinput wayland ico_exinput interface
 283  *  @param [IN] device      input device name
 284  *  @param [IN] input       input switch number
 285  *  @param [IN] codename    input code name
 286  *  @param [IN] code        input code number
 287  */
 288 //--------------------------------------------------------------------------
 289 void
 290 CicoSCWlInputMgrIF::wlCodeCB(void               *data,
 291                              struct ico_exinput *ico_exinput,
 292                              const char         *device,
 293                              int32_t            input,
 294                              const char         *codename,
 295                              int32_t            code)
 296 {
 297     ICO_DBG("CicoSCWlInputMgrIF::wlCodeCB Enter");
 298
 299     if (NULL == data) {
 300         ICO_WRN("wlCodeCB: data is null");
 301         return;
 302     }
 303     static_cast<CicoSCWlInputMgrIF*>(data)->codeCB(data, ico_exinput,
 304                                                    device, input,
 305                                                    codename, code);
 306
 307     ICO_DBG("CicoSCWlInputMgrIF::wlCodeCB Leave");
 308 }
 309
 310 //--------------------------------------------------------------------------
 311 /**
 312  *  @brief  callback to application for switch input
 313  *
 314  *  @param [IN] data        user data
 315  *  @param [IN] ico_exinput wayland ico_exinput interface
 316  *  @param [IN] time        input time of miri-sec
 317  *  @param [IN] device      input device name
 318  *  @param [IN] input       input switch number
 319  *  @param [IN] code        input switch code
 320  *  @param [IN] state       Of/Off status
 321  */
 322 //--------------------------------------------------------------------------
 323 void
 324 CicoSCWlInputMgrIF::wlInputCB(void               *data,
 325                               struct ico_exinput *ico_exinput,
 326                               uint32_t           time,
 327                               const char         *device,
 328                               int32_t            input,
 329                               int32_t            code,
 330                               int32_t            state)
 331 {
 332     ICO_DBG("CicoSCWlInputMgrIF::wlInputCB Enter");
 333
 334     if (NULL == data) {
 335         ICO_WRN("wlInputCB: data is null");
 336         return;
 337     }
 338     static_cast<CicoSCWlInputMgrIF*>(data)->inputCB(data, ico_exinput,
 339                                                     time, device, input,
 340                                                     code, state);
 341
 342     ICO_DBG("CicoSCWlInputMgrIF::wlInputCB Leave");
 343 }
 344
 345 //--------------------------------------------------------------------------
 346 /**
 347  *  @brief  callback to application for change input region
 348  *
 349  *  @param [IN] data                user data
 350  *  @param [IN] ico_input_mgr_dev   wayland ico_exinput interface
 351  *  @param [IN] region              input regions
 352  */
 353 //--------------------------------------------------------------------------
 354 void
 355 CicoSCWlInputMgrIF::wlRegionCB(void                        *data,
 356                                struct ico_input_mgr_device *ico_input_mgr_dev,
 357                                struct wl_array             *region)
 358 {
 359     ICO_DBG("CicoSCWlInputMgrIF::wlRegionCB Enter");
 360
 361     if (NULL == data) {
 362         ICO_WRN("wlRegionCB: data is null");
 363         return;
 364     }
 365     static_cast<CicoSCWlInputMgrIF*>(data)->regionCB(data, ico_input_mgr_dev,
 366                                                      region);
 367
 368     ICO_DBG("CicoSCWlInputMgrIF::wlRegionCB Leave");
 369 }
 370 // vim:set expandtab ts=4 sw=4: