1  /*
2   * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3   * Licensed under the Apache License, Version 2.0 (the "License");
4   * you may not use this file except in compliance with the License.
5   * You may obtain a copy of the License at
6   *
7   *     http://www.apache.org/licenses/LICENSE-2.0
8   *
9   * Unless required by applicable law or agreed to in writing, software
10   * distributed under the License is distributed on an "AS IS" BASIS,
11   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12   * See the License for the specific language governing permissions and
13   * limitations under the License.
14   */
15  
16  #include "nfc_impl.h"
17  #include <hdf_base.h>
18  #include <hdf_log.h>
19  #include <iproxy_broker.h>
20  #include <vector>
21  #include "nfc_vendor_adaptions.h"
22  
23  #define HDF_LOG_TAG hdf_nfc_dal
24  
25  #ifdef LOG_DOMAIN
26  #undef LOG_DOMAIN
27  #endif
28  
29  #define LOG_DOMAIN 0xD000306
30  
31  namespace OHOS {
32  namespace HDI {
33  namespace Nfc {
34  namespace V1_1 {
35  static sptr<INfcCallback> g_callbackV1_1 = nullptr;
36  
EventCallback(unsigned char event,unsigned char status)37  static void EventCallback(unsigned char event, unsigned char status)
38  {
39      if (g_callbackV1_1 != nullptr) {
40          g_callbackV1_1->OnEvent((NfcEvent)event, (NfcStatus)status);
41      }
42  }
43  
DataCallback(uint16_t len,uint8_t * data)44  static void DataCallback(uint16_t len, uint8_t *data)
45  {
46      if (g_callbackV1_1 != nullptr) {
47          std::vector<uint8_t> vec(data, data + len / sizeof(uint8_t));
48          g_callbackV1_1->OnData(vec);
49      }
50  }
51  
NfcInterfaceImplGetInstance(void)52  extern "C" INfcInterface *NfcInterfaceImplGetInstance(void)
53  {
54      using OHOS::HDI::Nfc::V1_1::NfcImpl;
55      NfcImpl *service = new (std::nothrow) NfcImpl();
56      if (service == nullptr) {
57          return nullptr;
58      }
59      return service;
60  }
61  
NfcImpl()62  NfcImpl::NfcImpl()
63  {
64      remoteDeathRecipient_ =
65          new RemoteDeathRecipient(std::bind(&NfcImpl::OnRemoteDied, this, std::placeholders::_1));
66  }
67  
~NfcImpl()68  NfcImpl::~NfcImpl()
69  {
70      if (callbacks_ != nullptr) {
71          RemoveNfcDeathRecipient(callbacks_);
72          callbacks_ = nullptr;
73      }
74  }
75  
Open(const sptr<INfcCallback> & callbackObj,NfcStatus & status)76  int32_t NfcImpl::Open(const sptr<INfcCallback> &callbackObj, NfcStatus &status)
77  {
78      if (callbackObj == nullptr) {
79          HDF_LOGE("Open, callback is nullptr!");
80          return HDF_ERR_INVALID_PARAM;
81      }
82      g_callbackV1_1 = callbackObj;
83  
84      int ret = adaptor_.VendorOpen(EventCallback, DataCallback);
85      if (ret == 0) {
86          callbacks_ = callbackObj;
87          AddNfcDeathRecipient(callbacks_);
88          status = NfcStatus::OK;
89          return HDF_SUCCESS;
90      }
91      status = NfcStatus::FAILED;
92      return HDF_FAILURE;
93  }
94  
CoreInitialized(const std::vector<uint8_t> & data,NfcStatus & status)95  int32_t NfcImpl::CoreInitialized(const std::vector<uint8_t> &data, NfcStatus &status)
96  {
97      if (data.empty()) {
98          HDF_LOGE("CoreInitialized, data is nullptr!");
99          return HDF_ERR_INVALID_PARAM;
100      }
101      int ret = adaptor_.VendorCoreInitialized(data.size(), (uint8_t *)&data[0]);
102      if (ret == 0) {
103          status = NfcStatus::OK;
104          return HDF_SUCCESS;
105      }
106      status = NfcStatus::FAILED;
107      return HDF_FAILURE;
108  }
109  
Prediscover(NfcStatus & status)110  int32_t NfcImpl::Prediscover(NfcStatus &status)
111  {
112      int ret = adaptor_.VendorPrediscover();
113      if (ret == 0) {
114          status = NfcStatus::OK;
115          return HDF_SUCCESS;
116      }
117      status = NfcStatus::FAILED;
118      return HDF_FAILURE;
119  }
120  
Write(const std::vector<uint8_t> & data,NfcStatus & status)121  int32_t NfcImpl::Write(const std::vector<uint8_t> &data, NfcStatus &status)
122  {
123      if (data.empty()) {
124          HDF_LOGE("Write, data is nullptr!");
125          return HDF_ERR_INVALID_PARAM;
126      }
127      int ret = adaptor_.VendorWrite(data.size(), (uint8_t *)&data[0]);
128      if (ret == 0) {
129          status = NfcStatus::OK;
130          return HDF_SUCCESS;
131      }
132      status = NfcStatus::FAILED;
133      return HDF_FAILURE;
134  }
135  
ControlGranted(NfcStatus & status)136  int32_t NfcImpl::ControlGranted(NfcStatus &status)
137  {
138      int ret = adaptor_.VendorControlGranted();
139      if (ret == 0) {
140          status = NfcStatus::OK;
141          return HDF_SUCCESS;
142      }
143      status = NfcStatus::FAILED;
144      return HDF_FAILURE;
145  }
146  
PowerCycle(NfcStatus & status)147  int32_t NfcImpl::PowerCycle(NfcStatus &status)
148  {
149      int ret = adaptor_.VendorPowerCycle();
150      if (ret == 0) {
151          status = NfcStatus::OK;
152          return HDF_SUCCESS;
153      }
154      status = NfcStatus::FAILED;
155      return HDF_FAILURE;
156  }
157  
Close(NfcStatus & status)158  int32_t NfcImpl::Close(NfcStatus &status)
159  {
160      int ret = adaptor_.VendorClose(false);
161      g_callbackV1_1 = nullptr;
162      if (callbacks_ != nullptr) {
163          RemoveNfcDeathRecipient(callbacks_);
164          callbacks_ = nullptr;
165      }
166      if (ret == 0) {
167          status = NfcStatus::OK;
168          return HDF_SUCCESS;
169      }
170      status = NfcStatus::FAILED;
171      return HDF_FAILURE;
172  }
173  
Ioctl(NfcCommand cmd,const std::vector<uint8_t> & data,NfcStatus & status)174  int32_t NfcImpl::Ioctl(NfcCommand cmd, const std::vector<uint8_t> &data, NfcStatus &status)
175  {
176      if (data.empty()) {
177          HDF_LOGE("Ioctl, data is nullptr!");
178          return HDF_ERR_INVALID_PARAM;
179      }
180      int ret = adaptor_.VendorIoctl(data.size(), (uint8_t *)&data[0]);
181      if (ret == 0) {
182          status = NfcStatus::OK;
183          return HDF_SUCCESS;
184      }
185      status = NfcStatus::FAILED;
186      return HDF_FAILURE;
187  }
188  
IoctlWithResponse(NfcCommand cmd,const std::vector<uint8_t> & data,std::vector<uint8_t> & response,NfcStatus & status)189  int32_t NfcImpl::IoctlWithResponse(NfcCommand cmd, const std::vector<uint8_t> &data,
190      std::vector<uint8_t> &response, NfcStatus &status)
191  {
192      if (data.empty()) {
193          HDF_LOGE("NfcImpl::IoctlWithResponse, data is nullptr!");
194          return HDF_ERR_INVALID_PARAM;
195      }
196      int ret = adaptor_.VendorIoctlWithResponse(cmd, (void*)&data[0], data.size(), response);
197      if (ret == 0) {
198          status = NfcStatus::OK;
199          return HDF_SUCCESS;
200      }
201      status = NfcStatus::FAILED;
202      return HDF_FAILURE;
203  }
204  
GetVendorConfig(NfcVendorConfig & config,NfcStatus & status)205  int32_t NfcImpl::GetVendorConfig(NfcVendorConfig &config, NfcStatus &status)
206  {
207      if (adaptor_.VendorGetConfig(config) != HDF_SUCCESS) {
208          HDF_LOGE("GetConfig, fail to get vendor config!");
209          status = NfcStatus::FAILED;
210          return HDF_FAILURE;
211      }
212      status = NfcStatus::OK;
213      return HDF_SUCCESS;
214  }
215  
DoFactoryReset(NfcStatus & status)216  int32_t NfcImpl::DoFactoryReset(NfcStatus &status)
217  {
218      int ret = adaptor_.VendorFactoryReset();
219      if (ret == 0) {
220          status = NfcStatus::OK;
221          return HDF_SUCCESS;
222      }
223      status = NfcStatus::FAILED;
224      return HDF_FAILURE;
225  }
226  
Shutdown(NfcStatus & status)227  int32_t NfcImpl::Shutdown(NfcStatus &status)
228  {
229      int ret = adaptor_.VendorShutdownCase();
230      if (ret == 0) {
231          status = NfcStatus::OK;
232          return HDF_SUCCESS;
233      }
234      status = NfcStatus::FAILED;
235      return HDF_FAILURE;
236  }
237  
OnRemoteDied(const wptr<IRemoteObject> & object)238  void NfcImpl::OnRemoteDied(const wptr<IRemoteObject> &object)
239  {
240      callbacks_ = nullptr;
241      NfcStatus status = NfcStatus::FAILED;
242      int32_t ret = Close(status);
243      if (ret != HDF_SUCCESS) {
244          HDF_LOGE("OnRemoteDied, Close failed, status(%{public}d)!", status);
245      }
246  }
247  
AddNfcDeathRecipient(const sptr<INfcCallback> & callbackObj)248  int32_t NfcImpl::AddNfcDeathRecipient(const sptr<INfcCallback> &callbackObj)
249  {
250      if (callbackObj == nullptr) {
251          HDF_LOGE("AddNfcDeathRecipient callbackobj nullptr");
252          return HDF_FAILURE;
253      }
254      const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<INfcCallback>(callbackObj);
255      if (remote == nullptr) {
256          HDF_LOGE("AddNfcDeathRecipient remote nullptr");
257          return HDF_FAILURE;
258      }
259      bool result = remote->AddDeathRecipient(remoteDeathRecipient_);
260      if (!result) {
261          HDF_LOGE("NfcImpl AddDeathRecipient failed!");
262          return HDF_FAILURE;
263      }
264      return HDF_SUCCESS;
265  }
266  
RemoveNfcDeathRecipient(const sptr<INfcCallback> & callbackObj)267  int32_t NfcImpl::RemoveNfcDeathRecipient(const sptr<INfcCallback> &callbackObj)
268  {
269      if (callbackObj == nullptr) {
270          HDF_LOGE("RemoveNfcDeathRecipient callbackobj nullptr");
271          return HDF_FAILURE;
272      }
273      const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<INfcCallback>(callbackObj);
274      if (remote == nullptr) {
275          HDF_LOGE("RemoveNfcDeathRecipient remote nullptr");
276          return HDF_FAILURE;
277      }
278      bool result = remote->RemoveDeathRecipient(remoteDeathRecipient_);
279      if (!result) {
280          HDF_LOGE("NfcImpl RemoveDeathRecipient failed!");
281          return HDF_FAILURE;
282      }
283      return HDF_SUCCESS;
284  }
285  } // V1_1
286  } // Nfc
287  } // HDI
288  } // OHOS
289