1# nfctech (标准NFC-Tag Nfc 技术) 2 3<!--Kit: Connectivity Kit--> 4<!--Subsystem: Communication--> 5<!--Owner: @amunra03--> 6<!--Designer: @wenxiaolin--> 7<!--Tester: @zs_111--> 8<!--Adviser: @zhang_yixin13--> 9 10本模块主要用于采用不同Nfc技术的Tag的读写操作。 11 12> **说明：** 13> 14> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 15 16> **注意：** 17> 18> 导入tag模块编辑器报错，在某个具体设备型号上能力可能超出工程默认设备定义的能力集范围，如需要使用此部分能力需额外配置自定义syscap，参考[syscap开发指南](https://developer.huawei.com/consumer/cn/doc/harmonyos-references/syscap#syscap开发指导)。 19 20## 导入模块 21 22```js 23import { tag } from '@kit.ConnectivityKit'; 24``` 25 26## NfcATag 27 28NfcATag 提供 NFC-A(ISO 14443-3A)技术的属性和I/O操作的访问，继承自[TagSession](js-apis-tagSession.md)。 29 30TagSession是所有NFC Tag技术类型的基类， 提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 31 32NfcATag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 33 34以下是NfcATag的独有接口。 35 36### NfcATag.getSak 37 38getSak(): number 39 40获取NFC-A标签的SAK值。 41 42**系统能力：** SystemCapability.Communication.NFC.Tag 43 44**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 45 46**返回值：** 47 48| **类型** | **说明** | 49| ------------------ | --------------------------| 50| number | NfcA 标签的SAK值，十六进制表示，范围是0x00~0xFF。 | 51 52**示例：** 53 54```js 55import { tag } from '@kit.ConnectivityKit'; 56 57// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 nfcA 58let sak : number = nfcA.getSak(); 59console.info("nfcA sak: " + sak); 60``` 61 62### NfcATag.getAtqa 63 64getAtqa(): number[] 65 66获取NFC-A标签的Atqa值。 67 68**系统能力：** SystemCapability.Communication.NFC.Tag 69 70**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 71 72**返回值：** 73 74| **类型** | **说明** | 75| ------------------ | --------------------------| 76| number[] | NfcA 标签的Atqa值，每个number十六进制表示，范围是0x00~0xFF。 | 77 78**示例：** 79 80```js 81import { tag } from '@kit.ConnectivityKit'; 82 83// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 nfcA 84let atqa : number[] = nfcA.getAtqa(); 85console.info("nfcA atqa: " + atqa); 86``` 87 88## NfcBTag 89 90NfcBTag 提供对NFC-B(ISO 14443-3B)技术的属性和I/O操作的访问，继承自TagSession。 91 92TagSession是所有NFC Tag技术类型的基类，提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 93 94NfcBTag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 95 96以下是NfcBTag的独有接口。 97 98### NfcBTag.getRespAppData 99 100getRespAppData(): number[] 101 102获取标签的应用程序数据。 103 104**系统能力：** SystemCapability.Communication.NFC.Tag 105 106**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 107 108**返回值：** 109 110| **类型** | **说明** | 111| ------------------ | --------------------------| 112| number[] | NfcB 标签的应用程序数据，每个number十六进制表示，范围是0x00~0xFF。 | 113 114**示例：** 115 116```js 117import { tag } from '@kit.ConnectivityKit'; 118 119// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 nfcB 120let respAppData : number[] = nfcB.getRespAppData(); 121console.info("nfcB respAppData: " + respAppData); 122``` 123 124### NfcBTag.getRespProtocol 125 126getRespProtocol(): number[] 127 128获取标签的协议信息。 129 130**系统能力：** SystemCapability.Communication.NFC.Tag 131 132**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 133 134**返回值：** 135 136| **类型** | **说明** | 137| ------------------ | --------------------------| 138| number[] | NfcB 标签的协议信息，每个number十六进制表示，范围是0x00~0xFF。| 139 140**示例：** 141 142```js 143import { tag } from '@kit.ConnectivityKit'; 144 145// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 nfcB 146let respProtocol : number[] = nfcB.getRespProtocol(); 147console.info("nfcB respProtocol: " + respProtocol); 148``` 149 150## NfcFTag 151 152NfcFTag 提供对NFC-F(JIS 6319-4)技术的属性和I/O操作的访问，继承自TagSession。 153 154TagSession是所有NFC Tag技术类型的基类， 提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 155 156NfcFTag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 157 158以下是NfcFTag的独有接口。 159 160### NfcFTag.getSystemCode 161 162getSystemCode(): number[] 163 164从标签实例获取系统代码。 165 166**系统能力：** SystemCapability.Communication.NFC.Tag 167 168**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 169 170**返回值：** 171 172| **类型** | **说明** | 173| ------------------ | --------------------------| 174| number[] | NfcF 标签的系统代码，每个number十六进制表示，范围是0x00~0xFF。| 175 176**示例：** 177 178```js 179import { tag } from '@kit.ConnectivityKit'; 180 181// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 nfcF 182let systemCode : number[] = nfcF.getSystemCode(); 183console.info("nfcF systemCode: " + systemCode); 184``` 185 186### NfcFTag.getPmm 187 188getPmm(): number[] 189 190从标签实例获取PMm（由IC代码和制造商参数组成）。 191 192**系统能力：** SystemCapability.Communication.NFC.Tag 193 194**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 195 196**返回值：** 197 198| **类型** | **说明** | 199| ------------------ | --------------------------| 200| number[] | NfcF 标签的PMm信息，每个number十六进制表示，范围是0x00~0xFF。| 201 202**示例：** 203 204```js 205import { tag } from '@kit.ConnectivityKit'; 206 207// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 nfcF 208let pmm : number[] = nfcF.getPmm(); 209console.info("nfcF pmm: " + pmm); 210``` 211 212## NfcVTag 213 214NfcVTag 提供对NFC-V(ISO 15693)技术的属性和I/O操作的访问，继承自TagSession。 215 216TagSession是所有NFC Tag技术类型的基类， 提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 217 218NfcVTag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 219 220以下是NfcVTag的独有接口。 221 222### NfcvTag.getResponseFlags 223 224getResponseFlags(): number 225 226从标签实例实例获取响应标志。 227 228**系统能力：** SystemCapability.Communication.NFC.Tag 229 230**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 231 232**返回值：** 233 234| **类型** | **说明** | 235| ------------------ | --------------------------| 236| number | NfcV 标签的响应标志，十六进制表示，范围是0x00~0xFF。| 237 238**示例：** 239 240```js 241import { tag } from '@kit.ConnectivityKit'; 242 243// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 nfcV 244let responseFlags : number = nfcV.getResponseFlags(); 245console.info("nfcV responseFlags: " + responseFlags); 246``` 247 248### NfcvTag.getDsfId 249 250getDsfId(): number 251 252从标签实例实例获取数据存储格式标识符（DSFID）。 253 254**系统能力：** SystemCapability.Communication.NFC.Tag 255 256**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 257 258**返回值：** 259 260| **类型** | **说明** | 261| ------------------ | --------------------------| 262| number | NfcV 标签的数据存储格式标识符，十六进制表示，范围是0x00~0xFF。| 263 264**示例：** 265 266```js 267import { tag } from '@kit.ConnectivityKit'; 268 269// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 nfcV 270let dsfId : number = nfcV.getDsfId(); 271console.info("nfcV dsfId: " + dsfId); 272``` 273 274## IsoDepTag<sup>9+</sup> 275 276IsoDepTag 提供对ISO-DEP(ISO 14443-4)技术的属性和I/O操作的访问，继承自TagSession。 277 278TagSession是所有NFC Tag技术类型的基类， 提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 279 280IsoDepTag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 281 282以下是IsoDepTag的独有接口。 283 284### IsoDepTag.getHistoricalBytes<sup>9+</sup> 285 286getHistoricalBytes(): number[] 287 288获取标签的历史字节，针对基于NfcA通信技术的IsoDep卡片。 289 290**系统能力：** SystemCapability.Communication.NFC.Tag 291 292**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 293 294**返回值：** 295 296| **类型** | **说明** | 297| ------------------ | --------------------------| 298| number[] | IsoDepTag 标签的历史字节，每个number十六进制表示，范围是0x00~0xFF。如果该IsoDep类型Tag是基于NfcB技术的，则该返回值为空。| 299 300**示例：** 301 302```js 303import { tag } from '@kit.ConnectivityKit'; 304 305// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 isoDep 306let historicalBytes : number[] = isoDep.getHistoricalBytes(); 307console.info("isoDep historicalBytes: " + historicalBytes); 308``` 309 310### IsoDepTag.getHiLayerResponse<sup>9+</sup> 311 312getHiLayerResponse(): number[] 313 314获取标签的更高层响应字节，针对基于NfcB通信技术的IsoDep卡片。 315 316**系统能力：** SystemCapability.Communication.NFC.Tag 317 318**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 319 320**返回值：** 321 322| **类型** | **说明** | 323| ------------------ | --------------------------| 324| number[] | IsoDepTag 标签的更高层响应字节，每个number十六进制表示，范围是0x00~0xFF。如果该IsoDep类型Tag是基于NfcA技术的，则该返回值为空。| 325 326**示例：** 327 328```js 329import { tag } from '@kit.ConnectivityKit'; 330 331// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 isoDep 332let hiLayerResponse : number[] = isoDep.getHiLayerResponse(); 333console.info("isoDep hiLayerResponse: " + hiLayerResponse); 334``` 335 336### IsoDepTag.isExtendedApduSupported<sup>9+</sup> 337 338isExtendedApduSupported(): Promise<boolean> 339 340检查是否支持扩展的APDU，使用Promise方式作为异步方法。 341 342**需要权限：** ohos.permission.NFC_TAG 343 344**系统能力：** SystemCapability.Communication.NFC.Tag 345 346**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 347 348**返回值：** 349 350| **类型** | **说明** | 351| ------------------ | --------------------------| 352| Promise<boolean> | 以Promise形式返回检查结果，true: 支持， false: 不支持。| 353 354**错误码：** 355 356以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 357 358| 错误码ID | 错误信息| 359| ------- | -------| 360| 201 | Permission denied. | 361| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 362| 3100201 | The tag running state is abnormal in the service. | 363| 3100204 | The tag I/O operation failed. | 364 365**示例：** 366 367```js 368import { tag } from '@kit.ConnectivityKit'; 369import { BusinessError } from '@kit.BasicServicesKit'; 370 371// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 isoDep 372function nfcTechDemo() { 373 // 如果没有连接Tag，请先连接 374 if (!isoDep.isTagConnected()) { 375 if (!isoDep.connectTag()) { 376 console.error("isoDep connectTag failed."); 377 return; 378 } 379 } 380 381 try { 382 isoDep.isExtendedApduSupported().then((response: boolean) => { 383 console.info("isoDep isExtendedApduSupported Promise response: " + response); 384 }).catch((err: BusinessError) => { 385 console.error(`isoDep isExtendedApduSupported Promise Code: ${err.code}, message: ${err.message}`); 386 }); 387 } catch (businessError) { 388 console.error(`isoDep isExtendedApduSupported Promise Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 389 } 390} 391 392``` 393 394### IsoDepTag.isExtendedApduSupported<sup>9+</sup> 395 396isExtendedApduSupported(callback: AsyncCallback\<boolean>): void 397 398检查是否支持扩展的APDU，使用AsyncCallback方式作为异步方法。 399 400**需要权限：** ohos.permission.NFC_TAG 401 402**系统能力：** SystemCapability.Communication.NFC.Tag 403 404**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 405 406**参数：** 407 408| 参数名 | 类型 | 必填 | 说明 | 409| -------- | ----------------------- | ---- | -------------------------------------- | 410| callback | AsyncCallback\<boolean> | 是 | 回调函数，true: 支持， false: 不支持。 | 411 412**错误码：** 413 414以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 415 416| 错误码ID | 错误信息| 417| ------- | -------| 418| 201 | Permission denied. | 419| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 420| 3100201 | The tag running state is abnormal in the service. | 421| 3100204 | The Tag I/O operation failed. | 422 423**示例：** 424 425```js 426import { tag } from '@kit.ConnectivityKit'; 427import { BusinessError } from '@kit.BasicServicesKit'; 428 429// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 isoDep 430function nfcTechDemo() { 431 // 如果没有连接Tag，请先连接 432 if (!isoDep.isTagConnected()) { 433 if (!isoDep.connectTag()) { 434 console.error("isoDep connectTag failed."); 435 return; 436 } 437 } 438 439 try { 440 isoDep.isExtendedApduSupported((err: BusinessError, response: boolean) => { 441 if (err) { 442 console.error(`isoDep isExtendedApduSupported AsyncCallback Code: ${err.code}, message: ${err. message}`); 443 } else { 444 console.info("isoDep isExtendedApduSupported AsyncCallback response: " + response); 445 } 446 }); 447 } catch (businessError) { 448 console.error(`isoDep isExtendedApduSupported AsyncCallback Code: ${(businessError as Business).code}, message: ${(businessError as Business).message}`); 449 } 450} 451 452``` 453 454## NdefMessage<sup>9+</sup> 455 456### NdefMessage.getNdefRecords<sup>9+</sup> 457 458getNdefRecords(): [tag.NdefRecord](js-apis-nfcTag.md#ndefrecord9)[] 459 460获取NDEF消息中的所有记录。 461 462**系统能力：** SystemCapability.Communication.NFC.Tag 463 464**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 465 466**返回值：** 467 468| **类型** | **说明** | 469| ------------------ | --------------------------| 470| [tag.NdefRecord](js-apis-nfcTag.md#ndefrecord9)[] | NDEF标签的Record列表，详见NDEF技术规范《NFCForum-TS-NDEF_1.0》。 | 471 472**示例：** 473 474```js 475import { tag } from '@kit.ConnectivityKit'; 476 477// 从 tag.ndef.createNdefMessage 或 ndefTag.getNdefMessage 获取 ndefMessage。 478// let ndefMessage : tag.NdefMessage = tag.ndef.createNdefMessage(...); 479// let ndefMessage : tag.NdefMessage = ndefTag.getNdefMessage(); 480 481let ndefRecords : tag.NdefRecord[] = ndefMessage.getNdefRecords(); 482console.info("ndef ndefRecords number: " + ndefRecords.length); 483``` 484 485## NdefTag<sup>9+</sup> 486 487提供对已格式化为NDEF的NFC标签的数据和操作的访问，继承自TagSession。 488 489TagSession是所有NFC Tag技术类型的基类，提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 490 491NdefTag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 492 493以下是NdefTag的独有接口。 494 495### NdefTag.getNdefTagType<sup>9+</sup> 496 497getNdefTagType(): [tag.NfcForumType](js-apis-nfcTag.md#nfcforumtype9) 498 499获取NDEF标签的类型。 500 501**系统能力：** SystemCapability.Communication.NFC.Tag 502 503**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 504 505**返回值：** 506 507| **类型** | **说明** | 508| ------------------ | --------------------------| 509| [tag.NfcForumType](js-apis-nfcTag.md#nfcforumtype9) | NDEF标签类型，包括NFC FORUM TYPE 1/2/3/4等。| 510 511**示例：** 512 513```js 514import { tag } from '@kit.ConnectivityKit'; 515 516// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 517let ndefTagType : tag.NfcForumType = ndefTag.getNdefTagType(); 518console.info("ndef ndefTagType: " + ndefTagType); 519``` 520 521### NdefTag.getNdefMessage<sup>9+</sup> 522 523getNdefMessage(): [NdefMessage](#ndefmessage9) 524 525获取发现NDEF标签时，从标签读取的Message。 526 527**系统能力：** SystemCapability.Communication.NFC.Tag 528 529**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 530 531**返回值：** 532 533| **类型** | **说明** | 534| ------------------ | --------------------------| 535| [NdefMessage](#ndefmessage9) | NDEF标签的Message，详见NDEF技术规范《NFCForum-TS-NDEF_1.0》。| 536 537**示例：** 538```js 539import { tag } from '@kit.ConnectivityKit'; 540 541// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 542let ndefMessage : tag.NdefMessage = ndefTag.getNdefMessage(); 543console.info("ndef ndefMessage: " + ndefMessage); 544``` 545 546### NdefTag.isNdefWritable<sup>9+</sup> 547 548isNdefWritable(): boolean 549 550检查NDEF标签是否可写。在调用写数据接口前，需要先判断是否支持写操作。 551 552**系统能力：** SystemCapability.Communication.NFC.Tag 553 554**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 555 556**返回值：** 557 558| **类型** | **说明** | 559| ------------------ | --------------------------| 560| boolean | 检查结果，true: 可写， false: 不可写。| 561 562**示例：** 563 564```js 565import { tag } from '@kit.ConnectivityKit'; 566 567// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 568let isWritable : boolean = ndefTag.isNdefWritable(); 569console.info("ndef isNdefWritable: " + isWritable); 570``` 571 572### NdefTag.readNdef<sup>9+</sup> 573 574readNdef(): Promise\<[NdefMessage](#ndefmessage9)> 575 576读取标签上的NDEF消息，使用Promise方式作为异步方法。 577 578**需要权限：** ohos.permission.NFC_TAG 579 580**系统能力：** SystemCapability.Communication.NFC.Tag 581 582**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 583 584**返回值：** 585 586| **类型** | **说明** | 587| ------------------ | --------------------------| 588| Promise\<[NdefMessage](#ndefmessage9)> | 以Promise形式返回从NDEF标签中读取到的Message数据对象。| 589 590**错误码：** 591 592以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 593 594| 错误码ID | 错误信息| 595| ------- | -------| 596| 201 | Permission denied. | 597| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 598| 3100201 | The tag running state is abnormal in the service. | 599| 3100204 | The tag I/O operation failed. | 600 601**示例：** 602 603```js 604import { tag } from '@kit.ConnectivityKit'; 605import { BusinessError } from '@kit.BasicServicesKit'; 606 607// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 608function nfcTechDemo(){ 609 // 如果没有连接Tag，请先连接 610 if (!ndefTag.isTagConnected()) { 611 if (!ndefTag.connectTag()) { 612 console.error("ndefTag connectTag failed."); 613 return; 614 } 615 } 616 617 try { 618 ndefTag.readNdef().then((ndefmessage : tag.NdefMessage) => { 619 console.info("ndef readNdef Promise ndefmessage: " + ndefmessage); 620 }).catch((err : BusinessError)=> { 621 console.error("ndef readNdef Promise err Code: ${err.code}, message: ${err.message}"); 622 }); 623 } catch (businessError) { 624 console.error(`ndef readNdef Promise catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 625 } 626} 627 628``` 629 630### NdefTag.readNdef<sup>9+</sup> 631 632readNdef(callback: AsyncCallback\<[NdefMessage](#ndefmessage9)>): void 633 634读取标签上的NDEF消息，使用AsyncCallback方式作为异步方法。 635 636**需要权限：** ohos.permission.NFC_TAG 637 638**系统能力：** SystemCapability.Communication.NFC.Tag 639 640**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 641 642**参数：** 643 644| 参数名 | 类型 | 必填 | 说明 | 645| -------- | ----------------------- | ---- | -------------------------------------- | 646| callback | AsyncCallback\<[NdefMessage](#ndefmessage9)> | 是 | 回调函数，返回从NDEF标签中读取到的Message信息。| 647 648**错误码：** 649 650以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 651 652| 错误码ID | 错误信息| 653| ------- | -------| 654| 201 | Permission denied. | 655| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 656| 3100201 | The tag running state is abnormal in the service. | 657| 3100204 | The Tag I/O operation failed. | 658 659**示例：** 660 661```js 662import { tag } from '@kit.ConnectivityKit'; 663import { BusinessError } from '@kit.BasicServicesKit'; 664 665// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 666function nfcTechDemo() { 667 // 如果没有连接Tag，请先连接 668 if (!ndefTag.isTagConnected()) { 669 if (!ndefTag.connectTag()) { 670 console.error("ndefTag connectTag failed."); 671 return; 672 } 673 } 674 675 try { 676 ndefTag.readNdef((err : BusinessError, ndefmessage : tag.NdefMessage)=> { 677 if (err) { 678 console.error(`ndef readNdef AsyncCallback err Code: ${err.code}, message: ${err.message}`); 679 } else { 680 console.info("ndef readNdef AsyncCallback ndefmessage: " + ndefmessage); 681 } 682 }); 683 } catch (businessError) { 684 console.error(`ndef readNdef AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 685 } 686} 687 688``` 689 690### NdefTag.writeNdef<sup>9+</sup> 691 692writeNdef(msg: [NdefMessage](#ndefmessage9)): Promise\<void> 693 694将NDEF Message数据对象写入标签，使用Promise方式作为异步方法。 695 696**需要权限：** ohos.permission.NFC_TAG 697 698**系统能力：** SystemCapability.Communication.NFC.Tag 699 700**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 701 702**参数：** 703 704| 参数名 | 类型 | 必填 | 说明 | 705| -------- | ----------------------- | ---- | -------------------------------------- | 706| msg | [NdefMessage](#ndefmessage9) | 是 | NDEF Message数据对象。| 707 708**返回值：** 709 710| 类型 | 说明 | 711| ------------------------- | ------------------ | 712| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 713 714**错误码：** 715 716以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 717 718| 错误码ID | 错误信息| 719| ------- | -------| 720| 201 | Permission denied. | 721| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 722| 3100201 | The tag running state is abnormal in the service. | 723| 3100204 | The tag I/O operation failed. | 724 725**示例：** 726 727```js 728import { tag } from '@kit.ConnectivityKit'; 729import { BusinessError } from '@kit.BasicServicesKit'; 730 731// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 732// 从原始数据创建的ndefMessage，例如： 733let ndefMessage : tag.NdefMessage = 734 tag.ndef.createNdefMessage([0xD1, 0x01, 0x03, 0x54, 0x4E, 0x46, 0x43]); // 必须是可以被解析的NDEF记录。 735// 或从 tag.ndef.createNdefMessage(ndefRecords:NdefRecord[]) 创建 ndefMessage 736 737function nfcTechDemo() { 738 // 如果没有连接Tag，请先连接 739 if (!ndefTag.isTagConnected()) { 740 if (!ndefTag.connectTag()) { 741 console.error("ndefTag connectTag failed."); 742 return; 743 } 744 } 745 746 try { 747 ndefTag.writeNdef(ndefMessage).then(() => { 748 console.info("ndef writeNdef Promise success."); 749 }).catch((err : BusinessError)=> { 750 console.error(`ndef writeNdef err Code: ${err.code}, message: ${err.message}`); 751 }); 752 } catch (businessError) { 753 console.error(`ndef writeNdef Promise catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 754 } 755} 756``` 757 758### NdefTag.writeNdef<sup>9+</sup> 759 760writeNdef(msg: [NdefMessage](#ndefmessage9), callback: AsyncCallback\<void>): void 761 762将NDEF Message数据对象写入此标签，使用AsyncCallback方式作为异步方法。 763 764**需要权限：** ohos.permission.NFC_TAG 765 766**系统能力：** SystemCapability.Communication.NFC.Tag 767 768**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 769 770**参数：** 771 772| 参数名 | 类型 | 必填 | 说明 | 773| -------- | ----------------------- | ---- | -------------------------------------- | 774| msg | [NdefMessage](#ndefmessage9) | 是 | NDEF Message数据对象。 | 775| callback | AsyncCallback\<void> | 是 | 回调函数。当NDEF Message数据对象写入成功时，err为undefined，否则为错误对象。| 776 777**错误码：** 778 779以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 780 781| 错误码ID | 错误信息| 782| ------- | -------| 783| 201 | Permission denied. | 784| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 785| 3100201 | The tag running state is abnormal in the service. | 786| 3100204 | The Tag I/O operation failed. | 787 788**示例：** 789 790```js 791import { tag } from '@kit.ConnectivityKit'; 792import { BusinessError } from '@kit.BasicServicesKit'; 793 794// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 795// 从原始数据创建的ndefMessage，例如： 796let ndefMessage : tag.NdefMessage = 797 tag.ndef.createNdefMessage([0xD1, 0x01, 0x03, 0x54, 0x4E, 0x46, 0x43]); // 必须是可以被解析的NDEF记录。 798// 或从 tag.ndef.createNdefMessage(ndefRecords:NdefRecord[]) 创建 ndefMessage 799 800function nfcTechDemo() { 801 // 如果没有连接Tag，请先连接 802 if (!ndefTag.isTagConnected()) { 803 if (!ndefTag.connectTag()) { 804 console.error("ndefTag connectTag failed."); 805 return; 806 } 807 } 808 809 try { 810 ndefTag.writeNdef(ndefMessage, (err : BusinessError)=> { 811 if (err) { 812 console.error("ndef writeNdef AsyncCallback Code: ${err.code}, message: ${err.message}"); 813 } else { 814 console.info("ndef writeNdef AsyncCallback success."); 815 } 816 }); 817 } catch (businessError) { 818 console.error(`ndef writeNdef AsyncCallback catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 819 } 820} 821``` 822 823### NdefTag.canSetReadOnly<sup>9+</sup> 824 825canSetReadOnly(): boolean 826 827检查NDEF标签是否可以设置为只读。 828 829**需要权限：** ohos.permission.NFC_TAG 830 831**系统能力：** SystemCapability.Communication.NFC.Tag 832 833**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 834 835**返回值：** 836 837| **类型** | **说明** | 838| ------------------ | --------------------------| 839| boolean| true: NDEF标签可设置为只读， false: NDEF标签不可设置为只读。 | 840 841**错误码：** 842 843以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 844 845| 错误码ID | 错误信息| 846| ------- | -------| 847| 201 | Permission denied. | 848| 3100201 | The tag running state is abnormal in the service. | 849 850**示例：** 851 852```js 853import { tag } from '@kit.ConnectivityKit'; 854 855// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 856let canSetReadOnly : boolean = ndefTag.canSetReadOnly(); 857console.info("ndef canSetReadOnly: " + canSetReadOnly); 858``` 859 860### NdefTag.setReadOnly<sup>9+</sup> 861 862setReadOnly(): Promise\<void> 863 864将NDEF标签设置为只读，使用Promise方式作为异步方法。 865 866**需要权限：** ohos.permission.NFC_TAG 867 868**系统能力：** SystemCapability.Communication.NFC.Tag 869 870**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 871 872**返回值：** 873 874| 类型 | 说明 | 875| ------------------------- | ------------------ | 876| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 877 878**错误码：** 879 880以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 881 882| 错误码ID | 错误信息| 883| ------- | -------| 884| 201 | Permission denied. | 885| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 886| 3100201 | The tag running state is abnormal in the service. | 887| 3100204 | The tag I/O operation failed. | 888 889**示例：** 890 891```js 892import { tag } from '@kit.ConnectivityKit'; 893import { BusinessError } from '@kit.BasicServicesKit'; 894 895// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 896 897function nfcTechDemo() { 898 // 如果没有连接Tag，请先连接 899 if (!ndefTag.isTagConnected()) { 900 if (!ndefTag.connectTag()) { 901 console.error("ndefTag connectTag failed."); 902 return; 903 } 904 } 905 906 try { 907 ndefTag.setReadOnly().then(() => { 908 console.info("ndef setReadOnly Promise success."); 909 }).catch((err : BusinessError)=> { 910 console.error("ndef setReadOnly Promise err Code: ${err.code}, message: ${err.message}"); 911 }); 912 } catch (businessError) { 913 console.error(`ndef setReadOnly Promise catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 914 } 915} 916``` 917 918### NdefTag.setReadOnly<sup>9+</sup> 919 920setReadOnly(callback: AsyncCallback\<void>): void 921 922将NDEF标签设置为只读，使用AsyncCallback方式作为异步方法。 923 924**需要权限：** ohos.permission.NFC_TAG 925 926**系统能力：** SystemCapability.Communication.NFC.Tag 927 928**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 929 930**参数：** 931 932| 参数名 | 类型 | 必填 | 说明 | 933| -------- | ----------------------- | ---- | -------------------------------------- | 934| callback | AsyncCallback\<void> | 是 | 回调函数。当NDEF标签设置为只读成功时，err为undefined，否则为错误对象。 | 935 936**错误码：** 937 938以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 939 940| 错误码ID | 错误信息| 941| ------- | -------| 942| 201 | Permission denied. | 943| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 944| 3100201 | The tag running state is abnormal in the service. | 945| 3100204 | The Tag I/O operation failed. | 946 947**示例：** 948 949```js 950import { tag } from '@kit.ConnectivityKit'; 951import { BusinessError } from '@kit.BasicServicesKit'; 952 953// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 954 955function nfcTechDemo() { 956 // 如果没有连接Tag，请先连接 957 if (!ndefTag.isTagConnected()) { 958 if (!ndefTag.connectTag()) { 959 console.error("ndefTag connectTag failed."); 960 return; 961 } 962 } 963 964 try { 965 ndefTag.setReadOnly((err : BusinessError)=> { 966 if (err) { 967 console.error(`ndef setReadOnly AsyncCallback err Code: ${err.code}, message: ${err.message}`); 968 } else { 969 console.info("ndef setReadOnly AsyncCallback success."); 970 } 971 }); 972 } catch (businessError) { 973 console.error(`ndef setReadOnly AsyncCallback catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 974 } 975} 976``` 977 978### NdefTag.getNdefTagTypeString<sup>9+</sup> 979 980getNdefTagTypeString(type: [tag.NfcForumType](js-apis-nfcTag.md#nfcforumtype9)): string 981 982将NFC论坛类型，转换为NFC论坛中定义的字符串描述。 983 984**系统能力：** SystemCapability.Communication.NFC.Tag 985 986**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 987 988**参数：** 989 990| 参数名 | 类型 | 必填 | 说明 | 991| -------- | ----------------------- | ---- | -------------------------------------- | 992| type | [tag.NfcForumType](js-apis-nfcTag.md#nfcforumtype9) | 是 | NDEF标签类型，包括NFC FORUM TYPE 1/2/3/4等。 | 993 994**返回值：** 995 996| **类型** | **说明** | 997| ------------------ | --------------------------| 998| string | NFC论坛类型的字符串描述。| 999 1000**错误码：** 1001 1002以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1003 1004| 错误码ID | 错误信息| 1005| ------- | -------| 1006| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1007 1008**示例：** 1009 1010```js 1011import { tag } from '@kit.ConnectivityKit'; 1012import { BusinessError } from '@kit.BasicServicesKit'; 1013 1014// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefTag 1015 1016try { 1017 let ndefTypeString : string = ndefTag.getNdefTagTypeString(tag.NfcForumType.NFC_FORUM_TYPE_1); 1018 console.info("ndef ndefTypeString: " + ndefTypeString); 1019} catch (businessError) { 1020 console.error(`ndef getNdefTagTypeString catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1021} 1022``` 1023 1024## MifareClassicTag<sup>9+</sup> 1025 1026MifareClassicTag提供对MIFARE Classic属性和I/O操作的访问，继承自[TagSession](js-apis-tagSession.md)。 1027 1028TagSession是所有NFC Tag技术类型的基类， 提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 1029 1030MifareClassicTag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 1031 1032以下是MifareClassicTag的独有接口。 1033 1034### MifareClassicTag.authenticateSector<sup>9+</sup> 1035 1036authenticateSector(sectorIndex: number, key: number[], isKeyA: boolean): Promise\<void> 1037 1038使用密钥对扇区进行身份验证，只有身份验证成功的扇区可以进行操作。使用Promise方式作为异步方法。 1039 1040**需要权限：** ohos.permission.NFC_TAG 1041 1042**系统能力：** SystemCapability.Communication.NFC.Tag 1043 1044**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1045 1046**参数：** 1047 1048| 参数名 | 类型 | 必填 | 说明 | 1049| -------- | ----------------------- | ---- | -------------------------------------- | 1050| sectorIndex | number | 是 | 待验证的扇区索引，从0开始。 | 1051| key | number[]| 是 | 用于扇区验证的密钥（6字节）。 | 1052| isKeyA | boolean | 是 | isKeyA标志。true 表示KeyA，false 表示KeyB。| 1053 1054**返回值：** 1055 1056| 类型 | 说明 | 1057| ------------------------- | ------------------ | 1058| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 1059 1060**错误码：** 1061 1062以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1063 1064| 错误码ID | 错误信息| 1065| ------- | -------| 1066| 201 | Permission denied. | 1067| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1068| 3100201 | The tag running state is abnormal in the service. | 1069| 3100204 | The tag I/O operation failed. | 1070 1071**示例：** 1072 1073```js 1074import { tag } from '@kit.ConnectivityKit'; 1075import { BusinessError } from '@kit.BasicServicesKit'; 1076 1077// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1078 1079function nfcTechDemo() { 1080 // 如果没有连接Tag，请先连接 1081 if (!mifareClassic.isTagConnected()) { 1082 if (!mifareClassic.connectTag()) { 1083 console.error("mifareClassic connectTag failed."); 1084 return; 1085 } 1086 } 1087 1088 try { 1089 let sectorIndex = 1; // 将其更改为正确的 index 1090 let key = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06] //必须是6个字节，将其更改为正确的key 1091 mifareClassic.authenticateSector(sectorIndex, key, true).then(() => { 1092 console.info("mifareClassic authenticateSector Promise success."); 1093 }).catch((err : BusinessError)=> { 1094 console.error("mifareClassic authenticateSector Promise errCode: ${err.code}, " + "message: ${err.message}"); 1095 }); 1096 } catch (businessError) { 1097 console.error(`mifareClassic authenticateSector Promise catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1098 } 1099} 1100``` 1101 1102### MifareClassicTag.authenticateSector<sup>9+</sup> 1103 1104authenticateSector(sectorIndex: number, key: number[], isKeyA: boolean, callback: AsyncCallback\<void>): void 1105 1106使用密钥对扇区进行身份验证，只有身份验证成功的扇区可以进行操作。使用AsyncCallback方式作为异步方法。 1107 1108**需要权限：** ohos.permission.NFC_TAG 1109 1110**系统能力：** SystemCapability.Communication.NFC.Tag 1111 1112**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1113 1114**参数：** 1115 1116| 参数名 | 类型 | 必填 | 说明 | 1117| -------- | ----------------------- | ---- | -------------------------------------- | 1118| sectorIndex | number | 是 | 待验证的扇区索引，从0开始。 | 1119| key | number[]| 是 | 用于扇区验证的密钥（6字节）。 | 1120| isKeyA | boolean | 是 | isKeyA标志。true 表示KeyA，false 表示KeyB。| 1121| callback | AsyncCallback\<void> | 是 | 回调函数。当身份验证成功时，err为undefined，否则为错误对象。| 1122 1123**错误码：** 1124 1125以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1126 1127| 错误码ID | 错误信息| 1128| ------- | -------| 1129| 201 | Permission denied. | 1130| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1131| 3100201 | The tag running state is abnormal in the service. | 1132| 3100204 | The Tag I/O operation failed. | 1133 1134**示例：** 1135```js 1136import { tag } from '@kit.ConnectivityKit'; 1137import { BusinessError } from '@kit.BasicServicesKit'; 1138 1139// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1140 1141function nfcTechDemo() { 1142 // 如果没有连接Tag，请先连接 1143 if (!mifareClassic.isTagConnected()) { 1144 if (!mifareClassic.connectTag()) { 1145 console.error("mifareClassic connectTag failed."); 1146 return; 1147 } 1148 } 1149 1150 try { 1151 let sectorIndex = 1; // 将其更改为正确的 index 1152 let key = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06] // 必须是6个字节，将其更改为正确的key 1153 mifareClassic.authenticateSector(sectorIndex, key, true, (err : BusinessError)=> { 1154 if (err) { 1155 console.error(`mifareClassic authenticateSector AsyncCallback errCode: ${err.code}, message: ${err.message}`); 1156 } else { 1157 console.info("mifareClassic authenticateSector AsyncCallback success."); 1158 } 1159 }); 1160 } catch (businessError) { 1161 console.error(`mifareClassic authenticateSector AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1162 } 1163} 1164``` 1165 1166### MifareClassicTag.readSingleBlock<sup>9+</sup> 1167 1168readSingleBlock(blockIndex: number): Promise\<number[]> 1169 1170读取标签中一个块存储的内容，一个块大小为16字节。使用Promise方式作为异步方法。 1171 1172**需要权限：** ohos.permission.NFC_TAG 1173 1174**系统能力：** SystemCapability.Communication.NFC.Tag 1175 1176**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1177 1178**参数：** 1179 1180| 参数名 | 类型 | 必填 | 说明 | 1181| -------- | ----------------------- | ---- | -------------------------------------- | 1182| blockIndex | number | 是 | 要读取的块索引，从0开始。 | 1183 1184**返回值：** 1185 1186| **类型** | **说明** | 1187| ------------------ | --------------------------| 1188| Promise\<number[]> | 以Promise形式返回读取的块数据。 | 1189 1190**错误码：** 1191 1192以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1193 1194| 错误码ID | 错误信息| 1195| ------- | -------| 1196| 201 | Permission denied. | 1197| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1198| 3100201 | The tag running state is abnormal in the service. | 1199| 3100204 | The tag I/O operation failed. | 1200 1201**示例：** 1202 1203```js 1204import { tag } from '@kit.ConnectivityKit'; 1205import { BusinessError } from '@kit.BasicServicesKit'; 1206 1207// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1208 1209function nfcTechDemo() { 1210 // 如果没有连接Tag，请先连接 1211 if (!mifareClassic.isTagConnected()) { 1212 if (!mifareClassic.connectTag()) { 1213 console.error("mifareClassic connectTag failed."); 1214 return; 1215 } 1216 } 1217 1218 try { 1219 let blockIndex = 1; // 将其更改为正确的 index 1220 mifareClassic.readSingleBlock(blockIndex).then((data : number[]) => { 1221 console.info("mifareClassic readSingleBlock Promise data: " + data); 1222 }).catch((err : BusinessError)=> { 1223 console.error(`mifareClassic readSingleBlock Promise errCode: ${err.code}, message: ${err.message}`); 1224 }); 1225 } catch (businessError) { 1226 console.error(`mifareClassic readSingleBlock Promise catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1227 } 1228} 1229``` 1230 1231### MifareClassicTag.readSingleBlock<sup>9+</sup> 1232 1233readSingleBlock(blockIndex: number, callback: AsyncCallback\<number[]>): void 1234 1235读取标签中一个块存储的内容，一个块大小为16字节。使用AsyncCallback方式作为异步方法。 1236 1237**需要权限：** ohos.permission.NFC_TAG 1238 1239**系统能力：** SystemCapability.Communication.NFC.Tag 1240 1241**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1242 1243**参数：** 1244 1245| 参数名 | 类型 | 必填 | 说明 | 1246| -------- | ----------------------- | ---- | -------------------------------------- | 1247| blockIndex | number | 是 | 要读取的块索引，从0开始。 | 1248| callback | AsyncCallback\<number[]> | 是 |以callback形式异步返回读取到的块数据。 | 1249 1250**错误码：** 1251 1252以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1253 1254| 错误码ID | 错误信息| 1255| ------- | -------| 1256| 201 | Permission denied. | 1257| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1258| 3100201 | The tag running state is abnormal in the service. | 1259| 3100204 | The Tag I/O operation failed. | 1260 1261**示例：** 1262 1263```js 1264import { tag } from '@kit.ConnectivityKit'; 1265import { BusinessError } from '@kit.BasicServicesKit'; 1266 1267// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1268 1269function nfcTechDemo() { 1270 // 如果没有连接Tag，请先连接 1271 if (!mifareClassic.isTagConnected()) { 1272 if (!mifareClassic.connectTag()) { 1273 console.error("mifareClassic connectTag failed."); 1274 return; 1275 } 1276 } 1277 1278 try { 1279 let blockIndex = 1; // 将其更改为正确的 index 1280 mifareClassic.readSingleBlock(blockIndex, (err : BusinessError, data : number[])=> { 1281 if (err) { 1282 console.error("mifareClassic readSingleBlock AsyncCallback err: " + err); 1283 } else { 1284 console.info("mifareClassic readSingleBlock AsyncCallback data: " + data); 1285 } 1286 }); 1287 } catch (businessError) { 1288 console.error(`mifareClassic readSingleBlock AsyncCallback catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1289 } 1290} 1291``` 1292 1293### MifareClassicTag.writeSingleBlock<sup>9+</sup> 1294 1295writeSingleBlock(blockIndex: number, data: number[]): Promise\<void> 1296 1297向标签中一个块存储写入内容，一个块大小为16字节。使用Promise方式作为异步方法。 1298 1299**需要权限：** ohos.permission.NFC_TAG 1300 1301**系统能力：** SystemCapability.Communication.NFC.Tag 1302 1303**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1304 1305**参数：** 1306 1307| 参数名 | 类型 | 必填 | 说明 | 1308| -------- | ----------------------- | ---- | -------------------------------------- | 1309| blockIndex | number | 是 | 要写入的块索引，从0开始。 | 1310| data | number[] | 是 | 要写入的数据，大小必须是16个字节。 | 1311 1312**返回值：** 1313 1314| 类型 | 说明 | 1315| ------------------------- | ------------------ | 1316| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 1317 1318**错误码：** 1319 1320以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1321 1322| 错误码ID | 错误信息| 1323| ------- | -------| 1324| 201 | Permission denied. | 1325| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1326| 3100201 | The tag running state is abnormal in the service. | 1327| 3100204 | The tag I/O operation failed. | 1328 1329**示例：** 1330 1331```js 1332import { tag } from '@kit.ConnectivityKit'; 1333import { BusinessError } from '@kit.BasicServicesKit'; 1334 1335// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1336 1337function nfcTechDemo() { 1338 // 如果没有连接Tag，请先连接 1339 if (!mifareClassic.isTagConnected()) { 1340 if (!mifareClassic.connectTag()) { 1341 console.error("mifareClassic connectTag failed."); 1342 return; 1343 } 1344 } 1345 1346 try { 1347 let blockIndex = 1; // 将其更改为正确的 index 1348 let rawData = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 1349 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10]; // 必须是16个字节，将其更改为正确的key 1350 mifareClassic.writeSingleBlock(blockIndex, rawData).then(() => { 1351 console.info("mifareClassic writeSingleBlock Promise success."); 1352 }).catch((err : BusinessError)=> { 1353 console.error("mifareClassic writeSingleBlock Promise errCode: ${err.code}, message: ${err.message}"); 1354 }); 1355 } catch (businessError) { 1356 console.error(`mifareClassic writeSingleBlock Promise catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1357 } 1358} 1359``` 1360 1361### MifareClassicTag.writeSingleBlock<sup>9+</sup> 1362 1363writeSingleBlock(blockIndex: number, data: number[], callback: AsyncCallback\<void>): void 1364 1365向标签中一个块存储写入内容，一个块大小为16字节。使用AsyncCallback方式作为异步方法。 1366 1367**需要权限：** ohos.permission.NFC_TAG 1368 1369**系统能力：** SystemCapability.Communication.NFC.Tag 1370 1371**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1372 1373**参数：** 1374 1375| 参数名 | 类型 | 必填 | 说明 | 1376| -------- | ----------------------- | ---- | -------------------------------------- | 1377| blockIndex | number | 是 | 要写入的块索引，从0开始。 | 1378| data | number[] | 是 | 要写入的数据，大小必须是16个字节。 | 1379| callback | AsyncCallback\<void> | 是 | 回调函数。当向块存储写入内容成功时，err为undefined，否则为错误对象。 | 1380 1381**错误码：** 1382 1383以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1384 1385| 错误码ID | 错误信息| 1386| ------- | -------| 1387| 201 | Permission denied. | 1388| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1389| 3100201 | The tag running state is abnormal in the service. | 1390| 3100204 | The Tag I/O operation failed. | 1391 1392**示例：** 1393 1394```js 1395import { tag } from '@kit.ConnectivityKit'; 1396import { BusinessError } from '@kit.BasicServicesKit'; 1397 1398// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1399 1400function nfcTechDemo() { 1401 // 如果没有连接Tag，请先连接 1402 if (!mifareClassic.isTagConnected()) { 1403 if (!mifareClassic.connectTag()) { 1404 console.error("mifareClassic connectTag failed."); 1405 return; 1406 } 1407 } 1408 1409 try { 1410 let blockIndex = 1; // 将其更改为正确的 index 1411 let rawData = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 1412 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10]; //必须是16个字节，将其更改为正确的data 1413 mifareClassic.writeSingleBlock(blockIndex, rawData, (err : BusinessError)=> { 1414 if (err) { 1415 console.error(`mifareClassic writeSingleBlock AsyncCallback err Code: ${err.code}, message: ${err.message}`); 1416 } else { 1417 console.info("mifareClassic writeSingleBlock AsyncCallback success."); 1418 } 1419 }); 1420 } catch (businessError) { 1421 console.error(`mifareClassic writeSingleBlock AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1422 } 1423} 1424``` 1425 1426### MifareClassicTag.incrementBlock<sup>9+</sup> 1427 1428incrementBlock(blockIndex: number, value: number): Promise\<void> 1429 1430对指定块的内容，增加指定的数值，并将结果存储在内部传输缓冲器中。使用Promise方式作为异步方法。 1431 1432**需要权限：** ohos.permission.NFC_TAG 1433 1434**系统能力：** SystemCapability.Communication.NFC.Tag 1435 1436**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1437 1438**参数：** 1439 1440| 参数名 | 类型 | 必填 | 说明 | 1441| -------- | ----------------------- | ---- | -------------------------------------- | 1442| blockIndex | number | 是 | 要指定增加的块索引，从0开始。 | 1443| value | number | 是 | 要指定增加的数据，非负数。 | 1444 1445**返回值：** 1446 1447| 类型 | 说明 | 1448| ------------------------- | ------------------ | 1449| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 1450 1451**错误码：** 1452 1453以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1454 1455| 错误码ID | 错误信息| 1456| ------- | -------| 1457| 201 | Permission denied. | 1458| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1459| 3100201 | The tag running state is abnormal in the service. | 1460| 3100204 | The tag I/O operation failed. | 1461 1462**示例：** 1463 1464```js 1465import { tag } from '@kit.ConnectivityKit'; 1466import { BusinessError } from '@kit.BasicServicesKit'; 1467 1468// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1469 1470function nfcTechDemo() { 1471 // 如果没有连接Tag，请先连接 1472 if (!mifareClassic.isTagConnected()) { 1473 if (!mifareClassic.connectTag()) { 1474 console.error("mifareClassic connectTag failed."); 1475 return; 1476 } 1477 } 1478 1479 try { 1480 let blockIndex = 1; // 将其更改为正确的 index 1481 let value = 0x20; // 将其更改为正确的数据 1482 mifareClassic.incrementBlock(blockIndex, value).then(() => { 1483 console.info("mifareClassic incrementBlock Promise success."); 1484 }).catch((err : BusinessError)=> { 1485 console.error(`mifareClassic incrementBlock Promise err Code: ${err.code}, message: ${err.message}`); 1486 }); 1487 } catch (businessError) { 1488 console.error(`mifareClassic incrementBlock Promise catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1489 } 1490} 1491``` 1492 1493### MifareClassicTag.incrementBlock<sup>9+</sup> 1494 1495incrementBlock(blockIndex: number, value: number, callback: AsyncCallback\<void>): void 1496 1497对指定块的内容，增加指定的数值，并将结果存储在内部传输缓冲器中。使用AsyncCallback方式作为异步方法。 1498 1499**需要权限：** ohos.permission.NFC_TAG 1500 1501**系统能力：** SystemCapability.Communication.NFC.Tag 1502 1503**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1504 1505**参数：** 1506 1507| 参数名 | 类型 | 必填 | 说明 | 1508| -------- | ----------------------- | ---- | -------------------------------------- | 1509| blockIndex | number | 是 | 要被运算的块索引，从0开始。 | 1510| value | number | 是 | 要增加的数值，非负数。 | 1511| callback | AsyncCallback\<void> | 是 | 回调函数。当对块增加指定数值成功时，err为undefined，否则为错误对象。| 1512 1513**错误码：** 1514 1515以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1516 1517| 错误码ID | 错误信息| 1518| ------- | -------| 1519| 201 | Permission denied. | 1520| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1521| 3100201 | The tag running state is abnormal in the service. | 1522| 3100204 | The Tag I/O operation failed. | 1523 1524**示例：** 1525 1526```js 1527import { tag } from '@kit.ConnectivityKit'; 1528import { BusinessError } from '@kit.BasicServicesKit'; 1529 1530// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1531 1532function nfcTechDemo() { 1533 // 如果没有连接Tag，请先连接 1534 if (!mifareClassic.isTagConnected()) { 1535 if (!mifareClassic.connectTag()) { 1536 console.error("mifareClassic connectTag failed."); 1537 return; 1538 } 1539 } 1540 1541 try { 1542 let blockIndex = 1; // 将其更改为正确的 index 1543 let value = 0x20; // 将其更改为正确的数据 1544 mifareClassic.incrementBlock(blockIndex, value, (err : BusinessError)=> { 1545 if (err) { 1546 console.error(`mifareClassic incrementBlock AsyncCallback err Code: ${err.code}, message: ${err.message}`); 1547 } else { 1548 console.info("mifareClassic incrementBlock AsyncCallback success."); 1549 } 1550 }); 1551 } catch (businessError) { 1552 console.error(`mifareClassic incrementBlock AsyncCallback catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1553 } 1554} 1555``` 1556 1557### MifareClassicTag.decrementBlock<sup>9+</sup> 1558 1559decrementBlock(blockIndex: number, value: number): Promise\<void> 1560 1561对指定块的内容，减少指定的数值，并将结果存储在内部传输缓冲器中。使用Promise方式作为异步方法。 1562 1563**需要权限：** ohos.permission.NFC_TAG 1564 1565**系统能力：** SystemCapability.Communication.NFC.Tag 1566 1567**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1568 1569**参数：** 1570 1571| 参数名 | 类型 | 必填 | 说明 | 1572| -------- | ----------------------- | ---- | -------------------------------------- | 1573| blockIndex | number | 是 | 要被运算的块索引，从0开始。 | 1574| value | number | 是 | 要减少的数值，非负数。 | 1575 1576**返回值：** 1577 1578| 类型 | 说明 | 1579| ------------------------- | ------------------ | 1580| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 1581 1582**错误码：** 1583 1584以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1585 1586| 错误码ID | 错误信息| 1587| ------- | -------| 1588| 201 | Permission denied. | 1589| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1590| 3100201 | The tag running state is abnormal in the service. | 1591| 3100204 | The tag I/O operation failed. | 1592 1593**示例：** 1594 1595```js 1596import { tag } from '@kit.ConnectivityKit'; 1597import { BusinessError } from '@kit.BasicServicesKit'; 1598 1599// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1600 1601function nfcTechDemo() { 1602 // 如果没有连接Tag，请先连接 1603 if (!mifareClassic.isTagConnected()) { 1604 if (!mifareClassic.connectTag()) { 1605 console.error("mifareClassic connectTag failed."); 1606 return; 1607 } 1608 } 1609 1610 try { 1611 let blockIndex = 1; // 将其更改为正确的 index 1612 let value = 0x20; // 将其更改为正确的数据 1613 mifareClassic.decrementBlock(blockIndex, value).then(() => { 1614 console.info("mifareClassic decrementBlock Promise success."); 1615 }).catch((err : BusinessError)=> { 1616 console.error("mifareClassic decrementBlock Promise errCode: ${err.code}, message: ${err.message}"); 1617 }); 1618 } catch (businessError) { 1619 console.error(`mifareClassic decrementBlock Promise catch businessError: Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1620 } 1621} 1622``` 1623 1624### MifareClassicTag.decrementBlock<sup>9+</sup> 1625 1626decrementBlock(blockIndex: number, value: number, callback: AsyncCallback\<void>): void 1627 1628对指定块的内容，减少指定的数值。使用AsyncCallback方式作为异步方法。 1629 1630**需要权限：** ohos.permission.NFC_TAG 1631 1632**系统能力：** SystemCapability.Communication.NFC.Tag 1633 1634**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1635 1636**参数：** 1637 1638| 参数名 | 类型 | 必填 | 说明 | 1639| -------- | ----------------------- | ---- | -------------------------------------- | 1640| blockIndex | number | 是 | 要被运算的块索引，从0开始。 | 1641| value | number | 是 | 要减少的数值，非负数。 | 1642| callback | AsyncCallback\<void> | 是 | 回调函数。当对块减少指定数值成功时，err为undefined，否则为错误对象。 | 1643 1644**错误码：** 1645 1646以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1647 1648| 错误码ID | 错误信息| 1649| ------- | -------| 1650| 201 | Permission denied. | 1651| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1652| 3100201 | The tag running state is abnormal in the service. | 1653| 3100204 | The Tag I/O operation failed. | 1654 1655**示例：** 1656 1657```js 1658import { tag } from '@kit.ConnectivityKit'; 1659import { BusinessError } from '@kit.BasicServicesKit'; 1660 1661// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1662 1663function nfcTechDemo() { 1664 // 如果没有连接Tag，请先连接 1665 if (!mifareClassic.isTagConnected()) { 1666 if (!mifareClassic.connectTag()) { 1667 console.error("mifareClassic connectTag failed."); 1668 return; 1669 } 1670 } 1671 1672 try { 1673 let blockIndex = 1; // 将其更改为正确的 index 1674 let value = 0x20; // 将其更改为正确的数据 1675 mifareClassic.decrementBlock(blockIndex, value, (err : BusinessError)=> { 1676 if (err) { 1677 console.error("mifareClassic decrementBlock AsyncCallback errCode:" + 1678 "${err.code}, message: ${err.message}"); 1679 } else { 1680 console.info("mifareClassic decrementBlock AsyncCallback success."); 1681 } 1682 }); 1683 } catch (businessError) { 1684 console.error(`mifareClassic decrementBlock AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1685 } 1686} 1687``` 1688 1689### MifareClassicTag.transferToBlock<sup>9+</sup> 1690 1691transferToBlock(blockIndex: number): Promise\<void> 1692 1693将临时寄存器的值转移到指定的块。使用Promise方式作为异步方法。 1694 1695**需要权限：** ohos.permission.NFC_TAG 1696 1697**系统能力：** SystemCapability.Communication.NFC.Tag 1698 1699**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1700 1701**参数：** 1702 1703| 参数名 | 类型 | 必填 | 说明 | 1704| -------- | ----------------------- | ---- | -------------------------------------- | 1705| blockIndex | number | 是 | 被操作的块的索引，从0开始。 | 1706 1707**返回值：** 1708 1709| 类型 | 说明 | 1710| ------------------------- | ------------------ | 1711| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 1712 1713**错误码：** 1714 1715以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1716 1717| 错误码ID | 错误信息| 1718| ------- | -------| 1719| 201 | Permission denied. | 1720| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1721| 3100201 | The tag running state is abnormal in the service. | 1722| 3100204 | The tag I/O operation failed. | 1723 1724**示例：** 1725 1726```js 1727import { tag } from '@kit.ConnectivityKit'; 1728import { BusinessError } from '@kit.BasicServicesKit'; 1729 1730// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1731 1732function nfcTechDemo() { 1733 // 如果没有连接Tag，请先连接 1734 if (!mifareClassic.isTagConnected()) { 1735 if (!mifareClassic.connectTag()) { 1736 console.error("mifareClassic connectTag failed."); 1737 return; 1738 } 1739 } 1740 1741 try { 1742 let blockIndex = 1; // 将其更改为正确的 index 1743 mifareClassic.transferToBlock(blockIndex).then(() => { 1744 console.info("mifareClassic transferToBlock Promise success."); 1745 }).catch((err : BusinessError)=> { 1746 console.error(`mifareClassic transferToBlock Promise err Code: ${err.code}, message: ${err.message}`); 1747 }); 1748 } catch (businessError) { 1749 console.error(`mifareClassic transferToBlock Promise catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}"); 1750 } 1751} 1752``` 1753 1754### MifareClassicTag.transferToBlock<sup>9+</sup> 1755 1756transferToBlock(blockIndex: number, callback: AsyncCallback\<void>): void 1757 1758将临时寄存器的值转移到指定的块。使用AsyncCallback方式作为异步方法。 1759 1760**需要权限：** ohos.permission.NFC_TAG 1761 1762**系统能力：** SystemCapability.Communication.NFC.Tag 1763 1764**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1765 1766**参数：** 1767 1768| 参数名 | 类型 | 必填 | 说明 | 1769| -------- | ----------------------- | ---- | -------------------------------------- | 1770| blockIndex | number | 是 | 被操作的块的索引，从0开始。 | 1771| callback | AsyncCallback\<void> | 是 | 回调函数。当临时寄存器的值转移到指定块成功时，err为undefined，否则为错误对象。| 1772 1773**错误码：** 1774 1775以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1776 1777| 错误码ID | 错误信息| 1778| ------- | -------| 1779| 201 | Permission denied. | 1780| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1781| 3100201 | The tag running state is abnormal in the service. | 1782| 3100204 | The Tag I/O operation failed. | 1783 1784**示例：** 1785 1786```js 1787import { tag } from '@kit.ConnectivityKit'; 1788import { BusinessError } from '@kit.BasicServicesKit'; 1789 1790// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1791 1792function nfcTechDemo() { 1793 // 如果没有连接Tag，请先连接 1794 if (!mifareClassic.isTagConnected()) { 1795 if (!mifareClassic.connectTag()) { 1796 console.error("mifareClassic connectTag failed."); 1797 return; 1798 } 1799 } 1800 1801 try { 1802 let blockIndex = 1; // 将其更改为正确的 index 1803 mifareClassic.transferToBlock(blockIndex, (err : BusinessError)=> { 1804 if (err) { 1805 console.error(`mifareClassic transferToBlock AsyncCallback errCode: ${err.code}, message: ${err.message}`); 1806 } else { 1807 console.info("mifareClassic transferToBlock AsyncCallback success."); 1808 } 1809 }); 1810 } catch (businessError) { 1811 console.error(`mifareClassic transferToBlock AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1812 } 1813} 1814``` 1815 1816### MifareClassicTag.restoreFromBlock<sup>9+</sup> 1817 1818restoreFromBlock(blockIndex: number): Promise\<void> 1819 1820将指定块的值复制到临时寄存器。使用Promise方式作为异步方法。 1821 1822**需要权限：** ohos.permission.NFC_TAG 1823 1824**系统能力：** SystemCapability.Communication.NFC.Tag 1825 1826**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1827 1828**参数：** 1829 1830| 参数名 | 类型 | 必填 | 说明 | 1831| -------- | ----------------------- | ---- | -------------------------------------- | 1832| blockIndex | number | 是 | 被操作的块的索引，从0开始。| 1833 1834**返回值：** 1835 1836| 类型 | 说明 | 1837| ------------------------- | ------------------ | 1838| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 1839 1840**错误码：** 1841 1842以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1843 1844| 错误码ID | 错误信息| 1845| ------- | -------| 1846| 201 | Permission denied. | 1847| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1848| 3100201 | The tag running state is abnormal in the service. | 1849| 3100204 | The tag I/O operation failed. | 1850 1851**示例：** 1852 1853```js 1854import { tag } from '@kit.ConnectivityKit'; 1855import { BusinessError } from '@kit.BasicServicesKit'; 1856 1857// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1858 1859function nfcTechDemo() { 1860 // 如果没有连接Tag，请先连接 1861 if (!mifareClassic.isTagConnected()) { 1862 if (!mifareClassic.connectTag()) { 1863 console.error("mifareClassic connectTag failed."); 1864 return; 1865 } 1866 } 1867 1868 try { 1869 let blockIndex = 1; // 将其更改为正确的 index 1870 mifareClassic.restoreFromBlock(blockIndex).then(() => { 1871 console.info("mifareClassic restoreFromBlock Promise success."); 1872 }).catch((err : BusinessError)=> { 1873 console.error(`mifareClassic restoreFromBlock Promise errCode: ${err.code}, message: ${err.message}`); 1874 }); 1875 } catch (businessError) { 1876 console.error(`mifareClassic restoreFromBlock Promise catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1877 } 1878} 1879``` 1880 1881### MifareClassicTag.restoreFromBlock<sup>9+</sup> 1882 1883restoreFromBlock(blockIndex: number, callback: AsyncCallback\<void>): void 1884 1885将指定块的值复制到临时寄存器。使用AsyncCallback方式作为异步方法。 1886 1887**需要权限：** ohos.permission.NFC_TAG 1888 1889**系统能力：** SystemCapability.Communication.NFC.Tag 1890 1891**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1892 1893**参数：** 1894 1895| 参数名 | 类型 | 必填 | 说明 | 1896| -------- | ----------------------- | ---- | -------------------------------------- | 1897| blockIndex | number | 是 | 被操作的块的索引，从0开始。 | 1898| callback | AsyncCallback\<void> | 是 | 回调函数。当复制指定块内容到临时寄存器成功时，err为undefined，否则为错误对象。| 1899 1900**错误码：** 1901 1902以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1903 1904| 错误码ID | 错误信息| 1905| ------- | -------| 1906| 201 | Permission denied. | 1907| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1908| 3100201 | The tag running state is abnormal in the service. | 1909| 3100204 | The Tag I/O operation failed. | 1910 1911**示例：** 1912 1913```js 1914import { tag } from '@kit.ConnectivityKit'; 1915import { BusinessError } from '@kit.BasicServicesKit'; 1916 1917// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1918 1919function nfcTechDemo() { 1920 // 如果没有连接Tag，请先连接 1921 if (!mifareClassic.isTagConnected()) { 1922 if (!mifareClassic.connectTag()) { 1923 console.error("mifareClassic connectTag failed."); 1924 return; 1925 } 1926 } 1927 1928 try { 1929 let blockIndex = 1; // 将其更改为正确的 index 1930 mifareClassic.restoreFromBlock(blockIndex, (err : BusinessError)=> { 1931 if (err) { 1932 console.error(`mifareClassic restoreFromBlock AsyncCallback err Code: ${err.code}, message: ${err.message}`); 1933 } else { 1934 console.info("mifareClassic restoreFromBlock AsyncCallback success."); 1935 } 1936 }); 1937 } catch (businessError) { 1938 console.error(`mifareClassic restoreFromBlock AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 1939 } 1940} 1941``` 1942 1943### MifareClassicTag.getSectorCount<sup>9+</sup> 1944 1945getSectorCount(): number 1946 1947获取MIFARE Classic标签中的扇区数。 1948 1949**系统能力：** SystemCapability.Communication.NFC.Tag 1950 1951**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1952 1953**返回值：** 1954 1955| **类型** | **说明** | 1956| ------------------ | --------------------------| 1957| number | 标签中的扇区数量。| 1958 1959**示例：** 1960 1961```js 1962import { tag } from '@kit.ConnectivityKit'; 1963import { BusinessError } from '@kit.BasicServicesKit'; 1964 1965// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 1966let sectorCount : number = mifareClassic.getSectorCount(); 1967console.info("mifareClassic sectorCount: " + sectorCount); 1968``` 1969 1970### MifareClassicTag.getBlockCountInSector<sup>9+</sup> 1971 1972getBlockCountInSector(sectorIndex: number): number 1973 1974获取指定扇区中的块数。 1975 1976**系统能力：** SystemCapability.Communication.NFC.Tag 1977 1978**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 1979 1980**参数：** 1981 1982| 参数名 | 类型 | 必填 | 说明 | 1983| -------- | ----------------------- | ---- | -------------------------------------- | 1984| sectorIndex | number | 是 | 扇区序号，从0开始。| 1985 1986**返回值：** 1987 1988| **类型** | **说明** | 1989| ------------------ | --------------------------| 1990| number | 该扇区内的块数量。| 1991 1992**错误码：** 1993 1994以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 1995 1996| 错误码ID | 错误信息| 1997| ------- | -------| 1998| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 1999 2000**示例：** 2001 2002```js 2003import { tag } from '@kit.ConnectivityKit'; 2004import { BusinessError } from '@kit.BasicServicesKit'; 2005 2006// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 2007 2008try { 2009 let sectorIndex = 1; // 将其更改为正确的 index 2010 let blockCnt : number = mifareClassic.getBlockCountInSector(sectorIndex); 2011 console.info("mifareClassic blockCnt: " + blockCnt); 2012} catch (businessError) { 2013 console.error(`mifareClassic getBlockCountInSector catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2014} 2015``` 2016 2017### MifareClassicTag.getType<sup>9+</sup> 2018 2019getType(): [tag.MifareClassicType](js-apis-nfcTag.md#mifareclassictype9) 2020 2021获取MIFARE Classic标签的类型。 2022 2023**系统能力：** SystemCapability.Communication.NFC.Tag 2024 2025**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2026 2027**返回值：** 2028 2029| **类型** | **说明** | 2030| ------------------ | --------------------------| 2031| [tag.MifareClassicType](js-apis-nfcTag.md#mifareclassictype9) | MifareClassic标签的类型。| 2032 2033**示例：** 2034 2035```js 2036import { tag } from '@kit.ConnectivityKit'; 2037 2038// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 2039let getType : tag.MifareClassicType = mifareClassic.getType(); 2040console.info("mifareClassic getType: " + getType); 2041``` 2042 2043### MifareClassicTag.getTagSize<sup>9+</sup> 2044 2045getTagSize(): number 2046 2047获取标签的存储空间大小，具体请参见[MifareClassicSize](js-apis-nfcTag.md#mifareclassicsize9)。 2048 2049**系统能力：** SystemCapability.Communication.NFC.Tag 2050 2051**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2052 2053**返回值：** 2054 2055| **类型** | **说明** | 2056| ------------------ | --------------------------| 2057| number | 标签的大小，单位为字节，请参见[MifareClassicSize](js-apis-nfcTag.md#mifareclassicsize9)。| 2058 2059**示例：** 2060 2061```js 2062import { tag } from '@kit.ConnectivityKit'; 2063import { BusinessError } from '@kit.BasicServicesKit'; 2064 2065// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 2066let tagSize : number = mifareClassic.getTagSize(); 2067console.info("mifareClassic tagSize: " + tagSize); 2068``` 2069 2070### MifareClassicTag.isEmulatedTag<sup>9+</sup> 2071 2072isEmulatedTag(): boolean 2073 2074检查标签是不是被模拟的。 2075 2076**系统能力：** SystemCapability.Communication.NFC.Tag 2077 2078**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2079 2080**返回值：** 2081 2082| **类型** | **说明** | 2083| ------------------ | --------------------------| 2084| boolean |检查结果，true: 是；false：否。 | 2085 2086**示例：** 2087 2088```js 2089import { tag } from '@kit.ConnectivityKit'; 2090import { BusinessError } from '@kit.BasicServicesKit'; 2091 2092// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 2093let isEmulatedTag : boolean = mifareClassic.isEmulatedTag(); 2094console.info("mifareClassic isEmulatedTag: " + isEmulatedTag); 2095``` 2096 2097### MifareClassicTag.getBlockIndex<sup>9+</sup> 2098 2099getBlockIndex(sectorIndex: number): number 2100 2101获取特定扇区的第一个块的序号。 2102 2103**系统能力：** SystemCapability.Communication.NFC.Tag 2104 2105**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2106 2107**参数：** 2108 2109| 参数名 | 类型 | 必填 | 说明 | 2110| -------- | ----------------------- | ---- | -------------------------------------- | 2111| sectorIndex | number | 是 | 扇区序号，从0开始。 | 2112 2113**返回值：** 2114 2115| **类型** | **说明** | 2116| ------------------ | --------------------------| 2117| number | 该扇区内的第一个块的序号，从0开始。 | 2118 2119**错误码：** 2120 2121以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2122 2123| 错误码ID | 错误信息| 2124| ------- | -------| 2125| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2126 2127**示例：** 2128 2129```js 2130import { tag } from '@kit.ConnectivityKit'; 2131import { BusinessError } from '@kit.BasicServicesKit'; 2132 2133// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 2134 2135try { 2136 let sectorIndex = 1; // 将其更改为正确的 index 2137 let blockIndex : number = mifareClassic.getBlockIndex(sectorIndex); 2138 console.info("mifareClassic blockIndex: " + blockIndex); 2139} catch (businessError) { 2140 console.error(`mifareClassic getBlockIndex catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2141} 2142``` 2143 2144### MifareClassicTag.getSectorIndex<sup>9+</sup> 2145 2146getSectorIndex(blockIndex: number): number 2147 2148获取包含指定块号的扇区序号。 2149 2150**系统能力：** SystemCapability.Communication.NFC.Tag 2151 2152**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2153 2154**参数：** 2155 2156| 参数名 | 类型 | 必填 | 说明 | 2157| -------- | ----------------------- | ---- | -------------------------------------- | 2158| blockIndex | number | 是 | 块序号，从0开始。 | 2159 2160**返回值：** 2161 2162| **类型** | **说明** | 2163| ------------------ | --------------------------| 2164| number | 扇区序号，从0开始。 | 2165 2166**错误码：** 2167 2168以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2169 2170| 错误码ID | 错误信息| 2171| ------- | -------| 2172| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2173 2174**示例：** 2175 2176```js 2177import { tag } from '@kit.ConnectivityKit'; 2178import { BusinessError } from '@kit.BasicServicesKit'; 2179 2180// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareClassic 2181 2182try { 2183 let blockIndex = 1; // 将其更改为正确的 index 2184 let sectorIndex : number = mifareClassic.getSectorIndex(blockIndex); 2185 console.info("mifareClassic sectorIndex: " + sectorIndex); 2186} catch (businessError) { 2187 console.error(`mifareClassic getSectorIndex catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2188} 2189``` 2190 2191## MifareUltralightTag<sup>9+</sup> 2192 2193MifareUltralightTag 提供对MIFARE Ultralight属性和I/O操作的访问，继承自TagSession。 2194 2195TagSession是所有NFC Tag技术类型的基类， 提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 2196 2197MifareUltralightTag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 2198 2199以下是MifareUltralightTag的独有接口。 2200 2201### MifareUltralightTag.readMultiplePages<sup>9+</sup> 2202 2203readMultiplePages(pageIndex: number): Promise\<number[]> 2204 2205读取标签的4页数据，共16字节的数据。每个页面数据大小为4字节。使用Promise方式作为异步方法。 2206 2207**需要权限：** ohos.permission.NFC_TAG 2208 2209**系统能力：** SystemCapability.Communication.NFC.Tag 2210 2211**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2212 2213**参数：** 2214 2215| 参数名 | 类型 | 必填 | 说明 | 2216| -------- | ----------------------- | ---- | ------------------------------ | 2217| pageIndex | number | 是 | 要读取页面的索引，从0开始。 | 2218 2219**返回值：** 2220 2221| **类型** | **说明** | 2222| ------------------ | --------------------------| 2223| Promise\<number[]> | 以Promise形式返回读取的4页的数据，共16字节。 | 2224 2225**错误码：** 2226 2227以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2228 2229| 错误码ID | 错误信息| 2230| ------- | -------| 2231| 201 | Permission denied. | 2232| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2233| 3100201 | The tag running state is abnormal in the service. | 2234| 3100204 | The tag I/O operation failed. | 2235 2236**示例：** 2237 2238```js 2239 2240import { tag } from '@kit.ConnectivityKit'; 2241import { BusinessError } from '@kit.BasicServicesKit'; 2242 2243// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareUltralight 2244 2245function nfcTechDemo() { 2246 // 如果没有连接Tag，请先连接 2247 if (!mifareUltralight.isTagConnected()) { 2248 if (!mifareUltralight.connectTag()) { 2249 console.error("mifareUltralight connectTag failed."); 2250 return; 2251 } 2252 } 2253 2254 try { 2255 let pageIndex = 1; // 将其更改为正确的 index 2256 mifareUltralight.readMultiplePages(pageIndex).then((data : number[]) => { 2257 console.info("mifareUltralight readMultiplePages Promise data = " + data); 2258 }).catch((err : BusinessError)=> { 2259 console.error(`mifareUltralight readMultiplePages Promise Code: ${err.code}, message: ${err.message}`); 2260 }); 2261 } catch (businessError) { 2262 console.error(`mifareUltralight readMultiplePages Promise catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2263 } 2264} 2265``` 2266 2267### MifareUltralightTag.readMultiplePages<sup>9+</sup> 2268 2269readMultiplePages(pageIndex: number, callback: AsyncCallback\<number[]>): void 2270 2271读取标签的4页数据，共16字节的数据。每个页面数据大小为4字节。使用AsyncCallback方式作为异步方法。 2272 2273**需要权限：** ohos.permission.NFC_TAG 2274 2275**系统能力：** SystemCapability.Communication.NFC.Tag 2276 2277**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2278 2279**参数：** 2280 2281| 参数名 | 类型 | 必填 | 说明 | 2282| -------- | ----------------------- | ---- | -------------------------------------- | 2283| pageIndex | number | 是 | 要读取页面的索引，从0开始。 | 2284| callback | AsyncCallback\<number[]> | 是 | 以callback形式异步返回页操作结果。返回读取到的数据，共16字节。 | 2285 2286**错误码：** 2287 2288以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2289 2290| 错误码ID | 错误信息| 2291| ------- | -------| 2292| 201 | Permission denied. | 2293| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2294| 3100201 | The tag running state is abnormal in the service. | 2295| 3100204 | The Tag I/O operation failed. | 2296 2297**示例：** 2298 2299```js 2300import { tag } from '@kit.ConnectivityKit'; 2301import { BusinessError } from '@kit.BasicServicesKit'; 2302 2303// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareUltralight 2304 2305function nfcTechDemo() { 2306 // 如果没有连接Tag，请先连接 2307 if (!mifareUltralight.isTagConnected()) { 2308 if (!mifareUltralight.connectTag()) { 2309 console.error("mifareUltralight connectTag failed."); 2310 return; 2311 } 2312 } 2313 2314 try { 2315 let pageIndex = 1; // 将其更改为正确的 index 2316 mifareUltralight.readMultiplePages(pageIndex, (err : BusinessError, data : number[])=> { 2317 if (err) { 2318 console.log(`mifareUltralight readMultiplePages AsyncCallback Code: ${err.code}, message: ${err.message}`); 2319 } else { 2320 console.info("mifareUltralight readMultiplePages AsyncCallback data: " + data); 2321 } 2322 }); 2323 } catch (businessError) { 2324 console.error(`mifareUltralight readMultiplePages AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2325 } 2326} 2327``` 2328 2329### MifareUltralightTag.writeSinglePage<sup>9+</sup> 2330 2331writeSinglePage(pageIndex: number, data: number[]): Promise\<void> 2332 2333写入一页数据，数据大小为4字节。使用Promise方式作为异步方法。 2334 2335**需要权限：** ohos.permission.NFC_TAG 2336 2337**系统能力：** SystemCapability.Communication.NFC.Tag 2338 2339**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2340 2341**参数：** 2342 2343| 参数名 | 类型 | 必填 | 说明 | 2344| -------- | ----------------------- | ---- | -------------------------------------- | 2345| pageIndex | number | 是 | 要写入页面的索引，从0开始。 | 2346| data | number[] | 是 | 要写入页面的数据内容，必须是4个字节大小。 | 2347 2348**返回值：** 2349 2350| 类型 | 说明 | 2351| ------------------------- | ------------------ | 2352| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 2353 2354**错误码：** 2355 2356以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2357 2358| 错误码ID | 错误信息| 2359| ------- | -------| 2360| 201 | Permission denied. | 2361| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2362| 3100201 | The tag running state is abnormal in the service. | 2363| 3100204 | The tag I/O operation failed. | 2364 2365**示例：** 2366 2367```js 2368import { tag } from '@kit.ConnectivityKit'; 2369import { BusinessError } from '@kit.BasicServicesKit'; 2370 2371// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareUltralight 2372 2373function nfcTechDemo() { 2374 // 如果没有连接Tag，请先连接 2375 if (!mifareUltralight.isTagConnected()) { 2376 if (!mifareUltralight.connectTag()) { 2377 console.error("mifareUltralight connectTag failed."); 2378 return; 2379 } 2380 } 2381 2382 try { 2383 let pageIndex = 1; // 将其更改为正确的 index 2384 let rawData = [0x01, 0x02, 0x03, 0x04]; //必须是4个字节，将其更改为正确的data 2385 mifareUltralight.writeSinglePage(pageIndex, rawData).then(() => { 2386 console.info("mifareUltralight writeSinglePage Promise success."); 2387 }).catch((err : BusinessError)=> { 2388 console.error(`mifareUltralight writeSinglePage Promise err Code: ${err.code}, message: ${err.message}`); 2389 }); 2390 } catch (businessError) { 2391 console.error(`mifareUltralight writeSinglePage Promise catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2392 } 2393} 2394``` 2395 2396### MifareUltralightTag.writeSinglePage<sup>9+</sup> 2397 2398writeSinglePage(pageIndex: number, data: number[], callback: AsyncCallback\<void>): void 2399 2400写入一页数据，数据大小为4字节。使用AsyncCallback方式作为异步方法。 2401 2402**需要权限：** ohos.permission.NFC_TAG 2403 2404**系统能力：** SystemCapability.Communication.NFC.Tag 2405 2406**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2407 2408**参数：** 2409 2410| 参数名 | 类型 | 必填 | 说明 | 2411| -------- | ----------------------- | ---- | ------------------------ | 2412| pageIndex | number | 是 | 要写入页面的索引，从0开始。 | 2413| data | number[] | 是 | 要写入页面的数据内容，必须是4个字节大小。 | 2414| callback|AsyncCallback\<void> |是| 回调函数。当写入数据成功时，err为undefined，否则为错误对象。 | 2415 2416**错误码：** 2417 2418以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2419 2420| 错误码ID | 错误信息| 2421| ------- | -------| 2422| 201 | Permission denied. | 2423| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2424| 3100201 | The tag running state is abnormal in the service. | 2425| 3100204 | The Tag I/O operation failed. | 2426 2427**示例：** 2428 2429```js 2430import { tag } from '@kit.ConnectivityKit'; 2431import { BusinessError } from '@kit.BasicServicesKit'; 2432 2433// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareUltralight 2434 2435function nfcTechDemo() { 2436 // 如果没有连接Tag，请先连接 2437 if (!mifareUltralight.isTagConnected()) { 2438 if (!mifareUltralight.connectTag()) { 2439 console.error("mifareUltralight connectTag failed."); 2440 return; 2441 } 2442 } 2443 2444 try { 2445 let pageIndex = 1; // 将其更改为正确的 index 2446 let rawData = [0x01, 0x02, 0x03, 0x04]; //必须是4个字节，将其更改为正确的data 2447 mifareUltralight.writeSinglePage(pageIndex, rawData, (err : BusinessError)=> { 2448 if (err) { 2449 console.error(`mifareUltralight writeSinglePage AsyncCallback Code: ${err.code}, message: ${err.message}`); 2450 } else { 2451 console.info("mifareUltralight writeSinglePage AsyncCallback success."); 2452 } 2453 }); 2454 } catch (businessError) { 2455 console.error(`mifareUltralight writeSinglePage AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2456 } 2457} 2458``` 2459 2460### MifareUltralightTag.getType<sup>9+</sup> 2461 2462getType(): [tag.MifareUltralightType](js-apis-nfcTag.md#mifareultralighttype9) 2463 2464获取MIFARE Ultralight标签的类型。 2465 2466**系统能力：** SystemCapability.Communication.NFC.Tag 2467 2468**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2469 2470**返回值：** 2471 2472| **类型** | **说明** | 2473| ------------------ | --------------------------| 2474| [tag.MifareUltralightType](js-apis-nfcTag.md#mifareultralighttype9) | MIFARE Ultralight标签的类型。| 2475 2476**示例：** 2477 2478```js 2479import { tag } from '@kit.ConnectivityKit'; 2480 2481// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 mifareUltralight 2482let getType : tag.MifareUltralightType = mifareClassic.getType(); 2483console.info("mifareUltralight getType: " + getType); 2484``` 2485 2486## NdefFormatableTag<sup>9+</sup> 2487 2488NdefFormatableTag为NDEF Formattable的标签提供格式化操作，继承自TagSession。 2489 2490TagSession是所有NFC Tag 技术类型的基类， 提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 2491 2492NdefFormatableTag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 2493 2494以下是NdefFormatableTag的独有接口。 2495 2496### NdefFormatableTag.format<sup>9+</sup> 2497 2498format(message: [NdefMessage](#ndefmessage9)): Promise\<void> 2499 2500将标签格式化为NDEF标签，将NDEF消息写入NDEF标签。使用Promise方式作为异步方法。 2501 2502**需要权限：** ohos.permission.NFC_TAG 2503 2504**系统能力：** SystemCapability.Communication.NFC.Tag 2505 2506**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2507 2508**参数：** 2509 2510| 参数名 | 类型 | 必填 | 说明 | 2511| -------- | ----------------------- | ---- | -------------------------------------- | 2512| message | [NdefMessage](#ndefmessage9) | 是 | 格式化成功时要写入的NDEF消息。可以为null，为null时仅格式化标签，不写入内容。 | 2513 2514**返回值：** 2515 2516| 类型 | 说明 | 2517| ------------------------- | ------------------ | 2518| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 2519 2520**错误码：** 2521 2522以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2523 2524| 错误码ID | 错误信息| 2525| ------- | -------| 2526| 201 | Permission denied. | 2527| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2528| 3100201 | The tag running state is abnormal in the service. | 2529| 3100204 | The tag I/O operation failed. | 2530 2531**示例：** 2532 2533```js 2534import { tag } from '@kit.ConnectivityKit'; 2535import { BusinessError } from '@kit.BasicServicesKit'; 2536 2537// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefFormatable 2538 2539function nfcTechDemo() { 2540 // 如果没有连接Tag，请先连接 2541 if (!ndefFormatable.isTagConnected()) { 2542 if (!ndefFormatable.connectTag()) { 2543 console.error("ndefFormatable connectTag failed."); 2544 return; 2545 } 2546 } 2547 2548 try { 2549 //从原始数据创建的ndefMessage，例如： 2550 let ndefMessage = tag.ndef.createNdefMessage([0xD1, 0x01, 0x03, 0x54, 0x4E, 0x46, 0x43]); 2551 // 必须是可以被解析的NDEF记录 2552 //或从 tag.ndef.createNdefMessage(ndefRecords:NdefRecord[]) 创建 ndefMessage 2553 2554 ndefFormatable.format(ndefMessage).then(() => { 2555 console.info("ndefFormatable format Promise success."); 2556 }).catch((err : BusinessError)=> { 2557 console.error(`defFormatable format Promise err Code: ${err.code}, message: ${err.message}`); 2558 }); 2559 } catch (businessError) { 2560 console.error(`ndefFormatable format Promise catch businessError Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2561 } 2562} 2563``` 2564 2565### NdefFormatableTag.format<sup>9+</sup> 2566 2567format(message: [NdefMessage](#ndefmessage9), callback: AsyncCallback\<void>): void 2568 2569将标签格式化为NDEF标签，然后将NDEF消息写入NDEF标签。使用AsyncCallback方式作为异步方法。 2570 2571**需要权限：** ohos.permission.NFC_TAG 2572 2573**系统能力：** SystemCapability.Communication.NFC.Tag 2574 2575**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2576 2577**参数：** 2578 2579| 参数名 | 类型 | 必填 | 说明 | 2580| -------- | ----------------------- | ---- | -------------------------------------- | 2581| message | [NdefMessage](#ndefmessage9) | 是 | 格式化成功时要写入的Ndef消息。可以为null，为null时仅格式化标签，不写入内容。 | 2582| callback | AsyncCallback\<void> | 是 | 回调函数。当NDEF消息写入标签成功时，err为undefined，否则为错误对象。 | 2583 2584**错误码：** 2585 2586以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2587 2588| 错误码ID | 错误信息| 2589| ------- | -------| 2590| 201 | Permission denied. | 2591| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2592| 3100201 | The tag running state is abnormal in the service. | 2593| 3100204 | The Tag I/O operation failed. | 2594 2595**示例：** 2596 2597```js 2598import { tag } from '@kit.ConnectivityKit'; 2599import { BusinessError } from '@kit.BasicServicesKit'; 2600 2601// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefFormatable 2602 2603function nfcTechDemo() { 2604 // 如果没有连接Tag，请先连接 2605 if (!ndefFormatable.isTagConnected()) { 2606 if (!ndefFormatable.connectTag()) { 2607 console.error("ndefFormatable connectTag failed."); 2608 return; 2609 } 2610 } 2611 2612 try { 2613 //从原始数据创建的ndefMessage，例如： 2614 let ndefMessage = tag.ndef.createNdefMessage([0xD1, 0x01, 0x03, 0x54, 0x4E, 0x46, 0x43]); // 必须是可以被解析的NDEF记录 2615 //或从 tag.ndef.createNdefMessage(ndefRecords:NdefRecord[]) 创建 ndefMessage 2616 2617 ndefFormatable.format(ndefMessage, (err : BusinessError)=> { 2618 if (err) { 2619 console.error(`ndefFormatable format AsyncCallback Code: ${err.code}, message: ${err.message}`); 2620 } else { 2621 console.info("ndefFormatable format AsyncCallback success."); 2622 } 2623 }); 2624 } catch (businessError) { 2625 console.error(`ndefFormatable format AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2626 } 2627} 2628``` 2629 2630### NdefFormatableTag.formatReadOnly<sup>9+</sup> 2631 2632formatReadOnly(message: [NdefMessage](#ndefmessage9)): Promise\<void> 2633 2634将标签格式化为NDEF标签，将NDEF消息写入NDEF标签，之后将标签设置为只读。使用Promise方式作为异步方法。 2635 2636**需要权限：** ohos.permission.NFC_TAG 2637 2638**系统能力：** SystemCapability.Communication.NFC.Tag 2639 2640**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2641 2642**参数：** 2643 2644| 参数名 | 类型 | 必填 | 说明 | 2645| -------- | ----------------------- | ---- | -------------------------------------- | 2646| message | [NdefMessage](#ndefmessage9) | 是 | 格式化成功时要写入的NDEF消息。可以为null，为null时仅格式化标签，不写入内容。 | 2647 2648**返回值：** 2649 2650| 类型 | 说明 | 2651| ------------------------- | ------------------ | 2652| Promise\<void> | Promise对象。无返回结果的Promise对象。 | 2653 2654**错误码：** 2655 2656以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2657 2658| 错误码ID | 错误信息| 2659| ------- | -------| 2660| 201 | Permission denied. | 2661| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2662| 3100201 | The tag running state is abnormal in the service. | 2663| 3100204 | The tag I/O operation failed. | 2664 2665**示例：** 2666 2667```js 2668import { tag } from '@kit.ConnectivityKit'; 2669import { BusinessError } from '@kit.BasicServicesKit'; 2670 2671// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefFormatable 2672 2673function nfcTechDemo() { 2674 // 如果没有连接Tag，请先连接 2675 if (!ndefFormatable.isTagConnected()) { 2676 if (!ndefFormatable.connectTag()) { 2677 console.error("ndefFormatable connectTag failed."); 2678 return; 2679 } 2680 } 2681 2682 try { 2683 //从原始数据创建的ndefMessage，例如： 2684 let ndefMessage = tag.ndef.createNdefMessage([0xD1, 0x01, 0x03, 0x54, 0x4E, 0x46, 0x43]); 2685 // 必须是可以被解析的NDEF记录 2686 //或从 tag.ndef.createNdefMessage(ndefRecords:NdefRecord[]) 创建 ndefMessage 2687 2688 ndefFormatable.formatReadOnly(ndefMessage).then(() => { 2689 console.info("ndefFormatable formatReadOnly Promise success."); 2690 }).catch((err : BusinessError)=> { 2691 console.error(`ndefFormatable formatReadOnly Promise Code: ${err.code}, message: ${err.message}`); 2692 }); 2693 } catch (businessError) { 2694 console.error(`ndefFormatable formatReadOnly Promise catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2695 } 2696} 2697``` 2698 2699### NdefFormatableTag.formatReadOnly<sup>9+</sup> 2700 2701formatReadOnly(message: [NdefMessage](#ndefmessage9), callback: AsyncCallback\<void>): void 2702 2703将标签格式化为NDEF标签，然后将NDEF消息写入NDEF标签，之后将标签设置为只读。使用callback方式作为异步方法。 2704 2705**需要权限：** ohos.permission.NFC_TAG 2706 2707**系统能力：** SystemCapability.Communication.NFC.Tag 2708 2709**原子化服务API：** 从API version 12开始，该接口支持在原子化服务中使用。 2710 2711**参数：** 2712 2713| 参数名 | 类型 | 必填 | 说明 | 2714| -------- | ----------------------- | ---- | -------------------------------------- | 2715| message | [NdefMessage](#ndefmessage9) | 是 | 格式化成功时要写入的NDEF消息。可以为null，为null时仅格式化标签，不写入内容。| 2716| callback | AsyncCallback\<void> | 是 | 回调函数。当NDEF消息写入NDEF标签成功时，err为undefined，否则为错误对象。 | 2717 2718**错误码：** 2719 2720以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2721 2722| 错误码ID | 错误信息| 2723| ------- | -------| 2724| 201 | Permission denied. | 2725| 401 | The parameter check failed. Possible causes: <br>1. Mandatory parameters are left unspecified.<br>2. Incorrect parameters types.<br>3. Parameter verification failed. | 2726| 3100201 | The tag running state is abnormal in the service. | 2727| 3100204 | The Tag I/O operation failed. | 2728 2729**示例：** 2730 2731```js 2732import { tag } from '@kit.ConnectivityKit'; 2733import { BusinessError } from '@kit.BasicServicesKit'; 2734 2735// 参考 @ohos.nfc.tag（标准NFC-Tag）中 tag.TagInfo 接口，获取正确的 ndefFormatable 2736 2737function nfcTechDemo() { 2738 // 如果没有连接Tag，请先连接 2739 if (!ndefFormatable.isTagConnected()) { 2740 if (!ndefFormatable.connectTag()) { 2741 console.error("ndefFormatable connectTag failed."); 2742 return; 2743 } 2744 } 2745 2746 try { 2747 //从原始数据创建的ndefMessage，例如： 2748 let ndefMessage = tag.ndef.createNdefMessage([0xD1, 0x01, 0x03, 0x54, 0x4E, 0x46, 0x43]); 2749 //必须是可以被解析的NDEF记录 2750 //或从 tag.ndef.createNdefMessage(ndefRecords:NdefRecord[]) 创建 ndefMessage 2751 2752 ndefFormatable.formatReadOnly(ndefMessage, (err : BusinessError)=> { 2753 if (err) { 2754 console.error(`ndefFormatable formatReadOnly AsyncCallback err Code: ${err.code}, message: ${err.message}`); 2755 } else { 2756 console.info("ndefFormatable formatReadOnly AsyncCallback success."); 2757 } 2758 }); 2759 } catch (businessError) { 2760 console.error(`ndefFormatable formatReadOnly AsyncCallback catch Code: ${(businessError as BusinessError).code}, message: ${(businessError as BusinessError).message}`); 2761 } 2762} 2763``` 2764 2765## BarcodeTag<sup>18+</sup> 2766 2767BarcodeTag提供读取条形码标签的属性和访问I/O操作的能力，继承自TagSession。 2768 2769TagSession是所有NFC Tag 技术类型的基类， 提供建立连接和发送数据等共同接口。具体请参见[TagSession](js-apis-tagSession.md)。 2770 2771BarcodeTag获取方式请参考[nfc-tag开发指南](../../connectivity/nfc/nfc-tag-access-guide.md)。 2772 2773以下是BarcodeTag的独有接口。 2774 2775### BarcodeTag.getBarcode<sup>18+</sup> 2776 2777getBarcode(): Promise\<ArrayBuffer> 2778 2779获取读到的Barcode类型的完整Tag。使用Promise方式作为异步方法。 2780 2781**需要权限：** ohos.permission.NFC_TAG 2782 2783**系统能力：** SystemCapability.Communication.NFC.Tag 2784 2785**原子化服务API：** 从API version 18开始，该接口支持在原子化服务中使用。 2786 2787 2788**返回值：** 2789 2790| 类型 | 说明 | 2791| ------------------------- | ------------------ | 2792| Promise\<ArrayBuffer> | Promise对象。返回BarCode类型的 tag。 | 2793 2794**错误码：** 2795 2796以下错误码的详细介绍请参见[NFC错误码](errorcode-nfc.md)。 2797 2798| 错误码ID | 错误信息| 2799| ------- | -------| 2800| 201 | Permission denied. | 2801| 3100201 | The tag running state is abnormal in the service. | 2802| 3100204 | The tag I/O operation failed. | 2803