1 /*
2  * Copyright (C) 2022 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 "nfcc_nci_adapter.h"
17 
18 #include <unistd.h>
19 
20 #include "loghelper.h"
21 #include "nfc_config.h"
22 #include "nfc_sdk_common.h"
23 #include "routing_manager.h"
24 #include "securec.h"
25 #include "tag_nci_adapter_ntf.h"
26 #include "tag_nci_adapter_common.h"
27 
28 using namespace OHOS::NFC;
29 namespace OHOS {
30 namespace NFC {
31 namespace NCI {
32 // values for SAK28 issue
33 static unsigned int g_isoMifareBitMap = 0;
34 static bool g_isIsoMifareFlag = false;
35 static uint8_t isoMifareUid[NCI_NFCID1_MAX_LEN] = { 0 };
36 const uint8_t NCI_RF_DISCOVER_NTF_FIRST_ID = 0x01;
37 const uint8_t NCI_RF_DISCOVER_NTF_SECOND_ID = 0x02;
38 const unsigned int FLAG_MULTI_TAG_ISO_DEP = 0x01;
39 const unsigned int FLAG_MULTI_TAG_MIFARE = 0x02;
40 // wait nci event 2000 ms
41 const unsigned int NCI_EVT_WAIT_TIMEOUT = 2000;
42 
43 NfccNciAdapter::NfccNciAdapter() = default;
44 NfccNciAdapter::~NfccNciAdapter() = default;
45 
GetInstance()46 NfccNciAdapter& NfccNciAdapter::GetInstance()
47 {
48     static NfccNciAdapter nfccNciAdapter;
49     return nfccNciAdapter;
50 }
51 
52 /**
53  * @brief whether nfc is enabled or disabled.
54  * @return true/false - nfc is enabled/disabled.
55  */
IsNfcActive()56 bool NfccNciAdapter::IsNfcActive()
57 {
58     bool isActive = (isNfcEnabled_ && !isDisabling_);
59     return isActive;
60 }
61 
62 /**
63  * @brief whether tag is active.
64  * @return True/false tag is active/deactive.
65  */
IsTagActive() const66 bool NfccNciAdapter::IsTagActive() const
67 {
68     return isTagActive_;
69 }
70 
71 /**
72  * @brief Set card emulation listener to receive field on/off event.
73  * @param listener The listener to receive field on/off event.
74  */
SetCeHostListener(std::weak_ptr<INciCeInterface::ICeHostListener> listener)75 void NfccNciAdapter::SetCeHostListener(std::weak_ptr<INciCeInterface::ICeHostListener> listener)
76 {
77     cardEmulationListener_ = listener;
78 }
79 
80 /**
81  * @brief Start or stop rf discovery.
82  * @param isStart True/false start/stop rf discovery.
83  */
StartRfDiscovery(bool isStart)84 void NfccNciAdapter::StartRfDiscovery(bool isStart)
85 {
86     DebugLog("NfccNciAdapter::StartRfDiscovery: isStart= %{public}d", isStart);
87     tNFA_STATUS status = NFA_STATUS_FAILED;
88     if (isStart) {
89         status = NFA_StartRfDiscovery();
90     } else {
91         status = NFA_StopRfDiscovery();
92     }
93     if (status == NFA_STATUS_OK) {
94         if (nfcStartStopPollingEvent_.Wait(NCI_EVT_WAIT_TIMEOUT) == false) {
95             ErrorLog("NfccNciAdapter::StartRfDiscovery timeout. isStart = %{public}d", isStart);
96             return;
97         }
98         rfEnabled_ = isStart;
99     } else {
100         ErrorLog("NfccNciAdapter::StartRfDiscovery: Failed to start/stop RF discovery; error=0x%{public}X", status);
101     }
102 }
103 
StartPolling(tNFA_TECHNOLOGY_MASK techMask)104 tNFA_STATUS NfccNciAdapter::StartPolling(tNFA_TECHNOLOGY_MASK techMask)
105 {
106     DebugLog("NfccNciAdapter::StartPolling, techMask = 0x%{public}02X", techMask);
107     tNFA_STATUS status = NFA_EnablePolling(techMask);
108     if (status == NFA_STATUS_OK) {
109         DebugLog("StartPolling: wait for enable event");
110         // wait for NFA_POLL_ENABLED_EVT
111         if (nfcStartStopPollingEvent_.Wait(NCI_EVT_WAIT_TIMEOUT) == false) {
112             ErrorLog("NfccNciAdapter::StartPolling timeout.");
113             return status;
114         }
115         pollingEnabled_ = true;
116     } else {
117         ErrorLog("NfccNciAdapter::StartPolling: fail enable polling; error = 0x%{public}X", status);
118     }
119     return status;
120 }
121 
StopPolling()122 tNFA_STATUS NfccNciAdapter::StopPolling()
123 {
124     DebugLog("NfccNciAdapter::StopPolling");
125     tNFA_STATUS status = NFA_DisablePolling();
126     if (status == NFA_STATUS_OK) {
127         pollingEnabled_ = false;
128         // wait for NFA_POLL_DISABLED_EVT
129         if (nfcStartStopPollingEvent_.Wait(NCI_EVT_WAIT_TIMEOUT) == false) {
130             ErrorLog("NfccNciAdapter::StopPolling timeout.");
131         }
132     } else {
133         ErrorLog("NfccNciAdapter::StopPolling: fail disable polling; error = 0x%{public}X", status);
134     }
135     return status;
136 }
137 
IsDiscTypeListen(tNFC_ACTIVATE_DEVT & actNtf)138 bool NfccNciAdapter::IsDiscTypeListen(tNFC_ACTIVATE_DEVT& actNtf)
139 {
140     return ((actNtf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A) ||
141             (actNtf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B) ||
142             (actNtf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_F) ||
143             (actNtf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ||
144             (actNtf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE) ||
145             (actNtf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_ISO15693) ||
146             (actNtf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) ||
147             (actNtf.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF));
148 }
149 
DoNfaActivatedEvt(tNFA_CONN_EVT_DATA * eventData)150 void NfccNciAdapter::DoNfaActivatedEvt(tNFA_CONN_EVT_DATA* eventData)
151 {
152     uint8_t actProto = (tNFA_INTF_TYPE)eventData->activated.activate_ntf.protocol;
153     if (actProto == NFC_PROTOCOL_T5T && TagNciAdapterNtf::GetInstance().GetDiscRstEvtNum()) {
154         // protocol T5T only support single protocol detection
155         InfoLog("DoNfaActivatedEvt, NFC_PROTOCOL_T5T not support multi tag.");
156         TagNciAdapterNtf::GetInstance().SetDiscRstEvtNum(0);
157     }
158 #if (NXP_EXTNS == TRUE)
159     TagNciAdapterCommon::GetInstance().isIsoDepDhReqFailed_ = false;
160 #endif
161     // logic for SAK28 issue
162     if (g_isIsoMifareFlag) {
163         InfoLog("DoNfaActivatedEvt(SAK28) - ISOMIFARE data cleanup");
164         g_isIsoMifareFlag = false;
165         g_isoMifareBitMap = 0;
166         (void)memset_s(isoMifareUid, sizeof(isoMifareUid), 0, sizeof(isoMifareUid));
167     }
168 
169     // sync activated iface and proto
170     if ((actProto != NFA_PROTOCOL_NFC_DEP) && !IsDiscTypeListen(eventData->activated.activate_ntf)) {
171         TagNciAdapterNtf::GetInstance().SetCurrRfInterface(
172             (tNFA_INTF_TYPE)eventData->activated.activate_ntf.intf_param.type);
173         TagNciAdapterNtf::GetInstance().SetCurrRfProtocol(actProto);
174 #if (NXP_EXTNS == TRUE)
175         uint8_t mode = eventData->activated.activate_ntf.rf_tech_param.mode;
176         TagNciAdapterNtf::GetInstance().SetCurrRfMode(mode);
177         if (mode == NFC_DISCOVERY_TYPE_POLL_B || mode == NFC_DISCOVERY_TYPE_POLL_B_PRIME) {
178             TagNciAdapterNtf::GetInstance().SetNfcID0ForTypeB(
179                 eventData->activated.activate_ntf.rf_tech_param.param.pb.nfcid0);
180         }
181 #endif
182     }
183 
184 #if (NXP_EXTNS == TRUE)
185     //clear MulitProto Mifare Tag state on single proto tag activation
186     if (!TagNciAdapterNtf::GetInstance().GetIsMultiTag() &&
187         TagNciAdapterNtf::GetInstance().IsMultiMFCTag()) {
188         TagNciAdapterNtf::GetInstance().ClearMultiMFCTagState();
189     }
190 #endif
191 
192     // handle ActivatedResult for Mifare tag
193     if (Extns::GetInstance().EXTNS_GetConnectFlag() == true) {
194         TagNciAdapterNtf::GetInstance().SetTagActivated();
195         TagNciAdapterNtf::GetInstance().SetConnectStatus(true);
196         return;
197     }
198 
199     // handle ActivationResult for normal tags
200     if (isDisabling_ || !isNfcEnabled_) {
201         return;
202     }
203     isTagActive_ = true;
204     if (TagNciAdapterNtf::GetInstance().IsSwitchingRfIface()) {
205 #if (NXP_EXTNS == TRUE)
206         if (TagNciAdapterNtf::GetInstance().IsExpectedActRfProtocol(actProto)) {
207             TagNciAdapterNtf::GetInstance().SetTagActivated();
208         }
209 #else
210         TagNciAdapterNtf::GetInstance().SetTagActivated();
211 #endif
212         TagNciAdapterNtf::GetInstance().SetConnectStatus(true);
213         return;
214     }
215     TagNciAdapterNtf::GetInstance().SetTagActivated();
216     TagNciAdapterNtf::GetInstance().ResetTagFieldOnFlag();
217 
218     if (actProto == NFA_PROTOCOL_NFC_DEP) {
219         // we do not support peer to peer
220     } else {
221         TagNciAdapterNtf::GetInstance().HandleActivatedResult(eventData);
222         if (TagNciAdapterNtf::GetInstance().GetDiscRstEvtNum()) {
223             // do deactivate to sleep and wait for reselect for multi tag
224             NFA_Deactivate(true);
225         }
226         // skipped notify secureelement
227     }
228 }
229 
DoNfaDeactivatedEvt(tNFA_CONN_EVT_DATA * eventData)230 void NfccNciAdapter::DoNfaDeactivatedEvt(tNFA_CONN_EVT_DATA* eventData)
231 {
232     tNFA_DEACTIVATE_TYPE type = eventData->deactivated.type;
233     TagNciAdapterNtf::GetInstance().SetTagDeactivated((type == NFA_DEACTIVATE_TYPE_SLEEP));
234     TagNciAdapterNtf::GetInstance().SelectTheNextTag();
235     if (eventData->deactivated.type != NFA_DEACTIVATE_TYPE_SLEEP) {
236         isTagActive_ = false;
237 #if (NXP_EXTNS == TRUE)
238         TagNciAdapterNtf::GetInstance().SetDiscRstEvtNum(0);
239 #endif
240         TagNciAdapterNtf::GetInstance().ResetTagFieldOnFlag();
241 #if (NXP_EXTNS == TRUE)
242         if (!TagNciAdapterNtf::GetInstance().IsSwitchingRfIface()) {
243             TagNciAdapterNtf::GetInstance().HandleDeactivatedResult(type);
244             TagNciAdapterNtf::GetInstance().AbortWait();
245         }
246 #else
247         TagNciAdapterNtf::GetInstance().HandleDeactivatedResult(type);
248         TagNciAdapterNtf::GetInstance().AbortWait();
249 #endif
250         TagNciAdapterNtf::GetInstance().SetIsMultiTag(false);
251     } else if (TagNciAdapterNtf::GetInstance().IsTagDeactivating() ||
252                Extns::GetInstance().EXTNS_GetDeactivateFlag()) {
253         TagNciAdapterNtf::GetInstance().SetDeactivatedStatus();
254     }
255     // skipped special process for Secure Element transaction
256 }
257 
DoNfaDiscResultEvt(tNFA_CONN_EVT_DATA * eventData)258 void NfccNciAdapter::DoNfaDiscResultEvt(tNFA_CONN_EVT_DATA* eventData)
259 {
260     static tNFA_STATUS status = eventData->disc_result.status;
261     DebugLog("DoNfaDiscResultEvt: status = 0x%{public}X", status);
262 #if (NXP_EXTNS == TRUE)
263     static uint8_t prevMoreVal = 0x00;
264     uint8_t curMoreVal = eventData->disc_result.discovery_ntf.more;
265     bool isMoreValid = true;
266     // 01 means the last notification due to nfcc reaching resource limit
267     // 02 means more notification
268     if ((curMoreVal == 0x01) && (prevMoreVal != 0x02)) {
269         ErrorLog("DoNfaDiscResultEvt: invalid more value");
270         isMoreValid = false;
271     } else {
272         DebugLog("DoNfaDiscResultEvt: valid more value");
273         isMoreValid = true;
274         prevMoreVal = curMoreVal;
275     }
276 #endif
277     if (!isMoreValid) {
278         TagNciAdapterNtf::GetInstance().SetDiscRstEvtNum(0);
279     } else {
280         TagNciAdapterNtf::GetInstance().HandleDiscResult(eventData);
281         HandleDiscNtf(&eventData->disc_result.discovery_ntf);
282     }
283 }
284 
HandleDiscNtf(tNFC_RESULT_DEVT * discNtf)285 void NfccNciAdapter::HandleDiscNtf(tNFC_RESULT_DEVT* discNtf)
286 {
287     // logic for SAK28 issue
288     if (discNtf->rf_disc_id == NCI_RF_DISCOVER_NTF_FIRST_ID) {
289         (void)memset_s(isoMifareUid, sizeof(isoMifareUid), 0, sizeof(isoMifareUid));
290         g_isoMifareBitMap = 0;
291         errno_t err = EOK;
292         if (discNtf->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) {
293             err = memcpy_s(isoMifareUid, sizeof(isoMifareUid),
294                            discNtf->rf_tech_param.param.pa.nfcid1,
295                            discNtf->rf_tech_param.param.pa.nfcid1_len);
296             if (err != EOK) {
297                 ErrorLog("HandleDiscNtf:(SAK28) memcpy_s first uid failed, err = %{public}d", err);
298             }
299             if (discNtf->protocol == NFC_PROTOCOL_ISO_DEP) {
300                 g_isoMifareBitMap |= FLAG_MULTI_TAG_ISO_DEP;
301             } else if (discNtf->protocol == NFC_PROTOCOL_MIFARE) {
302                 g_isoMifareBitMap |= FLAG_MULTI_TAG_MIFARE;
303             }
304         }
305     } else if (discNtf->rf_disc_id == NCI_RF_DISCOVER_NTF_SECOND_ID) {
306         if (discNtf->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) {
307             if (memcmp(isoMifareUid, discNtf->rf_tech_param.param.pa.nfcid1,
308                        discNtf->rf_tech_param.param.pa.nfcid1_len) == 0) {
309                 InfoLog("HandleDiscNtf:(SAK28) multicard with same uid");
310                 if (discNtf->protocol == NFC_PROTOCOL_ISO_DEP) {
311                     g_isoMifareBitMap |= FLAG_MULTI_TAG_ISO_DEP;
312                 } else if (discNtf->protocol == NFC_PROTOCOL_MIFARE) {
313                     g_isoMifareBitMap |= FLAG_MULTI_TAG_MIFARE;
314                 }
315             }
316         }
317     }
318     InfoLog("HandleDiscNtf:(SAK28) g_isoMifareBitMap = 0x%{public}02X, g_isIsoMifareFlag = %{public}d",
319             g_isoMifareBitMap, g_isIsoMifareFlag);
320     if ((g_isoMifareBitMap & FLAG_MULTI_TAG_ISO_DEP) && (g_isoMifareBitMap & FLAG_MULTI_TAG_MIFARE) &&
321          g_isIsoMifareFlag && readerModeEnabled_ == false) {
322         InfoLog("HandleDiscNtf:(SAK28) same tag discovered twice, skip Mifare detection");
323         g_isoMifareBitMap = 0;
324         TagNciAdapterNtf::GetInstance().SetSkipMifareInterface();
325     }
326 
327     // logic for normal tag
328     if (discNtf->more == NCI_DISCOVER_NTF_MORE) {
329         // there is more discovery notification coming
330         TagNciAdapterNtf::GetInstance().SetDiscRstEvtNum(TagNciAdapterNtf::GetInstance().GetDiscRstEvtNum() + 1);
331         return;
332     }
333     if (TagNciAdapterNtf::GetInstance().GetDiscRstEvtNum() > 0) {
334         TagNciAdapterNtf::GetInstance().SetIsMultiTag(true);
335     }
336     // select the first tag of multiple tags that is discovered
337     TagNciAdapterNtf::GetInstance().SelectTheFirstTag();
338 }
339 
DoNfaSelectResultEvt(uint8_t status)340 void NfccNciAdapter::DoNfaSelectResultEvt(uint8_t status)
341 {
342     TagNciAdapterNtf::GetInstance().HandleSelectResult(status);
343 }
344 
DoNfaPresenceEvt(tNFA_CONN_EVT_DATA * eventData)345 void NfccNciAdapter::DoNfaPresenceEvt(tNFA_CONN_EVT_DATA* eventData)
346 {
347     static tNFA_STATUS curStatus = NFA_STATUS_FAILED;
348     if (eventData->status != curStatus) {
349         curStatus = eventData->status;
350     }
351     TagNciAdapterNtf::GetInstance().HandleFieldCheckResult(curStatus);
352 
353     // logic for SAK28 issue
354     if (curStatus != NFA_STATUS_OK) {
355         if ((g_isoMifareBitMap & FLAG_MULTI_TAG_ISO_DEP) && (g_isoMifareBitMap & FLAG_MULTI_TAG_MIFARE)) {
356             InfoLog("DoNfaPresenceEvt:(SAK28) set g_isIsoMifareFlag");
357             g_isIsoMifareFlag = true;
358         }
359         g_isoMifareBitMap = 0;
360     }
361 }
362 
NfcConnectionCallback(uint8_t connEvent,tNFA_CONN_EVT_DATA * eventData)363 void NfccNciAdapter::NfcConnectionCallback(uint8_t connEvent, tNFA_CONN_EVT_DATA* eventData)
364 {
365     if (eventData == nullptr) {
366         ErrorLog("NfcConnectionCallback, eventData is null. connEvent = %{public}X", connEvent);
367         return;
368     }
369     switch (connEvent) {
370         /* whether polling successfully started */
371         case NFA_POLL_ENABLED_EVT: {
372             DebugLog("NfaConnectionCallback: NFA_POLL_ENABLED_EVT: status = %{public}u", eventData->status);
373             NfccNciAdapter::GetInstance().DoNfaPollEnabledDisabledEvt();
374             break;
375         }
376         /* Listening/Polling stopped */
377         case NFA_POLL_DISABLED_EVT: {
378             DebugLog("NfaConnectionCallback: NFA_POLL_DISABLED_EVT: status = %{public}u", eventData->status);
379             NfccNciAdapter::GetInstance().DoNfaPollEnabledDisabledEvt();
380             break;
381         }
382         /* RF Discovery started event */
383         case NFA_RF_DISCOVERY_STARTED_EVT: {
384             DebugLog("NfaConnectionCallback: NFA_RF_DISCOVERY_STARTED_EVT: status = %{public}u", eventData->status);
385             NfccNciAdapter::GetInstance().DoNfaPollEnabledDisabledEvt();
386             break;
387         }
388         /* RF Discovery stopped event */
389         case NFA_RF_DISCOVERY_STOPPED_EVT: {
390             DebugLog("NfaConnectionCallback: NFA_RF_DISCOVERY_STOPPED_EVT: status = %{public}u", eventData->status);
391             NfccNciAdapter::GetInstance().DoNfaPollEnabledDisabledEvt();
392             break;
393         }
394         /* NFC deactivate failed event */
395         case NFA_DEACTIVATE_FAIL_EVT: {
396             DebugLog("NfaConnectionCallback: NFA_DEACTIVATE_FAIL_EVT: status = %{public}u", eventData->status);
397 #if (NXP_EXTNS == TRUE)
398             if (eventData->status == NFC_DEACTIVATE_REASON_DH_REQ_FAILED) {
399                 TagNciAdapterCommon::GetInstance().isIsoDepDhReqFailed_ = true;
400             }
401 #endif
402             break;
403         }
404         /* NFC link/protocol activated */
405         case NFA_ACTIVATED_EVT: {
406             DebugLog("NfaConnectionCallback: NFA_ACTIVATED_EVT");
407             NfccNciAdapter::GetInstance().DoNfaActivatedEvt(eventData);
408             break;
409         }
410         /* NFC link/protocol deactivated */
411         case NFA_DEACTIVATED_EVT: {
412             DebugLog("NfaConnectionCallback: NFA_DEACTIVATED_EVT");
413             NfccNciAdapter::GetInstance().DoNfaDeactivatedEvt(eventData);
414             break;
415         }
416         case NFA_DISC_RESULT_EVT: {
417             DebugLog("NfaConnectionCallback: NFA_DISC_RESULT_EVT");
418             NfccNciAdapter::GetInstance().DoNfaDiscResultEvt(eventData);
419             break;
420         }
421         case NFA_SELECT_RESULT_EVT: {
422             DebugLog("NfaConnectionCallback: NFA_SELECT_RESULT_EVT: status = 0x%{public}X", eventData->status);
423             NfccNciAdapter::GetInstance().DoNfaSelectResultEvt(eventData->status);
424             break;
425         }
426         /* Data message received (for non-NDEF reads) */
427         case NFA_DATA_EVT: {
428             DebugLog("NfaConnectionCallback: NFA_DATA_EVT: status = 0x%{public}X, len = %{public}d",
429                 eventData->status, eventData->data.len);
430             TagNciAdapterNtf::GetInstance().HandleTranceiveData(eventData->status, eventData->data.p_data,
431                 eventData->data.len);
432             break;
433         }
434         case NFA_PRESENCE_CHECK_EVT: {
435             NfccNciAdapter::GetInstance().DoNfaPresenceEvt(eventData);
436             break;
437         }
438         case NFA_READ_CPLT_EVT: {
439             DebugLog("NfaConnectionCallback: NFA_READ_CPLT_EVT: status = 0x%{public}X", eventData->status);
440             TagNciAdapterNtf::GetInstance().HandleReadComplete(eventData->status);
441             break;
442         }
443         case NFA_WRITE_CPLT_EVT: {
444             DebugLog("NfaConnectionCallback: NFA_WRITE_CPLT_EVT: status = 0x%{public}X", eventData->status);
445             TagNciAdapterNtf::GetInstance().HandleWriteComplete(eventData->status);
446             break;
447         }
448         case NFA_FORMAT_CPLT_EVT: {
449             DebugLog("NfaConnectionCallback: NFA_FORMAT_CPLT_EVT: status = 0x%{public}X", eventData->status);
450             TagNciAdapterNtf::GetInstance().HandleFormatComplete(eventData->status);
451             break;
452         }
453         case NFA_NDEF_DETECT_EVT: {
454             DebugLog("NfaConnectionCallback: NFA_NDEF_DETECT_EVT: status = 0x%{public}X, protocol = 0x%{public}X,"
455                 " max_size = %{public}u, cur_size = %{public}u, flags = 0x%{public}X",
456                 eventData->ndef_detect.status, eventData->ndef_detect.protocol,
457                 static_cast<uint32_t>(eventData->ndef_detect.max_size),
458                 static_cast<uint32_t>(eventData->ndef_detect.cur_size), eventData->ndef_detect.flags);
459             TagNciAdapterNtf::GetInstance().HandleNdefCheckResult(eventData->ndef_detect.status,
460                 eventData->ndef_detect.cur_size, eventData->ndef_detect.flags, eventData->ndef_detect.max_size);
461             break;
462         }
463         case NFA_SET_TAG_RO_EVT: {
464             DebugLog("NfaDeviceManagementCallback: NFA_SET_TAG_RO_EVT; status = 0x%{public}X", eventData->status);
465             TagNciAdapterNtf::GetInstance().HandleSetReadOnlyResult(eventData->status);
466             break;
467         }
468         default: {
469             DebugLog("NfaConnectionCallback: unknown event %{public}u", connEvent);
470             break;
471         }
472     }
473 }
474 
475 /* method for SAK28 issue */
SendActEvtForSak28Tag(uint8_t connEvent,tNFA_CONN_EVT_DATA * eventData)476 void NfccNciAdapter::SendActEvtForSak28Tag(uint8_t connEvent, tNFA_CONN_EVT_DATA* eventData)
477 {
478     NfcConnectionCallback(connEvent, eventData);
479 }
480 
DoNfaPollEnabledDisabledEvt()481 void NfccNciAdapter::DoNfaPollEnabledDisabledEvt()
482 {
483     SynchronizeGuard guard(nfcStartStopPollingEvent_);
484     nfcStartStopPollingEvent_.NotifyOne();
485 }
486 
DoNfaDmEnableEvt(tNFA_DM_CBACK_DATA * eventData)487 void NfccNciAdapter::DoNfaDmEnableEvt(tNFA_DM_CBACK_DATA* eventData)
488 {
489     SynchronizeGuard guard(nfcEnableEvent_);
490     isNfcEnabled_ = (eventData->status == NFA_STATUS_OK);
491     isDisabling_ = false;
492     nfcEnableEvent_.NotifyOne();
493 }
494 
DoNfaDmDisableEvt(tNFA_DM_CBACK_DATA * eventData)495 void NfccNciAdapter::DoNfaDmDisableEvt(tNFA_DM_CBACK_DATA* eventData)
496 {
497     SynchronizeGuard guard(nfcDisableEvent_);
498     isNfcEnabled_ = false;
499     isDisabling_ = false;
500     nfcDisableEvent_.NotifyOne();
501 }
502 
503 /**
504  * @brief Whether rf field is on or off.
505  * @return True/false to be field on/off.
506  */
isRfFieldOn()507 bool NfccNciAdapter::isRfFieldOn()
508 {
509     if (isRfFieldOn_) {
510         return true;
511     }
512     uint64_t currTime = KITS::NfcSdkCommon::GetCurrentTime();
513     // If it is less than 50ms before fieldoff, then it is considered field on;
514     if ((currTime - lastRfFieldTime) < 50) {
515         return true;
516     }
517     return false;
518 }
519 
DoNfaDmRfFieldEvt(tNFA_DM_CBACK_DATA * eventData)520 void NfccNciAdapter::DoNfaDmRfFieldEvt(tNFA_DM_CBACK_DATA* eventData)
521 {
522     lastRfFieldTime = 0;
523     isRfFieldOn_ = false;
524     if (cardEmulationListener_.expired()) {
525         DebugLog("DoNfaDmRfFieldEvt: cardEmulationListener_ is null");
526         return;
527     }
528     if (eventData->rf_field.status == NFA_STATUS_OK) {
529         lastRfFieldTime = KITS::NfcSdkCommon::GetCurrentTime();
530         // notify field on/off event to nfc service.
531         if (eventData->rf_field.rf_field_status == NFA_DM_RF_FIELD_ON) {
532             isRfFieldOn_ = true;
533             cardEmulationListener_.lock()->FieldActivated();
534         } else {
535             isRfFieldOn_ = false;
536             cardEmulationListener_.lock()->FieldDeactivated();
537         }
538     }
539 }
540 
DoNfaDmSetConfig()541 void NfccNciAdapter::DoNfaDmSetConfig()
542 {
543     SynchronizeGuard guard(nfcSetConfigEvent_);
544     DebugLog("NfaDeviceManagementCallback: NFA_DM_SET_CONFIG_EVT");
545     nfcSetConfigEvent_.NotifyOne();
546 }
DoNfaSetPowerSubState()547 void NfccNciAdapter::DoNfaSetPowerSubState()
548 {
549     SynchronizeGuard guard(nfcSetPowerSubStateEvent_);
550     nfcSetPowerSubStateEvent_.NotifyOne();
551 }
552 
DoNfaDmNfccTimeoutEvt(tNFA_DM_CBACK_DATA * eventData)553 void NfccNciAdapter::DoNfaDmNfccTimeoutEvt(tNFA_DM_CBACK_DATA* eventData)
554 {
555     {
556         SynchronizeGuard guard(nfcEnableEvent_);
557         nfcEnableEvent_.NotifyOne();
558     }
559     {
560         SynchronizeGuard guard(nfcDisableEvent_);
561         nfcDisableEvent_.NotifyOne();
562     }
563     {
564         SynchronizeGuard guard(nfcStartStopPollingEvent_);
565         nfcStartStopPollingEvent_.NotifyOne();
566     }
567     discoveryEnabled_ = false;
568     pollingEnabled_ = false;
569 
570     if (IsNfcActive()) {
571         NFA_Disable(FALSE);
572         isDisabling_ = true;
573     } else {
574         isNfcEnabled_ = false;
575         isDisabling_ = false;
576     }
577 }
578 
NfcDeviceManagementCallback(uint8_t dmEvent,tNFA_DM_CBACK_DATA * eventData)579 void NfccNciAdapter::NfcDeviceManagementCallback(uint8_t dmEvent, tNFA_DM_CBACK_DATA* eventData)
580 {
581     if (eventData == nullptr) {
582         ErrorLog("NfcDeviceManagementCallback, eventData is null. dmEvent = %{public}X", dmEvent);
583         return;
584     }
585     DebugLog("NfaDeviceManagementCallback: event= %{public}u", dmEvent);
586 
587     switch (dmEvent) {
588         /* Result of NFA_Enable */
589         case NFA_DM_ENABLE_EVT: {
590             DebugLog("NfaDeviceManagementCallback: NFA_DM_ENABLE_EVT; status = 0x%{public}X", eventData->status);
591             NfccNciAdapter::GetInstance().DoNfaDmEnableEvt(eventData);
592             break;
593         }
594         /* Result of NFA_Disable */
595         case NFA_DM_DISABLE_EVT: {
596             DebugLog("NfaDeviceManagementCallback: NFA_DM_DISABLE_EVT");
597             NfccNciAdapter::GetInstance().DoNfaDmDisableEvt(eventData);
598             break;
599         }
600 
601         case NFA_DM_RF_FIELD_EVT: {
602             DebugLog("NfaDeviceManagementCallback: NFA_DM_RF_FIELD_EVT; status = 0x%{public}X; field status = "
603                 "%{public}u", eventData->rf_field.status, eventData->rf_field.rf_field_status);
604             NfccNciAdapter::GetInstance().DoNfaDmRfFieldEvt(eventData);
605             break;
606         }
607 
608         case NFA_DM_NFCC_TRANSPORT_ERR_EVT:
609         case NFA_DM_NFCC_TIMEOUT_EVT: {
610             NfccNciAdapter::GetInstance().DoNfaDmNfccTimeoutEvt(eventData);
611             break;
612         }
613 
614         case NFA_DM_SET_CONFIG_EVT: {
615             NfccNciAdapter::GetInstance().DoNfaDmSetConfig();
616             break;
617         }
618 
619         case NFA_DM_SET_POWER_SUB_STATE_EVT: {
620             DebugLog("NfaDeviceManagementCallback: NFA_DM_SET_POWER_SUB_STATE_EVT; status=0x%{public}X",
621                      eventData->power_mode.status);
622             NfccNciAdapter::GetInstance().DoNfaSetPowerSubState();
623             break;
624         }
625 
626         case NFA_SET_TAG_RO_EVT: {
627             DebugLog("NfaDeviceManagementCallback: NFA_SET_TAG_RO_EVT; status = 0x%{public}X", eventData->status);
628             TagNciAdapterNtf::GetInstance().HandleSetReadOnlyResult(eventData->status);
629             break;
630         }
631         default: {
632             ErrorLog("NfaDeviceManagementCallback: unknown event %{public}d", dmEvent);
633             break;
634         }
635     }
636 }
637 
NfaRegVSCback(bool isRegster,tNFA_VSC_CBACK * vscCback)638 tNFA_STATUS NfccNciAdapter::NfaRegVSCback(bool isRegster, tNFA_VSC_CBACK* vscCback)
639 {
640     return NFA_STATUS_OK;
641 }
642 
PrivateNciCallback(uint8_t event,uint16_t paramLen,uint8_t * param)643 void NfccNciAdapter::PrivateNciCallback(uint8_t event, uint16_t paramLen, uint8_t *param)
644 {
645 }
646 
647 /**
648  * @brief Initialize nfc.
649  * @return true/false - initialize is successful or not successful.
650  */
Initialize()651 bool NfccNciAdapter::Initialize()
652 {
653     DebugLog("NfccNciAdapter::Initialize");
654     tNFA_STATUS status = NFA_STATUS_FAILED;
655     if (isNfcEnabled_) {
656         WarnLog("NfccNciAdapter::Initialize: already enabled");
657         return isNfcEnabled_;
658     }
659 
660     NfcAdaptation::GetInstance().Initialize();  // start GKI, NCI task, NFC task
661     SynchronizeGuard guard(nfcEnableEvent_);
662     tHAL_NFC_ENTRY* halFuncEntries = NfcAdaptation::GetInstance().GetHalEntryFuncs();
663 
664     NFA_Init(halFuncEntries);
665     status = NFA_Enable(NfcDeviceManagementCallback, NfcConnectionCallback);
666     if (status == NFA_STATUS_OK) {
667         if (nfcEnableEvent_.Wait(NCI_EVT_WAIT_TIMEOUT) == false) {
668             ErrorLog("NfccNciAdapter::Initialize : Enable nfc timeout");
669         }
670     }
671     Extns::GetInstance().EXTNS_Init(NfcDeviceManagementCallback, NfcConnectionCallback);
672     NfaRegVSCback(true, PrivateNciCallback);
673 
674     if (status == NFA_STATUS_OK) {
675         // sIsNfaEnabled indicates whether stack started successfully
676         if (isNfcEnabled_) {
677 #ifdef _NFC_SERVICE_HCE_
678             NciBalCe::GetInstance().InitializeCe();
679             HciManager::GetInstance().Initialize();
680 #endif
681             isRoutingInited_ = RoutingManager::GetInstance().Initialize();
682             TagNciAdapterNtf::GetInstance().RegisterNdefHandler();
683             discoveryDuration_ = DEFAULT_DISCOVERY_DURATION;
684             NFA_SetRfDiscoveryDuration(static_cast<uint16_t>(discoveryDuration_));
685             DebugLog("NfccNciAdapter::Initialize: nfc enabled = %{public}d", isNfcEnabled_);
686             return isNfcEnabled_;
687         }
688     }
689     ErrorLog("NfccNciAdapter::Initialize: fail nfa enable; error = %{public}d", status);
690     if (isNfcEnabled_) {
691         Extns::GetInstance().EXTNS_Close();
692         status = NFA_Disable(false);
693         DebugLog("NfccNciAdapter::Initialize: status = %{public}d", status);
694     }
695     NfcAdaptation::GetInstance().Finalize();
696     DebugLog("NfccNciAdapter::Initialize: nfc enabled = %{public}d", isNfcEnabled_);
697     return isNfcEnabled_;
698 }
699 
700 /**
701  * @brief Deinitialize nfc.
702  * @return true/false - deinitialize is successful or not successful.
703  */
Deinitialize()704 bool NfccNciAdapter::Deinitialize()
705 {
706     DebugLog("NfccNciAdapter::Deinitialize");
707     if (!IsNfcActive()) {
708         WarnLog("NfccNciAdapter::Deinitialize: Nfc not initialized");
709         return NFA_STATUS_OK;
710     }
711 
712     tNFA_STATUS status = NFA_STATUS_OK;
713     isDisabling_ = true;
714 
715 #ifdef _NFC_SERVICE_HCE_
716     NciBalCe::GetInstance().Deinitialize();
717 #endif
718     RoutingManager::GetInstance().Deinitialize();
719 
720     if (isNfcEnabled_) {
721         SynchronizeGuard guard(nfcDisableEvent_);
722         Extns::GetInstance().EXTNS_Close();
723         status = NFA_Disable(true);
724         if (status == NFA_STATUS_OK) {
725             if (nfcDisableEvent_.Wait(NCI_EVT_WAIT_TIMEOUT) == false) {
726                 ErrorLog("NfccNciAdapter::Deinitialize : disable nfc timeout");
727             } else {
728                 DebugLog("NfccNciAdapter::Deinitialize: wait for completion");
729             }
730         } else {
731             ErrorLog("NfccNciAdapter::Deinitialize: fail disable; error = 0x%{public}X", status);
732         }
733     }
734     isNfcEnabled_ = false;
735     isRoutingInited_ = false;
736     discoveryEnabled_ = false;
737     isDisabling_ = false;
738     pollingEnabled_ = false;
739 
740     NfcAdaptation::GetInstance().Finalize();
741     NfaRegVSCback(false, PrivateNciCallback);
742     DebugLog("NfccNciAdapter::Deinitialize: exit");
743     return (status == NFA_STATUS_OK);
744 }
745 
746 /**
747  * @brief whether to enable discovery for nfc.
748  * @param techMask Supported rf technology for nfc.
749  * @param enableReaderMode True/false to enable/disable reader mode
750  * @param enableHostRouting True/false to enable/disable host routing
751  * @param restart True/false to restart or not restart
752  */
EnableDiscovery(uint16_t techMask,bool enableReaderMode,bool enableHostRouting,bool restart)753 void NfccNciAdapter::EnableDiscovery(uint16_t techMask, bool enableReaderMode, bool enableHostRouting, bool restart)
754 {
755     DebugLog("NfccNciAdapter::EnableDiscovery");
756     if (!IsNfcActive()) {
757         ErrorLog("NfccNciAdapter::EnableDiscovery: Nfc not initialized.");
758         return;
759     }
760 
761     if (discoveryEnabled_ && !restart) {
762         WarnLog("NfccNciAdapter::EnableDiscovery: already discovering");
763         return;
764     }
765 
766     if (rfEnabled_) {
767         // Stop RF discovery to reconfigure
768         StartRfDiscovery(false);
769     }
770 
771     tNFA_TECHNOLOGY_MASK technologyMask = techMask & DEFAULT_TECH_MASK;
772     if (technologyMask != 0) {
773         StopPolling();
774         StartPolling(technologyMask);
775         if (pollingEnabled_) {
776             if (enableReaderMode && !readerModeEnabled_) {
777                 readerModeEnabled_ = true;
778                 NFA_DisableListening();
779                 NFA_SetRfDiscoveryDuration(DISCOVERY_DURATION);
780             } else if (!enableReaderMode && readerModeEnabled_) {
781                 readerModeEnabled_ = false;
782                 NFA_EnableListening();
783                 NFA_SetRfDiscoveryDuration(DISCOVERY_DURATION);
784             }
785         }
786     } else {
787         StopPolling();
788     }
789 #ifdef _NFC_SERVICE_HCE_
790     NciBalCe::GetInstance().EnableHostRouting(enableHostRouting);
791     NciBalCe::GetInstance().CommitRouting();
792 #endif
793 
794     StartRfDiscovery(true);
795     discoveryEnabled_ = true;
796     DebugLog("NfccNciAdapter::EnableDiscovery: exit");
797 }
798 
799 /**
800  * @brief Disable discovery for nfc.
801  */
DisableDiscovery()802 void NfccNciAdapter::DisableDiscovery()
803 {
804     DebugLog("NfccNciAdapter::DisableDiscovery");
805     if (!IsNfcActive()) {
806         ErrorLog("NfccNciAdapter::DisableDiscovery: Nfc not initialized.");
807         return;
808     }
809     if (!discoveryEnabled_) {
810         WarnLog("NfccNciAdapter::DisableDiscovery: already disabled");
811         return;
812     }
813     // Stop RF Discovery.
814     StartRfDiscovery(false);
815     if (pollingEnabled_) {
816         StopPolling();
817     }
818     discoveryEnabled_ = false;
819     readerModeEnabled_ = false;
820     DebugLog("NfccNciAdapter::DisableDiscovery: exit");
821 }
822 
823 /**
824  * @brief Send raw data.
825  * @param rawData Data needed to send
826  * @return True/false to successful/failed to send
827  */
SendRawFrame(std::string & rawData)828 bool NfccNciAdapter::SendRawFrame(std::string& rawData)
829 {
830     uint16_t length = KITS::NfcSdkCommon::GetHexStrBytesLen(rawData);
831     uint8_t data[length];
832     for (uint32_t i = 0; i < length; i++) {
833         data[i] = KITS::NfcSdkCommon::GetByteFromHexStr(rawData, i);
834     }
835     tNFA_STATUS status = NFA_SendRawFrame(data, length, 0);
836     InfoLog("SendRawFrame status = %{public}d", status);
837     if (status != NFA_STATUS_OK) {
838         ErrorLog("NfccNciAdapter::SendRawFrame failed. status = %{public}X", status);
839     }
840     return status == NFA_STATUS_OK;
841 }
842 
GetDiscovryParam(unsigned char screenState,unsigned char screenStateMask)843 uint8_t NfccNciAdapter::GetDiscovryParam(unsigned char screenState, unsigned char screenStateMask)
844 {
845     // discocery parameters for SCREEN OFF_LOCKED or OFF_UNLOCKED
846     if (screenState == NFA_SCREEN_STATE_OFF_LOCKED || screenState == NFA_SCREEN_STATE_OFF_UNLOCKED) {
847         return (NCI_POLLING_DH_DISABLE_MASK | NCI_LISTEN_DH_NFCEE_DISABLE_MASK);
848     }
849 
850     // discocery parameters for SCREEN ON_LOCKED
851     if (screenState == NFA_SCREEN_STATE_ON_LOCKED) {
852         return (screenStateMask & NFA_SCREEN_POLLING_TAG_MASK)
853                 ? (NCI_POLLING_DH_ENABLE_MASK | NCI_LISTEN_DH_NFCEE_ENABLE_MASK)
854                 : (NCI_POLLING_DH_DISABLE_MASK | NCI_LISTEN_DH_NFCEE_ENABLE_MASK);
855     }
856 
857     // discocery parameters for SCREEN ON_UNLOCKED
858     if (screenState == NFA_SCREEN_STATE_ON_UNLOCKED) {
859         return (NCI_POLLING_DH_ENABLE_MASK | NCI_LISTEN_DH_NFCEE_ENABLE_MASK);
860     }
861 
862     // default discocery parameters
863     return (NCI_POLLING_DH_ENABLE_MASK | NCI_LISTEN_DH_NFCEE_ENABLE_MASK);
864 }
865 
866 /**
867  * @brief Send the status of screen.
868  * @param screenStateMask The state of screen
869  */
SetScreenStatus(unsigned char screenStateMask)870 void NfccNciAdapter::SetScreenStatus(unsigned char screenStateMask)
871 {
872     DebugLog("NfccNciAdapter::SetScreenStatus");
873     if (!IsNfcActive()) {
874         DebugLog("Do not handle Screen state change when NFC is not active");
875         return;
876     }
877     unsigned char screenState = screenStateMask & NFA_SCREEN_STATE_MASK;
878     if (curScreenState_ == screenState) {
879         WarnLog("Screen state not changed");
880         return;
881     }
882     if (GetNciVersion() != NCI_VERSION_2_0) {
883         WarnLog("only update curScreenState when NCI version under 2.0");
884         curScreenState_ = screenState;
885         return;
886     }
887 
888     // set power state for screen state.
889     tNFA_STATUS status = NFA_STATUS_FAILED;
890     unsigned char curScreenState = NFA_SCREEN_STATE_OFF_LOCKED | NFA_SCREEN_STATE_OFF_UNLOCKED |
891         NFA_SCREEN_STATE_ON_LOCKED | NFA_SCREEN_STATE_UNKNOWN;
892     if ((curScreenState_ & curScreenState) != 0) {
893         SynchronizeGuard guard(nfcSetPowerSubStateEvent_);
894         status = NFA_SetPowerSubStateForScreenState(screenState);
895         if (status != NFA_STATUS_OK) {
896             ErrorLog("NFA_SetPowerSubStateForScreenState fail, error=0x%{public}X, screenState = %{public}X,\
897                 curScreenState_ = %{public}X", status, screenState, curScreenState_);
898             return;
899         }
900         if (nfcSetPowerSubStateEvent_.Wait(NCI_EVT_WAIT_TIMEOUT) == false) {
901             ErrorLog("NfccNciAdapter::SetScreenStatus : SetScreenStatus nfc timeout");
902         }
903     }
904 
905     uint8_t discParam = GetDiscovryParam(screenState, screenStateMask);
906     SynchronizeGuard guard(nfcSetConfigEvent_);
907     status = NFA_SetConfig(NCI_PARAM_ID_CON_DISCOVERY_PARAM,
908         NCI_PARAM_LEN_CON_DISCOVERY_PARAM, &discParam);
909     if (status != NFA_STATUS_OK) {
910         ErrorLog("NFA_SetConfig fail, error=0x%{public}X", status);
911         return;
912     }
913     if (nfcSetConfigEvent_.Wait(NCI_EVT_WAIT_TIMEOUT) == false) {
914         ErrorLog("NfccNciAdapter::SetScreenStatus : nfcSetConfigEvent_ nfc timeout");
915     }
916 
917     if (curScreenState_ == NFA_SCREEN_STATE_ON_UNLOCKED) {
918         SynchronizeGuard guard(nfcSetPowerSubStateEvent_);
919         status = NFA_SetPowerSubStateForScreenState(screenState);
920         if (status != NFA_STATUS_OK) {
921             ErrorLog("NFA_SetPowerSubStateForScreenState fail, error=0x%{public}X", status);
922             return;
923         }
924         if (nfcSetPowerSubStateEvent_.Wait(NCI_EVT_WAIT_TIMEOUT) == false) {
925             ErrorLog("NfccNciAdapter::SetScreenStatus : SetScreenStatus nfc timeout");
926         }
927     }
928     curScreenState_ = screenState;
929     return;
930 }
931 
932 /**
933  * @brief Get nci version.
934  * @return Nci version
935  */
GetNciVersion() const936 uint32_t NfccNciAdapter::GetNciVersion() const
937 {
938     DebugLog("NfccNciAdapter::GetNciVersion");
939     uint8_t version = NFC_GetNCIVersion();
940     return version;
941 }
942 
RegisterT3tIdentifier(const std::string & t3tIdentifier) const943 bool NfccNciAdapter::RegisterT3tIdentifier(const std::string& t3tIdentifier) const
944 {
945     DebugLog("NfccNciAdapter::RegisterT3tIdentifier");
946     return true;
947 }
948 
DeregisterT3tIdentifier(uint32_t handle) const949 void NfccNciAdapter::DeregisterT3tIdentifier(uint32_t handle) const
950 {
951     DebugLog("NfccNciAdapter::DeregisterT3tIdentifier");
952 }
953 
ClearT3tIdentifiersCache()954 void NfccNciAdapter::ClearT3tIdentifiersCache()
955 {
956     DebugLog("NfccNciAdapter::ClearT3tIdentifiersCache");
957 }
958 
GetLfT3tMax()959 uint32_t NfccNciAdapter::GetLfT3tMax()
960 {
961     DebugLog("NfccNciAdapter::GetLfT3tMax");
962     return 0;
963 }
964 
GetLastError()965 uint32_t NfccNciAdapter::GetLastError()
966 {
967     DebugLog("NfccNciAdapter::GetLastError");
968     return 0;
969 }
970 
Abort()971 void NfccNciAdapter::Abort()
972 {
973     InfoLog("NfccNciAdapter::Abort");
974     _exit(0);
975 }
976 
977 /**
978  * @brief Check whether to load firmware.
979  * @return True/false to success/fail to load firmware.
980  */
CheckFirmware()981 bool NfccNciAdapter::CheckFirmware()
982 {
983     DebugLog("NfccNciAdapter::CheckFirmware");
984     NfcAdaptation::GetInstance().Initialize();
985     NfcAdaptation::GetInstance().DownloadFirmware(nullptr, true);
986     NfcAdaptation::GetInstance().Finalize();
987     return true;
988 }
989 
990 /**
991  * @brief Dump debug info for nfc.
992  * @param fd File descriptor to store debug info.
993  */
Dump(uint32_t fd) const994 void NfccNciAdapter::Dump(uint32_t fd) const
995 {
996     DebugLog("NfccNciAdapter::Dump, fd=%{public}d", fd);
997     NfcAdaptation::GetInstance().Dump(fd);
998 }
999 
1000 /**
1001  * @brief Reset nfc chip.
1002  */
FactoryReset() const1003 void NfccNciAdapter::FactoryReset() const
1004 {
1005     DebugLog("NfccNciAdapter::FactoryReset");
1006     NfcAdaptation::GetInstance().FactoryReset();
1007 }
1008 
1009 /**
1010  * @brief Close nfc.
1011  */
Shutdown() const1012 void NfccNciAdapter::Shutdown() const
1013 {
1014     DebugLog("NfccNciAdapter::Shutdown");
1015     NfcAdaptation::GetInstance().DeviceShutdown();
1016 }
1017 
1018 /**
1019  * @brief Query whether to start rf discovery.
1020  * @return True/false to start/stop rf discovery.
1021  */
IsRfEbabled()1022 bool NfccNciAdapter::IsRfEbabled()
1023 {
1024     return rfEnabled_;
1025 }
1026 
1027 /**
1028  * @brief Config commit routing table for nfc.
1029  * @return True/false to be successful/failed to config routing table.
1030  */
CommitRouting()1031 bool NfccNciAdapter::CommitRouting()
1032 {
1033     return RoutingManager::GetInstance().CommitRouting();
1034 }
1035 
1036 /**
1037  * @brief Computer routing params.
1038  * @return True/false to be successful/failed to computer params.
1039  */
ComputeRoutingParams(int defaultPaymentType)1040 bool NfccNciAdapter::ComputeRoutingParams(int defaultPaymentType)
1041 {
1042     return RoutingManager::GetInstance().ComputeRoutingParams(defaultPaymentType);
1043 }
1044 
OnCardEmulationData(const std::vector<uint8_t> & data)1045 void NfccNciAdapter::OnCardEmulationData(const std::vector<uint8_t> &data)
1046 {
1047     DebugLog("NfccNciAdapter::OnCardEmulationData");
1048     cardEmulationListener_.lock()->OnCardEmulationData(data);
1049 }
1050 
OnCardEmulationActivated()1051 void NfccNciAdapter::OnCardEmulationActivated()
1052 {
1053     DebugLog("NfccNciAdapter::OnCardEmulationActivated");
1054     cardEmulationListener_.lock()->OnCardEmulationActivated();
1055 }
OnCardEmulationDeactivated()1056 void  NfccNciAdapter::OnCardEmulationDeactivated()
1057 {
1058     DebugLog("NfccNciAdapter::OnCardEmulationDeactivated");
1059     cardEmulationListener_.lock()->OnCardEmulationDeactivated();
1060 }
1061 }  // namespace NCI
1062 }  // namespace NFC
1063 }  // namespace OHOS
1064