video_in_hal/vehicleservice/positioning/server/src/ServiceInterface/DevDetectSrvIf.cpp

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (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://www.apache.org/licenses/LICENSE-2.0
   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 /**
  18  * @file
  19  *    DevDetectSrvIf.cpp
  20  * @brief
  21  *    DevDetectSrv service-to-service interface
  22  */
  23
  24 /*---------------------------------------------------------------------------------*
  25  * Include Files                                                                   *
  26  *---------------------------------------------------------------------------------*/
  27 #include <vehicle_service/positioning_base_library.h>
  28 #include "DevDetectSrvIf.h"
  29
  30 /*---------------------------------------------------------------------------------*
  31  * Definition                                                                      *
  32  *---------------------------------------------------------------------------------*/
  33
  34 /*---------------------------------------------------------------------------------*
  35  * Structre                                                                        *
  36  *---------------------------------------------------------------------------------*/
  37
  38 /*---------------------------------------------------------------------------------*
  39  * Local Function Prototype                                                        *
  40  *---------------------------------------------------------------------------------*/
  41
  42 /*---------------------------------------------------------------------------------*
  43  * Grobal Value                                                                    *
  44  *---------------------------------------------------------------------------------*/
  45 static BOOL g_dev_detect_srv_availability = FALSE;
  46
  47 /** Device insertion detection */
  48 DeviceDetectionServiceIf    g_if_ss_dev;
  49
  50
  51 /*---------------------------------------------------------------------------------*
  52  * Function                                                                        *
  53  *---------------------------------------------------------------------------------*/
  54 /**
  55  * @brief
  56  *    DevDetectSrv Services IF-Availability Settings
  57  *
  58  * @param[in]  b_is_available    Available state
  59  * @return     none
  60  */
  61 void DevDetectSrvIfSetAvailability(BOOL b_is_available) {
  62     g_dev_detect_srv_availability = b_is_available;
  63
  64     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, \
  65         "g_dev_detect_srv_availability=%d", g_dev_detect_srv_availability);
  66
  67     return;
  68 }
  69
  70 /**
  71  * @brief
  72  *    DevDetectSrv Services IF-Initialization
  73  *
  74  * @return     eFrameworkunifiedStatusOK
  75  * @return     eFrameworkunifiedStatusFail
  76  */
  77 EFrameworkunifiedStatus DevDetectSrvIfInitialize(void) {
  78     EFrameworkunifiedStatus estatus = eFrameworkunifiedStatusFail;
  79     BOOL bret;
  80     HANDLE happ;
  81
  82     happ = _pb_GetAppHandle();
  83     if (happ != NULL) {
  84         bret = g_if_ss_dev.Initialize(happ);
  85         if (bret == TRUE) {
  86             estatus = eFrameworkunifiedStatusOK;
  87         } else {
  88             FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, \
  89                 "g_if_ss_dev::Initialize ERROR!! [estatus=%d]", estatus);
  90         }
  91     } else {
  92         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_GetAppHandle ERROR!! [happ=%p]", happ);
  93     }
  94
  95     return estatus;
  96 }
  97
  98 /**
  99  * @brief
 100  *    DevDetectSrv Services IF Availability Change Notification Registration
 101  *
 102  * @param[in]  fp_call_back_fn    Callback function
 103  * @return     eFrameworkunifiedStatusOK
 104  * @return     eFrameworkunifiedStatusFail
 105  */
 106 EFrameworkunifiedStatus DevDetectSrvIfNotifyOnDeviceDetectionAvailability(CbFuncPtr fp_call_back_fn) {
 107     EFrameworkunifiedStatus estatus = eFrameworkunifiedStatusFail;
 108
 109     estatus = g_if_ss_dev.NotifyOnDeviceDetectionAvailability(fp_call_back_fn);
 110     if (eFrameworkunifiedStatusOK != estatus) {
 111         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
 112             "DeviceDetectionServiceIf Availability ERROR!! [estatus = %d]", estatus);
 113     }
 114
 115     return estatus;
 116 }
 117
 118 /**
 119  * @brief
 120  *    DevDetectSrv Services IF OpenSessionRequest Complete Answer Receive Callback Registration
 121  *
 122  * @param[in]  fp_call_back_fn    Callback function
 123  * @param[out] pb_is_available    Available state
 124  * @return     eFrameworkunifiedStatusOK
 125  * @return     eFrameworkunifiedStatusFail
 126  */
 127 EFrameworkunifiedStatus DevDetectSrvIfNotifyOnOpenSessionAck(CbFuncPtr fp_call_back_fn, BOOL* pb_is_available) {
 128     EFrameworkunifiedStatus estatus = eFrameworkunifiedStatusFail;
 129
 130     if (g_dev_detect_srv_availability == TRUE) {
 131         estatus = g_if_ss_dev.NotifyOnOpenSessionAck(fp_call_back_fn);
 132     } else {
 133         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "g_dev_detect_srv_availability=FALSE");
 134     }
 135
 136     *pb_is_available = g_dev_detect_srv_availability;
 137
 138     return estatus;
 139 }
 140
 141 /**
 142  * @brief
 143  *    DevDetectSrv Services IF CloseSessionRequest Complete Answer Receive Callback Registration
 144  *
 145  * @param[in]  fp_call_back_fn    Callback function
 146  * @param[out] pb_is_available    Available state
 147  * @return     eFrameworkunifiedStatusOK
 148  * @return     eFrameworkunifiedStatusFail
 149  */
 150 EFrameworkunifiedStatus DevDetectSrvIfNotifyOnCloseSessionAck(CbFuncPtr fp_call_back_fn, BOOL* pb_is_available) {
 151     EFrameworkunifiedStatus estatus = eFrameworkunifiedStatusFail;
 152
 153     if (g_dev_detect_srv_availability == TRUE) {
 154         estatus = g_if_ss_dev.NotifyOnCloseSessionAck(fp_call_back_fn);
 155     } else {
 156         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "g_dev_detect_srv_availability=FALSE");
 157     }
 158
 159     *pb_is_available = g_dev_detect_srv_availability;
 160
 161     return estatus;
 162 }
 163
 164 /**
 165  * @brief
 166  *    DevDetectSrv Service IF Service and Session Generation
 167  *
 168  * @param[out] pb_is_available    Available state
 169  * @return     eFrameworkunifiedStatusOK
 170  * @return     eFrameworkunifiedStatusFail
 171  */
 172 EFrameworkunifiedStatus DevDetectSrvIfOpenSessionRequest(BOOL* pb_is_available) {
 173     EFrameworkunifiedStatus estatus = eFrameworkunifiedStatusFail;
 174
 175     if (g_dev_detect_srv_availability == TRUE) {
 176         estatus = g_if_ss_dev.OpenSessionRequest();
 177     } else {
 178         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "g_dev_detect_srv_availability=FALSE");
 179     }
 180
 181     *pb_is_available = g_dev_detect_srv_availability;
 182
 183     return estatus;
 184 }
 185
 186 /**
 187  * @brief
 188  *    DevDetectSrv Services IF-Session Id Retention
 189  *
 190  * @param[out] pb_is_available    Available state
 191  * @return     eFrameworkunifiedStatusOK
 192  * @return     eFrameworkunifiedStatusFail
 193  */
 194 EFrameworkunifiedStatus DevDetectSrvIfDecodeOpenSessionResponse(BOOL* pb_is_available) {
 195     EFrameworkunifiedStatus estatus = eFrameworkunifiedStatusFail;
 196
 197     if (g_dev_detect_srv_availability == TRUE) {
 198         estatus = g_if_ss_dev.DecodeOpenSessionResponse();
 199     } else {
 200         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "g_dev_detect_srv_availability=FALSE");
 201     }
 202
 203     *pb_is_available = g_dev_detect_srv_availability;
 204
 205     return estatus;
 206 }
 207
 208 /**
 209  * @brief
 210  *    DevDetectSrv Services IF-Device Event Receive Callback Registration
 211  *
 212  * @param[in]  fe_dev_detect_event
 213  * @param[in]  fp_call_back_fn
 214  * @param[in]  p_file_path
 215  * @param[out] pb_is_available    Available state
 216  * @return     eFrameworkunifiedStatusOK
 217  * @return     eFrameworkunifiedStatusFail
 218  */
 219 EFrameworkunifiedStatus DevDetectSrvIfRegisterForDeviceDetectionEvent(SS_DeviceDetectionServerEvents fe_dev_detect_event, \
 220         CbFuncPtr fp_call_back_fn, PCSTR p_file_path, BOOL* pb_is_available) {
 221     EFrameworkunifiedStatus estatus = eFrameworkunifiedStatusFail;
 222
 223     if (g_dev_detect_srv_availability == TRUE) {
 224         estatus = g_if_ss_dev.RegisterForDeviceDetectionEvent(fe_dev_detect_event, fp_call_back_fn, p_file_path);
 225     } else {
 226         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "g_dev_detect_srv_availability=FALSE");
 227     }
 228
 229     *pb_is_available = g_dev_detect_srv_availability;
 230
 231     return estatus;
 232 }
 233
 234 /**
 235  * @brief
 236  *    DevDetectSrv Services IF DeviceDetectionServiceIf Callback Release
 237  *
 238  * @param[in]  fe_dev_detect_event
 239  * @param[out] pb_is_available    Available state
 240  * @return     eFrameworkunifiedStatusOK
 241  * @return     eFrameworkunifiedStatusFail
 242  */
 243 EFrameworkunifiedStatus DevDetectSrvIfUnRegisterForDeviceDetectionEvent(SS_DeviceDetectionServerEvents fe_dev_detect_event, \
 244         BOOL* pb_is_available) {
 245     EFrameworkunifiedStatus estatus = eFrameworkunifiedStatusFail;
 246
 247     if (g_dev_detect_srv_availability == TRUE) {
 248         estatus = g_if_ss_dev.UnRegisterForDeviceDetectionEvent(fe_dev_detect_event);
 249     } else {
 250         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "g_dev_detect_srv_availability=FALSE");
 251     }
 252
 253     *pb_is_available = g_dev_detect_srv_availability;
 254
 255     return estatus;
 256 }
 257
 258 /**
 259  * @brief
 260  *    DevDetectSrv Service IF Service and Destroy Sessions
 261  *
 262  * @param[out] pb_is_available    Available state
 263  * @return     eFrameworkunifiedStatusOK
 264  * @return     eFrameworkunifiedStatusFail
 265  */
 266 EFrameworkunifiedStatus DevDetectSrvIfCloseSessionRequest(BOOL* pb_is_available) {
 267     EFrameworkunifiedStatus estatus = eFrameworkunifiedStatusFail;
 268
 269     if (g_dev_detect_srv_availability == TRUE) {
 270         estatus = g_if_ss_dev.CloseSessionRequest();
 271     } else {
 272         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "g_dev_detect_srv_availability=FALSE");
 273     }
 274
 275     *pb_is_available = g_dev_detect_srv_availability;
 276
 277     return estatus;
 278 }
 279