1 /*
2  * Copyright (c) 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 <gtest/gtest.h>
16 #include <thread>
17 #include "nfc_service.h"
18 #include "tag_nci_adapter.h"
19 
20 namespace OHOS {
21 namespace NFC {
22 namespace TEST {
23 using namespace testing::ext;
24 using namespace OHOS::NFC::NCI;
25 
26 class TagNciAdapterTest : public testing::Test {
27 public:
SetUpTestCase()28     static void SetUpTestCase() {}
TearDownTestCase()29     static void TearDownTestCase() {}
30     void SetUp();
31     void TearDown();
32 
33     static const int DEFAULT_TIMEOUT = 1000;
34     static const int ISO14443_3A_DEFAULT_TIMEOUT = 618;   // NfcA
35     static const uint32_t MAX_NUM_TECHNOLOGY = 12;
36     // const values for Mifare Ultralight
37     static const int MANUFACTURER_ID_NXP = 0x04;
38     static const int SAK_MIFARE_UL_1 = 0x00;
39     static const int SAK_MIFARE_UL_2 = 0x04;
40     static const int ATQA_MIFARE_UL_0 = 0x44;
41     static const int ATQA_MIFARE_UL_1 = 0x00;
42 
43     // const values for Mifare DESFire
44     static const int SAK_MIFARE_DESFIRE = 0x20;
45     static const int ATQA_MIFARE_DESFIRE_0 = 0x44;
46     static const int ATQA_MIFARE_DESFIRE_1 = 0x03;
47 };
48 
SetUp()49 void TagNciAdapterTest::SetUp()
50 {
51 }
52 
TearDown()53 void TagNciAdapterTest::TearDown()
54 {
55 }
56 
57 /**
58  * @tc.name: TagNciAdapterTest001
59  * @tc.desc: Test IsNdefFormattable
60  * @tc.type: FUNC
61  */
62 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest001, TestSize.Level1)
63 {
64     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
65     std::vector<uint16_t> systemCode = {0x88B4, 0, 0};
66     tNFA_ACTIVATED activated;
67     activated.params.t3t.num_system_codes = 1;
68     activated.params.t3t.p_system_codes = &systemCode[0];
69     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_A;
70     activated.activate_ntf.rf_tech_param.param.pa.sel_rsp = SAK_MIFARE_UL_1;
71     activated.activate_ntf.rf_tech_param.param.pa.sens_res[0] = ATQA_MIFARE_UL_0;
72     activated.activate_ntf.rf_tech_param.param.pa.sens_res[1] = ATQA_MIFARE_UL_1;
73     activated.activate_ntf.rf_tech_param.param.pa.nfcid1[0] = MANUFACTURER_ID_NXP;
74 
75     activated.activate_ntf.protocol = NFA_PROTOCOL_T2T;
76     adapterObj->BuildTagInfo(activated);
77     EXPECT_TRUE(adapterObj->IsNdefFormattable());
78 
79     activated.activate_ntf.protocol = NFA_PROTOCOL_T3T;
80     adapterObj->BuildTagInfo(activated);
81     EXPECT_TRUE(adapterObj->IsNdefFormattable());
82 
83     activated.activate_ntf.protocol = NFA_PROTOCOL_ISO_DEP;
84     adapterObj->BuildTagInfo(activated);
85     EXPECT_TRUE(!adapterObj->IsNdefFormattable());
86 
87     activated.activate_ntf.protocol = NFA_PROTOCOL_T1T;
88     adapterObj->BuildTagInfo(activated);
89     EXPECT_TRUE(adapterObj->IsNdefFormattable());
90 
91     activated.activate_ntf.protocol = NFA_PROTOCOL_INVALID;
92     adapterObj->BuildTagInfo(activated);
93     EXPECT_TRUE(!adapterObj->IsNdefFormattable());
94 }
95 
96 /**
97  * @tc.name: TagNciAdapterTest002
98  * @tc.desc: Test Connect or Disconnect
99  * @tc.type: FUNC
100  */
101 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest002, TestSize.Level1)
102 {
103     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
104 
105     tNFA_STATUS statusConnect = adapterObj->Connect(0);
106     EXPECT_TRUE(statusConnect == NFA_STATUS_BUSY);
107 
108     bool statusDisconnect = adapterObj->Disconnect();
109     EXPECT_FALSE(!statusDisconnect);
110 
111     bool statusReconnect = adapterObj->Reconnect();
112     EXPECT_TRUE(!statusReconnect);
113 
114     EXPECT_TRUE(!NCI::TagNciAdapter::GetInstance().IsReconnecting());
115 
116     adapterObj->ResetTag();
117     EXPECT_TRUE(!NCI::TagNciAdapter::GetInstance().IsReconnecting());
118 }
119 
120 /**
121  * @tc.name: TagNciAdapterTest003
122  * @tc.desc: Test Transmit
123  * @tc.type: FUNC
124  */
125 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest003, TestSize.Level1)
126 {
127     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
128     std::string request = "00a40400";
129     std::string response;
130     EXPECT_TRUE(adapterObj->Transceive(request, response) == NFA_STATUS_BUSY);
131 
132     unsigned char data[] = {0x00, 0xa4, 0x04, 0x00};
133     NCI::TagNciAdapter::GetInstance().HandleTranceiveData(NFA_STATUS_OK, data, 4);
134     NCI::TagNciAdapter::GetInstance().HandleTranceiveData(NFA_STATUS_CONTINUE, data, 4);
135 
136     NCI::TagNciAdapter::GetInstance().HandleFieldCheckResult(NFA_STATUS_OK);
137 
138     NCI::TagNciAdapter::GetInstance().HandleSelectResult(0);
139     NCI::TagNciAdapter::GetInstance().HandleDeactivatedResult(0);
140     adapterObj->ResetTagFieldOnFlag();
141 
142     EXPECT_TRUE(adapterObj->GetTimeout((MAX_NUM_TECHNOLOGY + 1)) == DEFAULT_TIMEOUT);
143     adapterObj->ResetTimeout();
144     EXPECT_TRUE(adapterObj->GetTimeout(TagHost::TARGET_TYPE_ISO14443_3A) == ISO14443_3A_DEFAULT_TIMEOUT);
145 }
146 
147 /**
148  * @tc.name: TagNciAdapterTest004
149  * @tc.desc: Test NDEF
150  * @tc.type: FUNC
151  */
152 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest004, TestSize.Level1)
153 {
154     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
155     EXPECT_TRUE(!adapterObj->SetReadOnly());
156 
157     std::string response;
158     adapterObj->ReadNdef(response);
159     EXPECT_TRUE(response.empty());
160     NCI::TagNciAdapter::GetInstance().HandleReadComplete(NFA_STATUS_BUSY);
161 
162     std::string command = "00a40400";
163     EXPECT_TRUE(!adapterObj->WriteNdef(command));
164     NCI::TagNciAdapter::GetInstance().HandleWriteComplete(NFA_STATUS_BUSY);
165 
166     EXPECT_TRUE(!adapterObj->FormatNdef());
167     NCI::TagNciAdapter::GetInstance().HandleFormatComplete(NFA_STATUS_BUSY);
168 
169     EXPECT_TRUE(!adapterObj->IsNdefFormatable());
170 
171     adapterObj->HandleNdefCheckResult(NFA_STATUS_BUSY, 0, 0xFFFFFFFF, 0);
172     adapterObj->HandleNdefCheckResult(NFA_STATUS_OK, 0, 0xFFFFFFFF, 0);
173     adapterObj->HandleNdefCheckResult(NFA_STATUS_FAILED, 0, 0xFFFFFFFF, 0);
174     adapterObj->HandleNdefCheckResult(NFA_STATUS_BUSY, 0, 0xFFFFFF00, 0);
175     adapterObj->HandleNdefCheckResult(NFA_STATUS_FAILED, 0, 0xFFFFFF04, 0);
176     adapterObj->HandleNdefCheckResult(NFA_STATUS_REJECTED, 0, 0xFFFFFFFF, 0);
177 
178     std::vector<int> ndefInfo{};
179     EXPECT_TRUE(!adapterObj->DetectNdefInfo(ndefInfo));
180 }
181 
182 /**
183  * @tc.name: TagNciAdapterTest005
184  * @tc.desc: Test Field On/Off
185  * @tc.type: FUNC
186  */
187 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest005, TestSize.Level1)
188 {
189     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
190     EXPECT_TRUE(!adapterObj->SetReadOnly());
191 
192     adapterObj->OnRfDiscLock();
193     adapterObj->OffRfDiscLock();
194 
195     NCI::TagNciAdapter::GetInstance().AbortWait();
196 
197     tNFA_DISC_RESULT discoveryData;
198     adapterObj->GetMultiTagTechsFromData(discoveryData);
199 
200     tNFA_ACTIVATED activated{};
201     adapterObj->BuildTagInfo(activated);
202 
203     adapterObj->SelectTheFirstTag();
204     adapterObj->SelectTheNextTag();
205 
206     adapterObj->SetIsMultiTag(true);
207     EXPECT_FALSE(adapterObj->GetIsMultiTag());
208 
209     adapterObj->SetDiscRstEvtNum(TagHost::TARGET_TYPE_ISO14443_3A);
210     EXPECT_TRUE(adapterObj->GetDiscRstEvtNum() == TagHost::TARGET_TYPE_ISO14443_3A);
211 }
212 
213 /**
214  * @tc.name: TagNciAdapterTest006
215  * @tc.desc: Test HandleDiscResult
216  * @tc.type: FUNC
217  */
218 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest006, TestSize.Level1)
219 {
220     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
221     adapterObj->HandleDiscResult(nullptr);
222 
223     // test with valid event data.
224     tNFA_CONN_EVT_DATA eventData;
225     tNFC_RESULT_DEVT discoveryNtf;
226     discoveryNtf.more = NCI_DISCOVER_NTF_MORE;
227     discoveryNtf.protocol = NFA_PROTOCOL_NFC_DEP;
228     eventData.disc_result.discovery_ntf = discoveryNtf;
229     adapterObj->HandleDiscResult(&eventData);
230 
231     discoveryNtf.more = NCI_DISCOVER_NTF_LAST;
232     discoveryNtf.protocol = NFA_PROTOCOL_ISO_DEP;
233     eventData.disc_result.discovery_ntf = discoveryNtf;
234     adapterObj->HandleDiscResult(&eventData);
235 
236     discoveryNtf.more = NCI_DISCOVER_NTF_LAST;
237     discoveryNtf.protocol = NFC_PROTOCOL_MIFARE;
238     eventData.disc_result.discovery_ntf = discoveryNtf;
239     adapterObj->HandleDiscResult(&eventData);
240 }
241 
242 /**
243  * @tc.name: TagNciAdapterTest007
244  * @tc.desc: Test BuildTagInfo
245  * @tc.type: FUNC
246  */
247 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest007, TestSize.Level1)
248 {
249     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
250     std::vector<uint16_t> systemCode = {0x88B4, 0, 0};
251     tNFA_ACTIVATED activated;
252     activated.activate_ntf.protocol = NCI_PROTOCOL_T1T;
253     activated.params.t3t.num_system_codes = 1;
254     activated.params.t3t.p_system_codes = &systemCode[0];
255     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_A;
256     activated.activate_ntf.rf_tech_param.param.pa.sel_rsp = 0004;
257     activated.activate_ntf.rf_tech_param.param.pa.sens_res[0] = ATQA_MIFARE_UL_0;
258     activated.activate_ntf.rf_tech_param.param.pa.sens_res[1] = ATQA_MIFARE_UL_1;
259     activated.activate_ntf.rf_tech_param.param.pa.nfcid1[0] = MANUFACTURER_ID_NXP;
260     adapterObj->SetDiscRstEvtNum(1);
261     adapterObj->BuildTagInfo(activated);
262 
263     activated.activate_ntf.protocol = NCI_PROTOCOL_T2T;
264     adapterObj->BuildTagInfo(activated);
265 
266     activated.activate_ntf.protocol = NCI_PROTOCOL_T3BT;
267     adapterObj->BuildTagInfo(activated);
268 
269     activated.activate_ntf.protocol = NCI_PROTOCOL_T3T;
270     adapterObj->BuildTagInfo(activated);
271 
272     activated.activate_ntf.protocol = NCI_PROTOCOL_15693;
273     adapterObj->BuildTagInfo(activated);
274 }
275 
276 /**
277  * @tc.name: TagNciAdapterTest008
278  * @tc.desc: Test BuildTagInfo
279  * @tc.type: FUNC
280  */
281 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest008, TestSize.Level1)
282 {
283     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
284     std::vector<uint16_t> systemCode = {0x88B4, 0, 0};
285     tNFA_ACTIVATED activated;
286     activated.activate_ntf.protocol = NCI_PROTOCOL_ISO_DEP;
287     activated.params.t3t.num_system_codes = 1;
288     activated.params.t3t.p_system_codes = &systemCode[0];
289     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_A;
290     activated.activate_ntf.rf_tech_param.param.pa.sel_rsp = 0004;
291     activated.activate_ntf.rf_tech_param.param.pa.sens_res[0] = ATQA_MIFARE_UL_0;
292     activated.activate_ntf.rf_tech_param.param.pa.sens_res[1] = ATQA_MIFARE_UL_1;
293     activated.activate_ntf.rf_tech_param.param.pa.nfcid1[0] = MANUFACTURER_ID_NXP;
294     adapterObj->SetDiscRstEvtNum(1);
295     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_B;
296     adapterObj->BuildTagInfo(activated);
297 
298     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_F;
299     adapterObj->BuildTagInfo(activated);
300 
301     activated.activate_ntf.rf_tech_param.mode = 0x0F;
302     adapterObj->BuildTagInfo(activated);
303 
304     activated.activate_ntf.rf_tech_param.mode = NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE;
305     activated.activate_ntf.rf_tech_param.param.pa.sens_res[0] = ATQA_MIFARE_DESFIRE_0;
306     activated.activate_ntf.rf_tech_param.param.pa.sens_res[1] = ATQA_MIFARE_DESFIRE_1;
307     activated.activate_ntf.rf_tech_param.param.pa.sel_rsp = SAK_MIFARE_DESFIRE;
308     adapterObj->BuildTagInfo(activated);
309 }
310 
311 /**
312  * @tc.name: TagNciAdapterTest009
313  * @tc.desc: Test BuildTagInfo NCI_DISCOVERY_TYPE_POLL_A
314  * @tc.type: FUNC
315  */
316 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest009, TestSize.Level1)
317 {
318     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
319     adapterObj->ResetTag();
320     adapterObj->SetDiscRstEvtNum(1);
321     std::vector<uint16_t> systemCode = {0x88B4, 0, 0};
322     tNFA_ACTIVATED activated;
323     activated.params.t3t.p_system_codes = &systemCode[0];
324 
325     activated.activate_ntf.protocol = NCI_PROTOCOL_ISO_DEP;
326     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_A;
327     activated.activate_ntf.intf_param.type = NFC_INTERFACE_ISO_DEP;
328     activated.activate_ntf.intf_param.intf_param.pa_iso.his_byte[0] = 0;
329     activated.activate_ntf.intf_param.intf_param.pa_iso.his_byte_len = 1;
330     adapterObj->BuildTagInfo(activated);
331 
332     activated.activate_ntf.intf_param.intf_param.pa_iso.his_byte[0] = 0;
333     activated.activate_ntf.intf_param.intf_param.pa_iso.his_byte_len = 0;
334     adapterObj->BuildTagInfo(activated);
335 
336     activated.activate_ntf.intf_param.type = NFC_INTERFACE_FRAME;
337     adapterObj->BuildTagInfo(activated);
338 }
339 
340 /**
341  * @tc.name: TagNciAdapterTest0010
342  * @tc.desc: Test BuildTagInfo NCI_DISCOVERY_TYPE_POLL_B
343  * @tc.type: FUNC
344  */
345 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest0010, TestSize.Level1)
346 {
347     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
348     adapterObj->ResetTag();
349     adapterObj->SetDiscRstEvtNum(1);
350     std::vector<uint16_t> systemCode = {0x88B4, 0, 0};
351     std::vector<uint8_t> hisByte = {0};
352     tNFA_ACTIVATED activated;
353     activated.params.t3t.p_system_codes = &systemCode[0];
354 
355     activated.activate_ntf.protocol = NCI_PROTOCOL_ISO_DEP;
356     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_B;
357     activated.activate_ntf.rf_tech_param.param.pb.sensb_res_len = 0;
358     activated.activate_ntf.intf_param.type = NFC_INTERFACE_ISO_DEP;
359     activated.activate_ntf.intf_param.intf_param.pa_iso.his_byte[0] = 0;
360     activated.activate_ntf.intf_param.intf_param.pa_iso.his_byte_len = 1;
361     adapterObj->BuildTagInfo(activated);
362     activated.activate_ntf.rf_tech_param.param.pb.sensb_res_len = NFC_NFCID0_MAX_LEN + 1;
363     adapterObj->BuildTagInfo(activated);
364     activated.activate_ntf.intf_param.type = NFC_INTERFACE_NFC_DEP;
365     adapterObj->BuildTagInfo(activated);
366 
367     activated.activate_ntf.protocol = NCI_PROTOCOL_ISO_DEP;
368     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_F;
369     activated.params.t3t.num_system_codes = 1;
370     adapterObj->BuildTagInfo(activated);
371     activated.params.t3t.num_system_codes = 0;
372     adapterObj->BuildTagInfo(activated);
373 
374     activated.activate_ntf.protocol = NCI_PROTOCOL_T3BT;
375     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_B;
376     activated.activate_ntf.intf_param.intf_param.pa_iso.his_byte_len = 0;
377     adapterObj->BuildTagInfo(activated);
378 }
379 
380 /**
381  * @tc.name: TagNciAdapterTest0011
382  * @tc.desc: Test BuildTagInfo: IsDiscTypeA/IsDiscTypeB/IsDiscTypeF/IsDiscTypeV
383  * @tc.type: FUNC
384  */
385 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest0011, TestSize.Level1)
386 {
387     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
388     std::vector<uint16_t> systemCode = {0x88B4, 0, 0};
389     tNFA_ACTIVATED activated;
390     activated.activate_ntf.protocol = NCI_PROTOCOL_T1T;
391     activated.params.t3t.num_system_codes = 1;
392     activated.params.t3t.p_system_codes = &systemCode[0];
393     activated.activate_ntf.rf_tech_param.param.pa.sel_rsp = SAK_MIFARE_DESFIRE;
394     activated.activate_ntf.rf_tech_param.param.pa.sens_res[0] = ATQA_MIFARE_UL_0;
395     activated.activate_ntf.rf_tech_param.param.pa.sens_res[1] = ATQA_MIFARE_UL_1;
396     activated.activate_ntf.rf_tech_param.param.pa.nfcid1[0] = MANUFACTURER_ID_NXP;
397 
398     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_A_ACTIVE;
399     adapterObj->BuildTagInfo(activated);
400 
401     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_LISTEN_A;
402     adapterObj->BuildTagInfo(activated);
403 
404     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_LISTEN_A_ACTIVE;
405     adapterObj->BuildTagInfo(activated);
406 
407     activated.activate_ntf.rf_tech_param.mode = NFC_DISCOVERY_TYPE_POLL_B_PRIME;
408     adapterObj->BuildTagInfo(activated);
409 
410     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_LISTEN_B;
411     adapterObj->BuildTagInfo(activated);
412 
413     activated.activate_ntf.rf_tech_param.mode = NFC_DISCOVERY_TYPE_LISTEN_B_PRIME;
414     adapterObj->BuildTagInfo(activated);
415 
416     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_F_ACTIVE;
417     adapterObj->BuildTagInfo(activated);
418 
419     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_LISTEN_F;
420     adapterObj->BuildTagInfo(activated);
421 
422     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_LISTEN_F_ACTIVE;
423     adapterObj->BuildTagInfo(activated);
424 
425     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_POLL_V;
426     adapterObj->BuildTagInfo(activated);
427 
428     activated.activate_ntf.rf_tech_param.mode = NCI_DISCOVERY_TYPE_LISTEN_ISO15693;
429     adapterObj->BuildTagInfo(activated);
430 }
431 
432 /**
433  * @tc.name: TagNciAdapterTest0012
434  * @tc.desc: Test SelectTheNextTag
435  * @tc.type: FUNC
436  */
437 HWTEST_F(TagNciAdapterTest, TagNciAdapterTest0012, TestSize.Level1)
438 {
439     std::shared_ptr<NCI::TagNciAdapter> adapterObj = std::make_shared<NCI::TagNciAdapter>();
440     adapterObj->SetDiscRstEvtNum(1);
441     tNFA_DISC_RESULT discoveryData;
442     discoveryData.discovery_ntf.rf_disc_id = NFA_PROTOCOL_NFC_DEP;
443     discoveryData.discovery_ntf.protocol = NFA_PROTOCOL_NFC_DEP;
444     adapterObj->GetMultiTagTechsFromData(discoveryData);
445     adapterObj->SelectTheFirstTag();
446 
447     adapterObj->SetDiscRstEvtNum(2);
448     discoveryData.discovery_ntf.rf_disc_id = NFA_PROTOCOL_ISO_DEP;
449     discoveryData.discovery_ntf.protocol = NFA_PROTOCOL_ISO_DEP;
450     adapterObj->GetMultiTagTechsFromData(discoveryData);
451     adapterObj->SelectTheFirstTag();
452     adapterObj->SelectTheNextTag();
453 }
454 }
455 }
456 }
457