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 #include "tag_nci_adapter_ntf.h"
16 #include "tag_nci_adapter_common.h"
17 #include "tag_nci_adapter_rw.h"
18 #include <unistd.h>
19 #include "nfc_brcm_defs.h"
20 #include "nfc_config.h"
21 #include "nfc_sdk_common.h"
22 #include "nfcc_nci_adapter.h"
23 #include "loghelper.h"
24 #include "nfa_api.h"
25 #include "rw_int.h"
26 #include "securec.h"
27 #include "tag_native_impl.h"
28 
29 namespace OHOS {
30 namespace NFC {
31 namespace NCI {
32 static const uint32_t POS_NFCF_STSTEM_CODE_HIGH = 8;
33 static const uint32_t POS_NFCF_STSTEM_CODE_LOW = 9;
34 static const uint32_t TOPAZ512_MAX_MESSAGE_SIZE = 462;
35 static const uint32_t TOPAZ96_MAX_MESSAGE_SIZE = 90;
36 static const uint32_t SENSF_RES_LENGTH = 8;
37 static const uint32_t SENS_RES_LENGTH = 2;
38 static const uint32_t SENSB_RES_POLL_POS = 4;
39 static const uint32_t SYSTEM_CODE_SHIFT = 8;
40 static const uint32_t F_POLL_LENGTH = 10;
41 static const uint32_t I93_POLL_LENGTH = 2;
42 static const uint32_t I93_ACT_LENGTH = 2;
43 static const uint32_t INVALID_TAG_INDEX = 0xFF;
44 static const uint32_t TIME_MUL_100MS = 100; // ms
45 static const uint8_t MIN_FWI = 0;  // min waiting time integer for protocol frame
46 static const uint8_t MAX_FWI = 14; // max waiting time integer for protocol frame
47 static const uint8_t NON_STD_CARD_SAK = 0x13;
48 
49 #define g_commonMultiTagDiscId (TagNciAdapterCommon::GetInstance().multiTagDiscId_)
50 #define g_commonMultiTagDiscProtocol (TagNciAdapterCommon::GetInstance().multiTagDiscProtocol_)
51 #define g_commonTechListIndex (TagNciAdapterCommon::GetInstance().techListIndex_)
52 #define g_commonMultiTagTmpTechIdx (TagNciAdapterCommon::GetInstance().multiTagTmpTechIdx_)
53 #define g_commonDiscRstEvtNum (TagNciAdapterCommon::GetInstance().discRstEvtNum_)
54 #define g_commonSelectedTagIdx (TagNciAdapterCommon::GetInstance().selectedTagIdx_)
55 #define g_commonConnectedProtocol (TagNciAdapterCommon::GetInstance().connectedProtocol_)
56 #define g_commonIsLegacyMifareReader (TagNciAdapterCommon::GetInstance().isLegacyMifareReader_)
57 #define g_commonIsNdefReadTimeOut (TagNciAdapterCommon::GetInstance().isNdefReadTimeOut_)
58 #define g_commonReconnectEvent (TagNciAdapterCommon::GetInstance().reconnectEvent_)
59 #define g_commonIsReconnecting (TagNciAdapterCommon::GetInstance().isReconnecting_)
60 #define g_commonIsSwitchingRfIface (TagNciAdapterCommon::GetInstance().isSwitchingRfIface_)
61 #define g_commonIsIsoDepDhReqFailed (TagNciAdapterCommon::GetInstance().isIsoDepDhReqFailed_)
62 #define g_commonConnectedTechIdx (TagNciAdapterCommon::GetInstance().connectedTechIdx_)
63 #define g_commonIsReconnected (TagNciAdapterCommon::GetInstance().isReconnected_)
64 #define g_commonReadNdefData (TagNciAdapterCommon::GetInstance().readNdefData_)
65 #define g_commonReadNdefEvent (TagNciAdapterCommon::GetInstance().readNdefEvent_)
66 #define g_commonIsNdefReading (TagNciAdapterCommon::GetInstance().isNdefReading_)
67 #define g_commonT1tMaxMessageSize (TagNciAdapterCommon::GetInstance().t1tMaxMessageSize_)
68 #define g_commonIsNdefWriteSuccess (TagNciAdapterCommon::GetInstance().isNdefWriteSuccess_)
69 #define g_commonWriteNdefEvent (TagNciAdapterCommon::GetInstance().writeNdefEvent_)
70 #define g_commonFormatNdefEvent (TagNciAdapterCommon::GetInstance().formatNdefEvent_)
71 #define g_commonIsNdefFormatSuccess (TagNciAdapterCommon::GetInstance().isNdefFormatSuccess_)
72 #define g_commonSelectEvent (TagNciAdapterCommon::GetInstance().selectEvent_)
73 #define g_commonSetReadOnlyEvent (TagNciAdapterCommon::GetInstance().setReadOnlyEvent_)
74 #define g_commonConnectedType (TagNciAdapterCommon::GetInstance().connectedType_)
75 #define g_commonConnectedRfIface (TagNciAdapterCommon::GetInstance().connectedRfIface_)
76 #define g_commonNfcID0 (TagNciAdapterCommon::GetInstance().nfcID0_)
77 
TagNciAdapterNtf()78 TagNciAdapterNtf::TagNciAdapterNtf()
79 {
80     if (NfcConfig::hasKey(NAME_NXP_NON_STD_CARD_TIMEDIFF)) {
81         std::vector<uint8_t> nonStdTimeDiff = NfcConfig::getBytes(NAME_NXP_NON_STD_CARD_TIMEDIFF);
82         for (uint8_t i = 0; i < nonStdTimeDiff.size(); i++) {
83             multiTagTimeDiff_.push_back(nonStdTimeDiff.at(i) * TIME_MUL_100MS);
84             DebugLog("TagNciAdapterNtf::TagNciAdapterNtf: timediff[%{public}d] = %{public}d", i, nonStdTimeDiff.at(i));
85         }
86     } else {
87         DebugLog("TagNciAdapterNtf::TagNciAdapterNtf:timediff not configured, use default");
88         multiTagTimeDiff_.push_back(100); // default time diff for Mifare Tag
89         multiTagTimeDiff_.push_back(300); // default time diff for ISODEP
90     }
91 #if (NXP_EXTNS == TRUE)
92     errno_t err = memset_s(&g_multiTagParams, sizeof(g_multiTagParams), 0, sizeof(g_multiTagParams));
93     if (err != EOK) {
94         ErrorLog("TagNciAdapterNtf::TagNciAdapterNtf:memset_s for g_multiTagParams error: %{public}d", err);
95     }
96 #endif
97 }
98 
~TagNciAdapterNtf()99 TagNciAdapterNtf::~TagNciAdapterNtf()
100 {
101     g_commonConnectedProtocol = NCI_PROTOCOL_UNKNOWN;
102     isSkipMifareActive_ = false;
103 };
104 
GetInstance()105 TagNciAdapterNtf& TagNciAdapterNtf::GetInstance()
106 {
107     static TagNciAdapterNtf tagNciAdapterNtf;
108     return tagNciAdapterNtf;
109 }
110 
DoNfaNdefRegisterEvt(tNFA_NDEF_EVT_DATA * eventData)111 void TagNciAdapterNtf::DoNfaNdefRegisterEvt(tNFA_NDEF_EVT_DATA* eventData)
112 {
113     DebugLog("NdefCallback: NFA_NDEF_REGISTER_EVT; status=0x%{public}X; handle=0x%{public}X",
114         eventData->ndef_reg.status, eventData->ndef_reg.ndef_type_handle);
115     ndefTypeHandle_ = eventData->ndef_reg.ndef_type_handle;
116 }
117 
DoNfaNdefDataEvt(tNFA_NDEF_EVT_DATA * eventData)118 void TagNciAdapterNtf::DoNfaNdefDataEvt(tNFA_NDEF_EVT_DATA* eventData)
119 {
120     DebugLog("NdefCallback: NFA_NDEF_DATA_EVT; data_len = %u", eventData->ndef_data.len);
121     uint32_t ndefDataLen = eventData->ndef_data.len;
122     g_commonReadNdefData = KITS::NfcSdkCommon::BytesVecToHexString(
123         eventData->ndef_data.p_data, ndefDataLen);
124 }
125 
NdefCallback(unsigned char event,tNFA_NDEF_EVT_DATA * eventData)126 void TagNciAdapterNtf::NdefCallback(unsigned char event, tNFA_NDEF_EVT_DATA* eventData)
127 {
128     DebugLog("TagNciAdapterNtf::NdefCallback");
129     switch (event) {
130         case NFA_NDEF_REGISTER_EVT: {
131             TagNciAdapterNtf::GetInstance().DoNfaNdefRegisterEvt(eventData);
132             break;
133         }
134         case NFA_NDEF_DATA_EVT: {
135             TagNciAdapterNtf::GetInstance().DoNfaNdefDataEvt(eventData);
136             break;
137         }
138         default: {
139             ErrorLog("%{public}s: Unknown event %{public}u", "NdefCallback", event);
140             break;
141         }
142     }
143 }
144 
RegisterNdefHandler()145 void TagNciAdapterNtf::RegisterNdefHandler()
146 {
147     DebugLog("TagNciAdapterNtf::RegisterNdefHandler");
148     ndefTypeHandle_ = NFA_HANDLE_INVALID;
149     NFA_RegisterNDefTypeHandler(true,
150                                 NFA_TNF_DEFAULT,
151                                 reinterpret_cast<uint8_t*>(const_cast<char*>("")),
152                                 0, NdefCallback);
153     if (g_commonIsLegacyMifareReader) {
154         Extns::GetInstance().EXTNS_MfcRegisterNDefTypeHandler(NdefCallback);
155     }
156 }
157 
IsReconnecting()158 bool TagNciAdapterNtf::IsReconnecting()
159 {
160     return g_commonIsReconnecting;
161 }
162 
SetCurrRfInterface(uint32_t rfInterface)163 void TagNciAdapterNtf::SetCurrRfInterface(uint32_t rfInterface)
164 {
165     g_commonConnectedRfIface = rfInterface;
166 }
167 
SetCurrRfProtocol(uint32_t protocol)168 void TagNciAdapterNtf::SetCurrRfProtocol(uint32_t protocol)
169 {
170     g_commonConnectedProtocol = protocol;
171 }
172 
SetCurrRfMode(uint8_t type)173 void TagNciAdapterNtf::SetCurrRfMode(uint8_t type)
174 {
175     if (type == NFC_DISCOVERY_TYPE_POLL_A || type == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) {
176         g_commonConnectedType = TagNciAdapterCommon::TARGET_TYPE_ISO14443_3A;
177     } else if (type == NFC_DISCOVERY_TYPE_POLL_B || type == NFC_DISCOVERY_TYPE_POLL_B_PRIME) {
178         g_commonConnectedType = TagNciAdapterCommon::TARGET_TYPE_ISO14443_3B;
179     }
180 }
181 
IsSwitchingRfIface()182 bool TagNciAdapterNtf::IsSwitchingRfIface()
183 {
184     return g_commonIsSwitchingRfIface;
185 }
186 
IsExpectedActRfProtocol(uint32_t protocol)187 bool TagNciAdapterNtf::IsExpectedActRfProtocol(uint32_t protocol)
188 {
189     InfoLog("IsExpectedActRfProtocol: currentProtocol = %{public}d, targetProtocol = %{public}d",
190             g_commonConnectedProtocol, protocol);
191     if (g_commonConnectedProtocol != NFC_PROTOCOL_UNKNOWN && g_commonConnectedProtocol != protocol) {
192         NFA_Deactivate(false);
193         return false;
194     }
195     return true;
196 }
197 
HandleSelectResult(uint8_t status)198 void TagNciAdapterNtf::HandleSelectResult(uint8_t status)
199 {
200     DebugLog("TagNciAdapterNtf::HandleSelectResult");
201     {
202         NFC::SynchronizeGuard guard(g_commonSelectEvent);
203         g_commonSelectEvent.NotifyOne();
204     }
205     if (status != NFA_STATUS_OK) {
206         if (g_commonIsSwitchingRfIface) {
207             SetConnectStatus(false);
208         }
209         ErrorLog("TagNciAdapterNtf::HandleSelectResult error: %{public}d", status);
210         NFA_Deactivate(false);
211     }
212 }
213 
ClearNonStdTagData()214 void TagNciAdapterNtf::ClearNonStdTagData()
215 {
216     InfoLog("ClearNonStdTagData");
217     errno_t err = memset_s(&g_multiTagParams, sizeof(g_multiTagParams), 0, sizeof(g_multiTagParams));
218     if (err != EOK) {
219         ErrorLog("TagNciAdapterNtf::ClearNonStdTagData:memset_s for g_multiTagParams error: %{public}d", err);
220     }
221 }
222 
SetNonStdTagData()223 void TagNciAdapterNtf::SetNonStdTagData()
224 {
225     // skipped detecte time calculation
226     tNFC_RESULT_DEVT& info = g_multiTagParams.discNtf;
227     info.rf_disc_id = TagNciAdapterCommon::GetInstance().tagRfDiscIdList_[g_commonSelectedTagIdx];
228     info.protocol = TagNciAdapterCommon::GetInstance().tagRfProtocols_[g_commonSelectedTagIdx];
229     InfoLog("SetNonStdTagData: disc id: %{public}d", info.rf_disc_id);
230 }
231 
HandleActivatedResult(tNFA_CONN_EVT_DATA * eventData)232 void TagNciAdapterNtf::HandleActivatedResult(tNFA_CONN_EVT_DATA* eventData)
233 {
234     if (eventData->activated.activate_ntf.rf_tech_param.mode >= NCI_DISCOVERY_TYPE_LISTEN_A || //not poll mode
235         eventData->activated.activate_ntf.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF) {     // is EE direct rf
236         return;
237     }
238     tNFA_ACTIVATED& activated = eventData->activated;
239 #if (NXP_EXTNS == TRUE)
240     if (TagNciAdapterCommon::GetInstance().isMultiTag_) {
241         InfoLog("TagNciAdapterNtf::HandleActivatedResult: copy nonstd tag data");
242         ClearNonStdTagData();
243         errno_t err = EOK;
244         err = memcpy_s(&g_multiTagParams.discNtf.rf_tech_param, sizeof(tNFC_RF_TECH_PARAMS),
245                        &activated.activate_ntf.rf_tech_param, sizeof(tNFC_RF_TECH_PARAMS));
246         if (err != EOK) {
247             ErrorLog("TagNciAdapterNtf::HandleActivatedResult, memcpy rf_tech_param error: %{public}d", err);
248         }
249         err = memcpy_s(&g_multiTagParams.intfParam, sizeof(tNFC_INTF_PARAMS),
250                        &activated.activate_ntf.intf_param, sizeof(tNFC_INTF_PARAMS));
251         if (err != EOK) {
252             ErrorLog("TagNciAdapterNtf::HandleActivatedResult, memcpy intfParam error: %{public}d", err);
253         }
254     }
255 #endif
256     // skipped  same kovio detection
257     g_commonConnectedProtocol = activated.activate_ntf.protocol;
258     g_commonT1tMaxMessageSize = GetT1tMaxMessageSize(activated);
259     GetTechFromData(activated);
260     BuildTagInfo(activated);
261 }
262 
SetConnectStatus(bool isStatusOk)263 void TagNciAdapterNtf::SetConnectStatus(bool isStatusOk)
264 {
265     DebugLog("TagNciAdapterNtf::SetConnectStatus");
266     if (Extns::GetInstance().EXTNS_GetConnectFlag() && g_commonIsLegacyMifareReader) {
267         DebugLog("TagNciAdapterNtf::SetConnectStatus: ExtnsMfcActivated");
268         Extns::GetInstance().EXTNS_MfcActivated();
269         Extns::GetInstance().EXTNS_SetConnectFlag(false);
270     }
271     if (g_commonIsReconnecting) {
272         g_commonIsReconnected = isStatusOk;
273         g_commonIsReconnecting = false;
274         NFC::SynchronizeGuard guard(g_commonReconnectEvent);
275         g_commonReconnectEvent.NotifyOne();
276     }
277 }
278 
SetNfcID0ForTypeB(uint8_t * nfcID0)279 void TagNciAdapterNtf::SetNfcID0ForTypeB(uint8_t* nfcID0)
280 {
281     int nfcId0Len = 4;
282     int err = memcpy_s(g_commonNfcID0, nfcId0Len, &nfcID0[0], nfcId0Len);
283     if (err != 0) {
284         ErrorLog("TagNciAdapterNtf::SetNfcID0ForTypeB: memcpy_s error: %{public}d", err);
285     }
286 }
287 
SetDeactivatedStatus()288 void TagNciAdapterNtf::SetDeactivatedStatus()
289 {
290     if (Extns::GetInstance().EXTNS_GetDeactivateFlag() &&
291         g_commonIsLegacyMifareReader) {
292         DebugLog("TagNciAdapterNtf::SetDeactivatedStatus mifare deactivate");
293         Extns::GetInstance().EXTNS_MfcDisconnect();
294         Extns::GetInstance().EXTNS_SetDeactivateFlag(false);
295     }
296     {
297         NFC::SynchronizeGuard guard(g_commonReconnectEvent);
298         g_commonReconnectEvent.NotifyOne();
299     }
300 }
301 
HandleSetReadOnlyResult(tNFA_STATUS status)302 void TagNciAdapterNtf::HandleSetReadOnlyResult(tNFA_STATUS status)
303 {
304     NFC::SynchronizeGuard guard(g_commonSetReadOnlyEvent);
305     g_commonSetReadOnlyEvent.NotifyOne();
306 }
307 
HandleReadComplete(uint8_t status)308 void TagNciAdapterNtf::HandleReadComplete(uint8_t status)
309 {
310     DebugLog("TagNciAdapterNtf::HandleReadComplete, g_commonIsNdefReading = %{public}d", g_commonIsNdefReading);
311     if (!g_commonIsNdefReading) {
312         return;
313     }
314     NFC::SynchronizeGuard guard(g_commonReadNdefEvent);
315     if (status != NFA_STATUS_OK) {
316         ErrorLog("Read ndef fail");
317         g_commonIsNdefReadTimeOut = true;
318         g_commonReadNdefData = "";
319     }
320     g_commonReadNdefEvent.NotifyOne();
321 }
322 
HandleWriteComplete(uint8_t status)323 void TagNciAdapterNtf::HandleWriteComplete(uint8_t status)
324 {
325     DebugLog("TagNciAdapterNtf::HandleWriteComplete");
326     NFC::SynchronizeGuard guard(g_commonWriteNdefEvent);
327     g_commonIsNdefWriteSuccess = (status == NFA_STATUS_OK);
328     g_commonWriteNdefEvent.NotifyOne();
329 }
330 
HandleFormatComplete(uint8_t status)331 void TagNciAdapterNtf::HandleFormatComplete(uint8_t status)
332 {
333     DebugLog("TagNciAdapterNtf::HandleFormatComplete");
334     NFC::SynchronizeGuard guard(g_commonFormatNdefEvent);
335     g_commonIsNdefFormatSuccess = (status == NFA_STATUS_OK);
336     g_commonFormatNdefEvent.NotifyOne();
337 }
338 
IsDiscTypeA(uint8_t discType) const339 bool TagNciAdapterNtf::IsDiscTypeA(uint8_t discType) const
340 {
341     if (discType == NCI_DISCOVERY_TYPE_POLL_A) {
342         return true;
343     }
344     if (discType == NCI_DISCOVERY_TYPE_POLL_A_ACTIVE) {
345         return true;
346     }
347     if (discType == NCI_DISCOVERY_TYPE_LISTEN_A) {
348         return true;
349     }
350     if (discType == NCI_DISCOVERY_TYPE_LISTEN_A_ACTIVE) {
351         return true;
352     }
353     return false;
354 }
355 
IsDiscTypeB(uint8_t discType) const356 bool TagNciAdapterNtf::IsDiscTypeB(uint8_t discType) const
357 {
358     if (discType == NCI_DISCOVERY_TYPE_POLL_B) {
359         return true;
360     }
361     if (discType == NFC_DISCOVERY_TYPE_POLL_B_PRIME) {
362         return true;
363     }
364     if (discType == NCI_DISCOVERY_TYPE_LISTEN_B) {
365         return true;
366     }
367     if (discType == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) {
368         return true;
369     }
370     return false;
371 }
372 
IsDiscTypeF(uint8_t discType) const373 bool TagNciAdapterNtf::IsDiscTypeF(uint8_t discType) const
374 {
375     if (discType == NCI_DISCOVERY_TYPE_POLL_F) {
376         return true;
377     }
378     if (discType == NCI_DISCOVERY_TYPE_POLL_F_ACTIVE) {
379         return true;
380     }
381     if (discType == NCI_DISCOVERY_TYPE_LISTEN_F) {
382         return true;
383     }
384     if (discType == NCI_DISCOVERY_TYPE_LISTEN_F_ACTIVE) {
385         return true;
386     }
387     return false;
388 }
389 
IsDiscTypeV(uint8_t discType) const390 bool TagNciAdapterNtf::IsDiscTypeV(uint8_t discType) const
391 {
392     if (discType == NCI_DISCOVERY_TYPE_POLL_V) {
393         return true;
394     }
395     if (discType == NCI_DISCOVERY_TYPE_LISTEN_ISO15693) {
396         return true;
397     }
398     return false;
399 }
400 
IsMifareUL(tNFA_ACTIVATED activated)401 bool TagNciAdapterNtf::IsMifareUL(tNFA_ACTIVATED activated)
402 {
403     // can also be mifare
404     if (activated.activate_ntf.rf_tech_param.param.pa.nfcid1[0] == MANUFACTURER_ID_NXP &&
405         (activated.activate_ntf.rf_tech_param.param.pa.sel_rsp == SAK_MIFARE_UL_1 ||
406         activated.activate_ntf.rf_tech_param.param.pa.sel_rsp == SAK_MIFARE_UL_2)) {
407         InfoLog("TagNciAdapterNtf::GetTechFromData: MifareUltralight");
408         return true;
409     }
410     return false;
411 }
412 
SetIsoDepFwt(tNFA_ACTIVATED activated,uint32_t technology)413 void TagNciAdapterNtf::SetIsoDepFwt(tNFA_ACTIVATED activated, uint32_t technology)
414 {
415     if ((activated.activate_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) ||
416         (activated.activate_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE)) {
417         // get frame Waiting time Integer(fwi) from activated data
418         uint8_t fwi = activated.activate_ntf.intf_param.intf_param.pa_iso.fwi;
419         if (fwi <= MAX_FWI) {
420             // 2^MIN_FWI * 256 * 16 * 1000 / 13560000 is approximately 618
421             int fwt = (1 << (fwi - MIN_FWI)) * 618;
422             InfoLog("TagNciAdapterNtf::GetTechFromData timeout = %{public}d, fwi = %{public}0#x", fwt, fwi);
423             TagNciAdapterRw::GetInstance().SetTimeout(fwt, technology);
424         }
425     }
426 }
427 
GetTechFromData(tNFA_ACTIVATED activated)428 void TagNciAdapterNtf::GetTechFromData(tNFA_ACTIVATED activated)
429 {
430     uint32_t tech[MAX_NUM_TECHNOLOGY];
431     if (activated.activate_ntf.protocol == NCI_PROTOCOL_T1T) {
432         tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_ISO14443_3A;
433     } else if (activated.activate_ntf.protocol == NCI_PROTOCOL_T2T) {
434         tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_ISO14443_3A;
435         if (IsMifareUL(activated)) {
436             g_commonTechListIndex++;
437             tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_MIFARE_UL;
438         }
439 #if (NXP_EXTNS == TRUE)
440     } else if (activated.activate_ntf.protocol == NCI_PROTOCOL_T3BT) {
441         tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_ISO14443_3B;
442     } else if (activated.activate_ntf.protocol == NCI_PROTOCOL_T3T) {
443 #else
444     } else if (activated.activate_ntf.protocol == NCI_PROTOCOL_T3T) {
445 #endif
446         tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_FELICA;
447     } else if (activated.activate_ntf.protocol == NCI_PROTOCOL_ISO_DEP) {
448         tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_ISO14443_4;
449         SetIsoDepFwt(activated, tech[g_commonTechListIndex]);
450         // A OR B
451         uint8_t discType = activated.activate_ntf.rf_tech_param.mode;
452         if (IsDiscTypeA(discType)) {
453             g_commonTechListIndex++;
454             tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_ISO14443_3A;
455         } else if (IsDiscTypeB(discType)) {
456             g_commonTechListIndex++;
457             tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_ISO14443_3B;
458         }
459     } else if (activated.activate_ntf.protocol == NCI_PROTOCOL_15693) {
460         tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_V;
461     } else if (activated.activate_ntf.protocol == NFC_PROTOCOL_MIFARE) {
462         InfoLog("TagNciAdapterNtf::GetTechFromData: MifareClassic");
463         Extns::GetInstance().EXTNS_MfcInit(activated);
464         tech[g_commonTechListIndex++] = TagNciAdapterCommon::TARGET_TYPE_ISO14443_3A;
465         tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_MIFARE_CLASSIC;
466     } else {
467         tech[g_commonTechListIndex] = TagNciAdapterCommon::TARGET_TYPE_UNKNOWN;
468     }
469     g_commonTechListIndex++;
470 
471     uint32_t tagRfDiscId = activated.activate_ntf.rf_disc_id;
472     uint32_t tagNtfProtocol = activated.activate_ntf.protocol;
473     for (uint32_t i = g_commonMultiTagTmpTechIdx; i < g_commonTechListIndex; i++) {
474         TagNciAdapterCommon::GetInstance().tagTechList_.push_back(tech[i]);
475         TagNciAdapterCommon::GetInstance().tagRfDiscIdList_.push_back(tagRfDiscId);
476         TagNciAdapterCommon::GetInstance().tagRfProtocols_.push_back(tagNtfProtocol);
477         InfoLog("GetTechFromData: index = %{public}d, tech = %{public}d, RfDiscId = %{public}d, "
478             "protocol = %{public}d", i, tech[i], tagRfDiscId, tagNtfProtocol);
479     }
480 }
481 
GetUidFromData(tNFA_ACTIVATED activated) const482 std::string TagNciAdapterNtf::GetUidFromData(tNFA_ACTIVATED activated) const
483 {
484     std::string uid;
485     tNFC_RF_TECH_PARAMS nfcRfTechParams = activated.activate_ntf.rf_tech_param;
486     uint8_t discType = nfcRfTechParams.mode;
487     if (IsDiscTypeA(discType)) {
488         uint32_t nfcid1Len = nfcRfTechParams.param.pa.nfcid1_len;
489         uid = KITS::NfcSdkCommon::BytesVecToHexString(nfcRfTechParams.param.pa.nfcid1, nfcid1Len);
490     } else if (IsDiscTypeB(discType)) {
491         if (activated.activate_ntf.protocol == NFA_PROTOCOL_T3BT) {
492             uid = KITS::NfcSdkCommon::BytesVecToHexString(nfcRfTechParams.param.pb.pupiid, NFC_PUPIID_MAX_LEN);
493         } else {
494             uid = KITS::NfcSdkCommon::BytesVecToHexString(nfcRfTechParams.param.pb.nfcid0, NFC_NFCID0_MAX_LEN);
495         }
496     } else if (IsDiscTypeF(discType)) {
497         uid = KITS::NfcSdkCommon::BytesVecToHexString(nfcRfTechParams.param.pf.nfcid2, NFC_NFCID2_LEN);
498     } else if (IsDiscTypeV(discType)) {
499         uint8_t* i93Uid = activated.params.i93.uid;
500         uint8_t i93UidReverse[I93_UID_BYTE_LEN];
501         for (uint32_t i = 0; i < I93_UID_BYTE_LEN; i++) {
502             i93UidReverse[i] = i93Uid[I93_UID_BYTE_LEN - i - 1];
503         }
504         uid = KITS::NfcSdkCommon::BytesVecToHexString(i93UidReverse, I93_UID_BYTE_LEN);
505     } else {
506         uid = "";
507     }
508     return uid;
509 }
510 
GetTechPollForTypeB(tNFC_RF_TECH_PARAMS nfcRfTechParams,uint32_t tech)511 std::string TagNciAdapterNtf::GetTechPollForTypeB(tNFC_RF_TECH_PARAMS nfcRfTechParams, uint32_t tech)
512 {
513     std::string techPoll = "";
514     if (tech == TagNciAdapterCommon::TARGET_TYPE_ISO14443_3B) {
515         uint32_t length = nfcRfTechParams.param.pb.sensb_res_len;
516         if (length > NFC_NFCID0_MAX_LEN) {
517             length = length - NFC_NFCID0_MAX_LEN;
518         } else {
519             WarnLog("sensb_res_len %{public}d error", length);
520             length = 0;
521         }
522         techPoll = KITS::NfcSdkCommon::BytesVecToHexString(
523             nfcRfTechParams.param.pb.sensb_res + SENSB_RES_POLL_POS, length);
524     }
525     return techPoll;
526 }
527 
GetTechPollFromData(tNFA_ACTIVATED activated)528 void TagNciAdapterNtf::GetTechPollFromData(tNFA_ACTIVATED activated)
529 {
530     std::string techPoll = "";
531     tNFC_RF_TECH_PARAMS nfcRfTechParams = activated.activate_ntf.rf_tech_param;
532     uint8_t discType = nfcRfTechParams.mode;
533     for (uint32_t i = g_commonMultiTagTmpTechIdx; i < g_commonTechListIndex; i++) {
534         if (IsDiscTypeA(discType)) {
535             techPoll = KITS::NfcSdkCommon::BytesVecToHexString(
536                 nfcRfTechParams.param.pa.sens_res, SENS_RES_LENGTH);
537         } else if (IsDiscTypeB(discType)) {
538             techPoll = GetTechPollForTypeB(nfcRfTechParams, TagNciAdapterCommon::GetInstance().tagTechList_[i]);
539         } else if (IsDiscTypeF(discType)) {
540             uint8_t fTechPoll[F_POLL_LENGTH];
541             uint8_t *sensfRes = nfcRfTechParams.param.pf.sensf_res;
542 
543             // save the pmm value.
544             for (uint32_t j = 0; j < SENSF_RES_LENGTH; j++) {
545                 fTechPoll[j] = static_cast<uint8_t>(sensfRes[j + SENSF_RES_LENGTH]);
546             }
547 
548             // save the system code.
549             if (activated.params.t3t.num_system_codes > 0) {
550                 unsigned short *pSystemCodes = activated.params.t3t.p_system_codes;
551                 fTechPoll[POS_NFCF_STSTEM_CODE_HIGH] =
552                     static_cast<uint8_t>(*pSystemCodes >> SYSTEM_CODE_SHIFT);
553                 fTechPoll[POS_NFCF_STSTEM_CODE_LOW] = static_cast<uint8_t>(*pSystemCodes);
554             }
555             techPoll = KITS::NfcSdkCommon::BytesVecToHexString(fTechPoll, F_POLL_LENGTH);
556         } else if (IsDiscTypeV(discType)) {
557             uint8_t vTechPoll[2] = {activated.params.i93.afi, activated.params.i93.dsfid};
558             techPoll = KITS::NfcSdkCommon::BytesVecToHexString(vTechPoll, I93_POLL_LENGTH);
559         } else {
560             techPoll = "";
561         }
562         TagNciAdapterCommon::GetInstance().tagPollBytes_.push_back(techPoll);
563     }
564 }
565 
GetTechActForIsoDep(tNFA_ACTIVATED activated,tNFC_RF_TECH_PARAMS nfcRfTechParams,uint32_t tech) const566 std::string TagNciAdapterNtf::GetTechActForIsoDep(tNFA_ACTIVATED activated,
567     tNFC_RF_TECH_PARAMS nfcRfTechParams, uint32_t tech) const
568 {
569     std::string techAct = "";
570     if (tech == TagNciAdapterCommon::TARGET_TYPE_ISO14443_4) {
571         uint8_t discType = nfcRfTechParams.mode;
572         if (IsDiscTypeA(discType)) {
573             if (activated.activate_ntf.intf_param.type == NFC_INTERFACE_ISO_DEP) {
574                 tNFC_INTF_PA_ISO_DEP paIso = activated.activate_ntf.intf_param.intf_param.pa_iso;
575                 techAct = (paIso.his_byte_len > 0) ? KITS::NfcSdkCommon::BytesVecToHexString(
576                     paIso.his_byte, paIso.his_byte_len) : "";
577             }
578         } else if (IsDiscTypeB(discType)) {
579             if (activated.activate_ntf.intf_param.type == NFC_INTERFACE_ISO_DEP) {
580                 tNFC_INTF_PB_ISO_DEP pbIso = activated.activate_ntf.intf_param.intf_param.pb_iso;
581                 techAct = (pbIso.hi_info_len > 0) ? KITS::NfcSdkCommon::BytesVecToHexString(
582                     pbIso.hi_info, pbIso.hi_info_len) : "";
583             }
584         }
585     } else if (tech == TagNciAdapterCommon::TARGET_TYPE_ISO14443_3A) {
586         techAct = KITS::NfcSdkCommon::UnsignedCharToHexString(nfcRfTechParams.param.pa.sel_rsp);
587     } else {
588         // do nothing
589     }
590     return techAct;
591 }
592 
GetTechActFromData(tNFA_ACTIVATED activated)593 void TagNciAdapterNtf::GetTechActFromData(tNFA_ACTIVATED activated)
594 {
595     uint8_t protocol = activated.activate_ntf.protocol;
596     tNFC_RF_TECH_PARAMS nfcRfTechParams = activated.activate_ntf.rf_tech_param;
597     for (uint32_t i = g_commonMultiTagTmpTechIdx; i < g_commonTechListIndex; i++) {
598         std::string techAct = "";
599         if (protocol == NCI_PROTOCOL_T1T) {
600             techAct = KITS::NfcSdkCommon::UnsignedCharToHexString(nfcRfTechParams.param.pa.sel_rsp);
601         } else if (protocol == NCI_PROTOCOL_T2T) {
602             techAct = KITS::NfcSdkCommon::UnsignedCharToHexString(nfcRfTechParams.param.pa.sel_rsp);
603         } else if (protocol == NCI_PROTOCOL_T3T) {
604             techAct = "";
605         } else if (protocol == NCI_PROTOCOL_ISO_DEP) {
606             techAct = GetTechActForIsoDep(activated, nfcRfTechParams,
607                 TagNciAdapterCommon::GetInstance().tagTechList_[i]);
608         } else if (protocol == NCI_PROTOCOL_15693) {
609             uint8_t techActivated[2] = {activated.params.i93.afi, activated.params.i93.dsfid};
610             techAct = KITS::NfcSdkCommon::BytesVecToHexString(techActivated, I93_ACT_LENGTH);
611         } else if (protocol == NFC_PROTOCOL_MIFARE) {
612             techAct = KITS::NfcSdkCommon::UnsignedCharToHexString(nfcRfTechParams.param.pa.sel_rsp);
613         } else {
614             // do nothing
615         }
616         TagNciAdapterCommon::GetInstance().tagActivatedBytes_.push_back(techAct);
617     }
618 }
619 
ParseSpecTagType(tNFA_ACTIVATED activated)620 void TagNciAdapterNtf::ParseSpecTagType(tNFA_ACTIVATED activated)
621 {
622     // parse for FelicaLite
623     if (activated.activate_ntf.protocol == NFC_PROTOCOL_T3T) {
624         uint32_t i = 0;
625         while (i < activated.params.t3t.num_system_codes) {
626             if (activated.params.t3t.p_system_codes[i++] == T3T_SYSTEM_CODE_FELICA_LITE) {
627                 TagNciAdapterCommon::GetInstance().isFelicaLite_ = true;
628                 break;
629             }
630         }
631     }
632     // parse for MifareUltralight, NFC Digital Protocol, see SENS_RES and SEL_RES
633     if (activated.activate_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) {
634         if ((activated.activate_ntf.rf_tech_param.param.pa.sens_res[0] == ATQA_MIFARE_UL_0) &&
635             (activated.activate_ntf.rf_tech_param.param.pa.sens_res[1] == ATQA_MIFARE_UL_1) &&
636             ((activated.activate_ntf.rf_tech_param.param.pa.sel_rsp == SAK_MIFARE_UL_1) ||
637             (activated.activate_ntf.rf_tech_param.param.pa.sel_rsp == SAK_MIFARE_UL_2)) &&
638             (activated.activate_ntf.rf_tech_param.param.pa.nfcid1[0] == MANUFACTURER_ID_NXP)) {
639             TagNciAdapterCommon::GetInstance().isMifareUltralight_ = true;
640         }
641     }
642 
643     // parse for MifareDESFire, one sak byte and 2 ATQA bytes
644     if ((activated.activate_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) ||
645         (activated.activate_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A) ||
646         (activated.activate_ntf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE)) {
647         if ((activated.activate_ntf.rf_tech_param.param.pa.sens_res[0] == ATQA_MIFARE_DESFIRE_0) &&
648             (activated.activate_ntf.rf_tech_param.param.pa.sens_res[1] == ATQA_MIFARE_DESFIRE_1) &&
649             (activated.activate_ntf.rf_tech_param.param.pa.sel_rsp == SAK_MIFARE_DESFIRE)) {
650             TagNciAdapterCommon::GetInstance().isMifareDESFire_ = true;
651         }
652     }
653     InfoLog("isFelicaLite_ = %{public}d, isMifareUltralight_ = %{public}d, isMifareDESFire_ = %{public}d",
654         TagNciAdapterCommon::GetInstance().isFelicaLite_, TagNciAdapterCommon::GetInstance().isMifareUltralight_,
655         TagNciAdapterCommon::GetInstance().isMifareDESFire_);
656 }
657 
BuildTagInfo(tNFA_ACTIVATED activated)658 void TagNciAdapterNtf::BuildTagInfo(tNFA_ACTIVATED activated)
659 {
660     DebugLog("TagNciAdapterNtf::BuildTagInfo, g_commonDiscRstEvtNum = %{public}d", g_commonDiscRstEvtNum);
661     std::string tagUid = GetUidFromData(activated);
662     GetTechPollFromData(activated);
663     GetTechActFromData(activated);
664     ParseSpecTagType(activated);
665 
666     if (g_commonDiscRstEvtNum == 0) {
667         g_commonMultiTagTmpTechIdx = 0;
668         std::shared_ptr<NCI::TagHost> tagHost = std::make_shared<NCI::TagHost>(
669             TagNciAdapterCommon::GetInstance().tagTechList_,
670             TagNciAdapterCommon::GetInstance().tagRfDiscIdList_,
671             TagNciAdapterCommon::GetInstance().tagRfProtocols_, tagUid,
672             TagNciAdapterCommon::GetInstance().tagPollBytes_,
673             TagNciAdapterCommon::GetInstance().tagActivatedBytes_,
674             g_commonConnectedTechIdx);
675         TagNativeImpl::GetInstance().OnTagDiscovered(TagNciAdapterCommon::GetInstance().tagRfDiscIdList_[0], tagHost);
676     } else {
677         g_commonMultiTagTmpTechIdx = g_commonTechListIndex;
678         InfoLog("TagNciAdapterNtf::BuildTagInfo, select next tag if exists");
679     }
680     InfoLog("TagNciAdapterNtf::BuildTagInfo, g_commonMultiTagTmpTechIdx = %{public}d,"
681         "g_commonTechListIndex = %{public}d", g_commonMultiTagTmpTechIdx, g_commonTechListIndex);
682 }
683 
IsTagDetectedInTimeDiff(uint32_t timeDiff)684 bool TagNciAdapterNtf::IsTagDetectedInTimeDiff(uint32_t timeDiff)
685 {
686     return true;
687 }
688 
ClearMultiMFCTagState()689 void TagNciAdapterNtf::ClearMultiMFCTagState()
690 {
691     TagNciAdapterCommon::GetInstance().ClearMultiMFCTagState();
692 }
693 
SetMultiTagData(tNFC_RESULT_DEVT & discNtf)694 void TagNciAdapterNtf::SetMultiTagData(tNFC_RESULT_DEVT& discNtf)
695 {
696     if (discNtf.rf_tech_param.param.pa.sel_rsp == NON_STD_CARD_SAK) {
697         InfoLog("TagNciAdapterNtf::SetMultiTagData: sak 13 tag detechted, set protocol to ISODEP");
698         g_commonMultiTagDiscProtocol[g_commonDiscRstEvtNum] = NFC_PROTOCOL_ISO_DEP;
699         return;
700     }
701     if (discNtf.protocol == NFC_PROTOCOL_MIFARE) {
702         if (TagNciAdapterCommon::GetInstance().isMultiProtoMFC_ &&
703             IsTagDetectedInTimeDiff(multiTagTimeDiff_[0])) { // 0 for Mifare
704             TagNciAdapterCommon::GetInstance().isSkipNdefRead_ = true;
705         } else {
706             ClearMultiMFCTagState();
707         }
708     } else if (discNtf.protocol == NFC_PROTOCOL_ISO_DEP) {
709         if (g_commonIsIsoDepDhReqFailed && IsTagDetectedInTimeDiff(multiTagTimeDiff_[1])) { // 1 for ISODEP
710             g_multiTagParams.isSkipIsoDepAct = true;
711         } else {
712             ClearMultiMFCTagState();
713         }
714     } else if (discNtf.more == NCI_DISCOVER_NTF_LAST) {
715         bool isMFCDetected = false;
716         for (uint32_t i = 0; i < g_commonTechListIndex; i++) {
717             if (TagNciAdapterCommon::GetInstance().tagRfProtocols_[i] == NFC_PROTOCOL_MIFARE) {
718                 isMFCDetected = true;
719             }
720         }
721         if (!isMFCDetected) {
722             ClearMultiMFCTagState();
723         }
724     }
725 }
726 
IsMultiTag(tNFC_RESULT_DEVT discoveryNtf,uint8_t * nfcID2,uint8_t nfcID2Len)727 void TagNciAdapterNtf::IsMultiTag(tNFC_RESULT_DEVT discoveryNtf, uint8_t *nfcID2, uint8_t nfcID2Len)
728 {
729     for (uint32_t i = 0; i < TagNciAdapterCommon::GetInstance().discNtfIndex_; i++) {
730         InfoLog("TagNciAdapterNtf::HandleDiscResult, index: %{public}d, discId: %{public}d, protocl: %{public}d",
731                 i, g_commonMultiTagDiscId[i], g_commonMultiTagDiscProtocol[i]);
732     }
733     if (discoveryNtf.rf_disc_id > 2) { // multitag has more than 2 uids
734         InfoLog("TagNciAdapterNtf::HandleDiscResult, this multiTag has more than 2 uids");
735     } else if (discoveryNtf.rf_disc_id == 2) { // this multiTag has 2 uids
736         if (memcmp(nfcID1_, nfcID2, sizeof(nfcID1_)) == 0) {
737             InfoLog("TagNciAdapterNtf::HandleDiscResult, this multiTag has 2 same uids");
738             TagNciAdapterCommon::GetInstance().isMultiTag_ = false;
739         } else {
740             InfoLog("TagNciAdapterNtf::HandleDiscResult, this multiTag has 2 different uids");
741         }
742     } else {
743         InfoLog("TagNciAdapterNtf::HandleDiscResult, this multiTag has 1 uid");
744     }
745 }
746 
747 /**
748  * @brief Parse rf discover ntf.
749  * @param eventData The rf discover ntf.
750  */
HandleDiscResult(tNFA_CONN_EVT_DATA * eventData)751 void TagNciAdapterNtf::HandleDiscResult(tNFA_CONN_EVT_DATA* eventData)
752 {
753     if (eventData == nullptr) {
754         WarnLog("HandleDiscResult invalid eventData.");
755         return;
756     }
757     if (eventData->disc_result.status != NFA_STATUS_OK) {
758         ErrorLog("TagNciAdapterNtf::HandleDiscResult, status error: %{public}d", eventData->disc_result.status);
759         return;
760     }
761     tNFC_RESULT_DEVT& discoveryNtf = eventData->disc_result.discovery_ntf;
762     DebugLog("TagNciAdapterNtf::HandleDiscResult, discId: %{public}d, protocol: %{public}d, discNtfIndex_: %{public}d",
763         discoveryNtf.rf_disc_id, discoveryNtf.protocol, TagNciAdapterCommon::GetInstance().discNtfIndex_);
764     uint8_t nfcID2[NCI_NFCID1_MAX_LEN] = {0};
765 
766     if (discoveryNtf.rf_disc_id == 1) { // first UID
767         (void)memset_s(nfcID1_, sizeof(nfcID1_), 0, sizeof(nfcID1_));
768         if (discoveryNtf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) {
769             errno_t err = memcpy_s(nfcID1_, sizeof(nfcID1_), discoveryNtf.rf_tech_param.param.pa.nfcid1,
770                            discoveryNtf.rf_tech_param.param.pa.nfcid1_len);
771             if (err != EOK) {
772                 ErrorLog("TagNciAdapterNtf::HandleDiscResult, memcpy nfcid1 error: %{public}d", err);
773             }
774         }
775     } else if (discoveryNtf.rf_disc_id == 2) {  // 2 represents the second uid
776         if (discoveryNtf.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) {
777             errno_t err = memcpy_s(nfcID2, sizeof(nfcID2), discoveryNtf.rf_tech_param.param.pa.nfcid1,
778                            discoveryNtf.rf_tech_param.param.pa.nfcid1_len);
779             if (err != EOK) {
780                 ErrorLog("TagNciAdapterNtf::HandleDiscResult, memcpy nfcid2 error: %{public}d", err);
781             }
782         }
783     }
784     if (TagNciAdapterCommon::GetInstance().discNtfIndex_ >= MAX_NUM_TECHNOLOGY) {
785         ErrorLog("TagNciAdapterNtf::HandleDiscResult, invalid discNtfIndex_: %{public}d",
786             TagNciAdapterCommon::GetInstance().discNtfIndex_);
787         return;
788     }
789     TagNciAdapterCommon::GetInstance().discNtfIndex_++;
790     g_commonMultiTagDiscId.push_back(discoveryNtf.rf_disc_id);
791     g_commonMultiTagDiscProtocol.push_back(discoveryNtf.protocol);
792 #if (NXP_EXTNS == TRUE)
793     SetMultiTagData(discoveryNtf);
794 #endif
795     if (discoveryNtf.more == NCI_DISCOVER_NTF_MORE) {
796         return;
797     }
798     IsMultiTag(discoveryNtf, nfcID2, NCI_NFCID1_MAX_LEN);
799 }
800 
GetT1tMaxMessageSize(tNFA_ACTIVATED activated) const801 uint32_t TagNciAdapterNtf::GetT1tMaxMessageSize(tNFA_ACTIVATED activated) const
802 {
803     uint32_t t1tMaxMessageSize;
804     DebugLog("GetT1tMaxMessageSize");
805     if (activated.activate_ntf.protocol != NFC_PROTOCOL_T1T) {
806         t1tMaxMessageSize = 0;
807         return t1tMaxMessageSize;
808     }
809     // examine the first byte of header ROM bytes
810     switch (activated.params.t1t.hr[0]) {
811         case RW_T1T_IS_TOPAZ96:
812             t1tMaxMessageSize = TOPAZ96_MAX_MESSAGE_SIZE;
813             break;
814         case RW_T1T_IS_TOPAZ512:
815             t1tMaxMessageSize = TOPAZ512_MAX_MESSAGE_SIZE;
816             break;
817         default:
818             ErrorLog("GetT1tMaxMessageSize: unknown T1T HR0=%u", activated.params.t1t.hr[0]);
819             t1tMaxMessageSize = 0;
820             break;
821     }
822     return t1tMaxMessageSize;
823 }
824 
GetRfInterface(uint32_t protocol) const825 tNFA_INTF_TYPE TagNciAdapterNtf::GetRfInterface(uint32_t protocol) const
826 {
827     tNFA_INTF_TYPE rfInterface;
828     if (protocol == NFA_PROTOCOL_ISO_DEP) {
829         rfInterface = NFA_INTERFACE_ISO_DEP;
830     } else if (protocol == NFA_PROTOCOL_MIFARE) {
831         rfInterface = NFA_INTERFACE_MIFARE;
832     } else {
833         rfInterface = NFA_INTERFACE_FRAME;
834     }
835     return rfInterface;
836 }
837 
SetIsMultiTag(bool isMultiTag)838 void TagNciAdapterNtf::SetIsMultiTag(bool isMultiTag)
839 {
840     TagNciAdapterCommon::GetInstance().isMultiTag_ = isMultiTag &&
841         TagNciAdapterCommon::GetInstance().isMultiTagSupported_;
842 }
843 
GetIsMultiTag() const844 bool TagNciAdapterNtf::GetIsMultiTag() const
845 {
846     return TagNciAdapterCommon::GetInstance().isMultiTag_;
847 }
848 
SetDiscRstEvtNum(uint32_t num)849 void TagNciAdapterNtf::SetDiscRstEvtNum(uint32_t num)
850 {
851     if (num < MAX_NUM_TECHNOLOGY) {
852         g_commonDiscRstEvtNum = num;
853     }
854 }
855 
GetDiscRstEvtNum() const856 uint32_t TagNciAdapterNtf::GetDiscRstEvtNum() const
857 {
858     return g_commonDiscRstEvtNum;
859 }
860 
GetMultiTagTechsFromData(const tNFA_DISC_RESULT & discoveryData)861 void TagNciAdapterNtf::GetMultiTagTechsFromData(const tNFA_DISC_RESULT& discoveryData)
862 {
863     uint32_t idx = g_commonDiscRstEvtNum;
864     if (idx >= MAX_NUM_TECHNOLOGY || idx >= g_commonMultiTagDiscProtocol.size() ||
865         idx >= g_commonMultiTagDiscId.size()) {
866         ErrorLog("TagNciAdapterNtf::GetMultiTagTechsFromData: index error, index = %{public}d", idx);
867         return;
868     }
869     g_commonMultiTagDiscId[idx] = discoveryData.discovery_ntf.rf_disc_id;
870     g_commonMultiTagDiscProtocol[idx] = discoveryData.discovery_ntf.protocol;
871     if (TagNciAdapterCommon::GetInstance().discNtfIndex_ < MAX_NUM_TECHNOLOGY) {
872         TagNciAdapterCommon::GetInstance().discNtfIndex_++;
873     }
874     DebugLog("TagNciAdapterNtf::GetMultiTagTechsFromData: g_commonDiscRstEvtNum = %{public}d,"
875         "discNtfIndex_ = %{public}d, discId = 0x%{public}X, protocol = 0x%{public}X",
876         g_commonDiscRstEvtNum, TagNciAdapterCommon::GetInstance().discNtfIndex_,
877         g_commonMultiTagDiscId[idx], g_commonMultiTagDiscProtocol[idx]);
878 }
879 
DoSelectForMultiTag(uint32_t currIdx)880 tNFA_STATUS TagNciAdapterNtf::DoSelectForMultiTag(uint32_t currIdx)
881 {
882     tNFA_STATUS result = NFA_STATUS_FAILED;
883     if (currIdx == INVALID_TAG_INDEX) {
884         ErrorLog("TagNciAdapterNtf::DoSelectForMultiTag: is NFC_DEP");
885         return result;
886     }
887     InfoLog("TagNciAdapterNtf::DoSelectForMultiTag: protocol = 0x%{public}X", g_commonMultiTagDiscProtocol[currIdx]);
888 
889     if (g_commonMultiTagDiscProtocol[currIdx] == NFA_PROTOCOL_ISO_DEP) {
890         result = NFA_Select(
891             g_commonMultiTagDiscId[currIdx], g_commonMultiTagDiscProtocol[currIdx], NFA_INTERFACE_ISO_DEP);
892     } else if (g_commonMultiTagDiscProtocol[currIdx] == NFA_PROTOCOL_MIFARE) {
893         result = NFA_Select(
894             g_commonMultiTagDiscId[currIdx], g_commonMultiTagDiscProtocol[currIdx], NFA_INTERFACE_MIFARE);
895     } else {
896         result = NFA_Select(
897             g_commonMultiTagDiscId[currIdx], g_commonMultiTagDiscProtocol[currIdx], NFA_INTERFACE_FRAME);
898     }
899     return result;
900 }
901 
SkipProtoActivateIfNeed(tNFC_PROTOCOL protocol)902 bool TagNciAdapterNtf::SkipProtoActivateIfNeed(tNFC_PROTOCOL protocol)
903 {
904     if ((protocol == NFA_PROTOCOL_ISO_DEP) && g_multiTagParams.isSkipIsoDepAct) {
905         tNFA_CONN_EVT_DATA eventData;
906         tNFC_ACTIVATE_DEVT& actNtf = eventData.activated.activate_ntf;
907         tNFC_RESULT_DEVT& info = g_multiTagParams.discNtf;
908         actNtf.rf_disc_id = info.rf_disc_id;
909         actNtf.protocol = info.protocol;
910         errno_t err = EOK;
911         err = memcpy_s(&actNtf.rf_tech_param, sizeof(tNFC_RF_TECH_PARAMS),
912                        &info.rf_tech_param, sizeof(tNFC_RF_TECH_PARAMS));
913         if (err != EOK) {
914             ErrorLog("TagNciAdapterNtf::SkipProtoActivateIfNeed, memcpy rf_tech_param error: %{public}d", err);
915         }
916         err = memcpy_s(&actNtf.intf_param, sizeof(tNFC_INTF_PARAMS),
917                        &g_multiTagParams.intfParam, sizeof(tNFC_INTF_PARAMS));
918         if (err != EOK) {
919             ErrorLog("TagNciAdapterNtf::SkipProtoActivateIfNeed, memcpy intfParam error: %{public}d", err);
920         }
921         InfoLog("TagNciAdapterNtf::SkipProtoActivateIfNeed,(SAK28) discID:%{public}u is skipped", actNtf.rf_disc_id);
922         NfccNciAdapter::GetInstance().SendActEvtForSak28Tag(NFA_ACTIVATED_EVT, &eventData);
923         g_commonDiscRstEvtNum--;
924         return true;
925     }
926     return false;
927 }
928 
SelectTheFirstTag()929 void TagNciAdapterNtf::SelectTheFirstTag()
930 {
931     uint32_t currIdx = INVALID_TAG_INDEX;
932     for (uint32_t i = 0; i < TagNciAdapterCommon::GetInstance().discNtfIndex_; i++) {
933         InfoLog("TagNciAdapterNtf::SelectTheFirstTag index = %{public}d discId = 0x%{public}X protocol = 0x%{public}X",
934             i, g_commonMultiTagDiscId[i], g_commonMultiTagDiscProtocol[i]);
935         // logic for SAK28 issue
936         if (isSkipMifareActive_) {
937             if ((g_commonMultiTagDiscProtocol[i] == NFA_PROTOCOL_NFC_DEP) ||
938                 (g_commonMultiTagDiscProtocol[i] == NFA_PROTOCOL_MIFARE)) {
939                 continue;
940             }
941 #if (NXP_EXTNS == TRUE)
942             if (!SkipProtoActivateIfNeed(g_commonMultiTagDiscProtocol[i])) {
943                 g_selectedIdx = i;
944 #endif
945                 g_commonSelectedTagIdx = i;
946                 currIdx = i;
947                 break;
948 #if (NXP_EXTNS == TRUE)
949             }
950 #endif
951         } else if (g_commonMultiTagDiscProtocol[i] != NFA_PROTOCOL_NFC_DEP) {
952 #if (NXP_EXTNS == TRUE)
953             if (!SkipProtoActivateIfNeed(g_commonMultiTagDiscProtocol[i])) {
954                 g_selectedIdx = i;
955 #endif
956                 g_commonSelectedTagIdx = i;
957                 currIdx = i;
958                 break;
959 #if (NXP_EXTNS == TRUE)
960             }
961 #endif
962         }
963     }
964     isSkipMifareActive_ = false;
965 
966     // logic for normal tag
967     tNFA_STATUS result = DoSelectForMultiTag(currIdx);
968     InfoLog("TagNciAdapterNtf::SelectTheFirstTag result = %{public}d", result);
969 }
970 
SelectTheNextTag()971 void TagNciAdapterNtf::SelectTheNextTag()
972 {
973     if (g_commonDiscRstEvtNum == 0) {
974         InfoLog("TagNciAdapterNtf::SelectTheNextTag: next tag does not exist");
975         return;
976     }
977     uint32_t currIdx = INVALID_TAG_INDEX;
978     g_commonDiscRstEvtNum--;
979     for (uint32_t i = 0; i < TagNciAdapterCommon::GetInstance().discNtfIndex_; i++) {
980         InfoLog("TagNciAdapterNtf::SelectTheNextTag index = %{public}d discId = 0x%{public}X protocol = 0x%{public}X",
981             i, g_commonMultiTagDiscId[i], g_commonMultiTagDiscProtocol[i]);
982         if (g_commonMultiTagDiscId[i] != g_commonMultiTagDiscId[g_commonSelectedTagIdx] ||
983             (g_commonMultiTagDiscProtocol[i] != g_commonMultiTagDiscProtocol[g_commonSelectedTagIdx] &&
984             (g_commonMultiTagDiscProtocol[i] != NFA_PROTOCOL_NFC_DEP))) {
985             g_commonSelectedTagIdx = i;
986             currIdx = i;
987             break;
988         }
989     }
990     tNFA_STATUS result = DoSelectForMultiTag(currIdx);
991     InfoLog("TagNciAdapterNtf::DoSelectForMultiTag result = %{public}d", result);
992 }
993 
994 /* method for SAK28 issue */
SetSkipMifareInterface()995 void TagNciAdapterNtf::SetSkipMifareInterface()
996 {
997     InfoLog("TagNciAdapterNtf::SetSkipMifareInterface");
998     isSkipMifareActive_ = true;
999     g_commonDiscRstEvtNum = 1;
1000 }
1001 
IsMultiMFCTag()1002 bool TagNciAdapterNtf::IsMultiMFCTag()
1003 {
1004     return TagNciAdapterRw::GetInstance().IsMultiMFCTag();
1005 }
1006 
SetTagActivated()1007 void TagNciAdapterNtf::SetTagActivated()
1008 {
1009     TagNciAdapterRw::GetInstance().SetTagActivated();
1010 }
1011 
ResetTagFieldOnFlag()1012 void TagNciAdapterNtf::ResetTagFieldOnFlag()
1013 {
1014     TagNciAdapterRw::GetInstance().ResetTagFieldOnFlag();
1015 }
1016 
SetTagDeactivated(bool isSleep)1017 void TagNciAdapterNtf::SetTagDeactivated(bool isSleep)
1018 {
1019     TagNciAdapterRw::GetInstance().SetTagDeactivated(isSleep);
1020 }
1021 
HandleDeactivatedResult(tNFA_DEACTIVATE_TYPE deactType)1022 void TagNciAdapterNtf::HandleDeactivatedResult(tNFA_DEACTIVATE_TYPE deactType)
1023 {
1024     TagNciAdapterRw::GetInstance().HandleDeactivatedResult(deactType);
1025 }
1026 
AbortWait()1027 void TagNciAdapterNtf::AbortWait()
1028 {
1029     TagNciAdapterRw::GetInstance().AbortWait();
1030 }
1031 
IsTagDeactivating()1032 bool TagNciAdapterNtf::IsTagDeactivating()
1033 {
1034     return TagNciAdapterRw::GetInstance().IsTagDeactivating();
1035 }
1036 
HandleFieldCheckResult(uint8_t status)1037 void TagNciAdapterNtf::HandleFieldCheckResult(uint8_t status)
1038 {
1039     TagNciAdapterRw::GetInstance().HandleFieldCheckResult(status);
1040 }
1041 
HandleNdefCheckResult(uint8_t status,uint32_t currentSize,uint32_t flag,uint32_t maxSize)1042 void TagNciAdapterNtf::HandleNdefCheckResult(uint8_t status, uint32_t currentSize, uint32_t flag, uint32_t maxSize)
1043 {
1044     TagNciAdapterRw::GetInstance().HandleNdefCheckResult(status, currentSize, flag, maxSize);
1045 }
1046 
HandleTranceiveData(uint8_t status,uint8_t * data,uint32_t dataLen)1047 void TagNciAdapterNtf::HandleTranceiveData(uint8_t status, uint8_t* data, uint32_t dataLen)
1048 {
1049     TagNciAdapterRw::GetInstance().HandleTranceiveData(status, data, dataLen);
1050 }
1051 
1052 }  // namespace NCI
1053 }  // namespace NFC
1054 }  // namespace OHOS
1055