1# @ohos.net.socket (Socket连接) 2 3本模块提供利用Socket进行数据传输的能力，支持TCPSocket、UDPSocket、WebSocket和TLSSocket。 4 5> **说明：** 6> 7> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 8 9## 导入模块 10 11```ts 12import socket from '@ohos.net.socket'; 13``` 14 15## socket.constructUDPSocketInstance 16 17constructUDPSocketInstance(): UDPSocket 18 19创建一个UDPSocket对象。 20 21**系统能力**：SystemCapability.Communication.NetStack 22 23**返回值：** 24 25| 类型 | 说明 | 26| --------------------------------- | ---------------------- | 27| [UDPSocket](#udpsocket) | 返回一个UDPSocket对象。 | 28 29**示例：** 30 31```ts 32import socket from '@ohos.net.socket'; 33let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 34``` 35 36## UDPSocket 37 38UDPSocket连接。在调用UDPSocket的方法前，需要先通过[socket.constructUDPSocketInstance](#socketconstructudpsocketinstance)创建UDPSocket对象。 39 40### bind 41 42bind(address: NetAddress, callback: AsyncCallback\<void\>): void 43 44绑定IP地址和端口，端口可以指定或由系统随机分配。使用callback方式作为异步方法。 45 46**需要权限**：ohos.permission.INTERNET 47 48**系统能力**：SystemCapability.Communication.NetStack 49 50**参数：** 51 52| 参数名 | 类型 | 必填 | 说明 | 53| -------- | ---------------------------------- | ---- | ------------------------------------------------------ | 54| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 55| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 56 57**错误码：** 58 59| 错误码ID | 错误信息 | 60| ------- | ----------------------- | 61| 401 | Parameter error. | 62| 201 | Permission denied. | 63 64**示例：** 65 66```ts 67import socket from '@ohos.net.socket'; 68import { BusinessError } from '@ohos.base'; 69 70let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 71let bindAddr: socket.NetAddress = { 72 address: '192.168.xx.xxx', 73 port: 1234 74} 75udp.bind(bindAddr, (err: BusinessError) => { 76 if (err) { 77 console.log('bind fail'); 78 return; 79 } 80 console.log('bind success'); 81}); 82``` 83 84### bind 85 86bind(address: NetAddress): Promise\<void\> 87 88绑定IP地址和端口，端口可以指定或由系统随机分配。使用Promise方式作为异步方法。 89 90**需要权限**：ohos.permission.INTERNET 91 92**系统能力**：SystemCapability.Communication.NetStack 93 94**参数：** 95 96| 参数名 | 类型 | 必填 | 说明 | 97| ------- | ---------------------------------- | ---- | ------------------------------------------------------ | 98| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 99 100**错误码：** 101 102| 错误码ID | 错误信息 | 103| ------- | ----------------------- | 104| 401 | Parameter error. | 105| 201 | Permission denied. | 106 107**返回值：** 108 109| 类型 | 说明 | 110| -------------- | ----------------------------------------- | 111| Promise\<void\> | 以Promise形式异步返回UDPSocket绑定的结果。 | 112 113**示例：** 114 115```ts 116import socket from '@ohos.net.socket'; 117import { BusinessError } from '@ohos.base'; 118 119let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 120let bindAddr: socket.NetAddress = { 121 address: '192.168.xx.xxx', 122 port: 8080 123} 124udp.bind(bindAddr).then(() => { 125 console.log('bind success'); 126}).catch((err: BusinessError) => { 127 console.log('bind fail'); 128}); 129``` 130 131### send 132 133send(options: UDPSendOptions, callback: AsyncCallback\<void\>): void 134 135通过UDPSocket连接发送数据。使用callback方式作为异步方法。 136 137发送数据前，需要先调用[UDPSocket.bind()](#bind)绑定IP地址和端口。 138 139**需要权限**：ohos.permission.INTERNET 140 141**系统能力**：SystemCapability.Communication.NetStack 142 143**参数：** 144 145| 参数名 | 类型 | 必填 | 说明 | 146| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 147| options | [UDPSendOptions](#udpsendoptions) | 是 | UDPSocket发送参数，参考[UDPSendOptions](#udpsendoptions)。 | 148| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 149 150**错误码：** 151 152| 错误码ID | 错误信息 | 153| ------- | ----------------------- | 154| 401 | Parameter error. | 155| 201 | Permission denied. | 156 157**示例：** 158 159```ts 160import socket from '@ohos.net.socket'; 161import { BusinessError } from '@ohos.base'; 162 163let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 164 165let sendOptions: socket.UDPSendOptions = { 166 data: 'Hello, server!', 167 address: { 168 address: '192.168.xx.xxx', 169 port: 8080 170 } 171} 172udp.send(sendOptions, (err: BusinessError) => { 173 if (err) { 174 console.log('send fail'); 175 return; 176 } 177 console.log('send success'); 178}); 179``` 180 181### send 182 183send(options: UDPSendOptions): Promise\<void\> 184 185通过UDPSocket连接发送数据。使用Promise方式作为异步方法。 186 187发送数据前，需要先调用[UDPSocket.bind()](#bind)绑定IP地址和端口。 188 189**需要权限**：ohos.permission.INTERNET 190 191**系统能力**：SystemCapability.Communication.NetStack 192 193**参数：** 194 195| 参数名 | 类型 | 必填 | 说明 | 196| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 197| options | [UDPSendOptions](#udpsendoptions) | 是 | UDPSocket发送参数，参考[UDPSendOptions](#udpsendoptions)。 | 198 199**错误码：** 200 201| 错误码ID | 错误信息 | 202| ------- | ----------------------- | 203| 401 | Parameter error. | 204| 201 | Permission denied. | 205 206**返回值：** 207 208| 类型 | 说明 | 209| -------------- | --------------------------------------------- | 210| Promise\<void\> | 以Promise形式返回UDPSocket连接发送数据的结果。 | 211 212**示例：** 213 214```ts 215import socket from '@ohos.net.socket'; 216import { BusinessError } from '@ohos.base'; 217 218let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 219 220let sendOptions: socket.UDPSendOptions = { 221 data: 'Hello, server!', 222 address: { 223 address: '192.168.xx.xxx', 224 port: 8080 225 } 226} 227udp.send(sendOptions).then(() => { 228 console.log('send success'); 229}).catch((err: BusinessError) => { 230 console.log('send fail'); 231}); 232``` 233 234### close 235 236close(callback: AsyncCallback\<void\>): void 237 238关闭UDPSocket连接。使用callback方式作为异步方法。 239 240**需要权限**：ohos.permission.INTERNET 241 242**系统能力**：SystemCapability.Communication.NetStack 243 244**参数：** 245 246| 参数名 | 类型 | 必填 | 说明 | 247| -------- | --------------------- | ---- | ---------- | 248| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 249 250**示例：** 251 252```ts 253import socket from '@ohos.net.socket'; 254import { BusinessError } from '@ohos.base'; 255 256let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 257udp.close((err: BusinessError) => { 258 if (err) { 259 console.log('close fail'); 260 return; 261 } 262 console.log('close success'); 263}) 264``` 265 266### close 267 268close(): Promise\<void\> 269 270关闭UDPSocket连接。使用Promise方式作为异步方法。 271 272**需要权限**：ohos.permission.INTERNET 273 274**系统能力**：SystemCapability.Communication.NetStack 275 276**返回值：** 277 278| 类型 | 说明 | 279| -------------- | ----------------------------------------- | 280| Promise\<void\> | 以Promise形式返回关闭UDPSocket连接的结果。 | 281 282**示例：** 283 284```ts 285import socket from '@ohos.net.socket'; 286import { BusinessError } from '@ohos.base'; 287 288let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 289udp.close().then(() => { 290 console.log('close success'); 291}).catch((err: BusinessError) => { 292 console.log('close fail'); 293}); 294``` 295 296### getState 297 298getState(callback: AsyncCallback\<SocketStateBase\>): void 299 300获取UDPSocket状态。使用callback方式作为异步方法。 301 302> **说明：** 303> bind方法调用成功后，才可调用此方法。 304 305**需要权限**：ohos.permission.INTERNET 306 307**系统能力**：SystemCapability.Communication.NetStack 308 309**参数：** 310 311| 参数名 | 类型 | 必填 | 说明 | 312| -------- | ------------------------------------------------------ | ---- | ---------- | 313| callback | AsyncCallback<[SocketStateBase](#socketstatebase)> | 是 | 回调函数。 | 314 315**错误码：** 316 317| 错误码ID | 错误信息 | 318| ------- | ----------------------- | 319| 201 | Permission denied. | 320 321**示例：** 322 323```ts 324import socket from '@ohos.net.socket'; 325import { BusinessError } from '@ohos.base'; 326 327let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 328let bindAddr: socket.NetAddress = { 329 address: '192.168.xx.xxx', 330 port: 8080 331} 332udp.bind(bindAddr, (err: BusinessError) => { 333 if (err) { 334 console.log('bind fail'); 335 return; 336 } 337 console.log('bind success'); 338 udp.getState((err: BusinessError, data: socket.SocketStateBase) => { 339 if (err) { 340 console.log('getState fail'); 341 return; 342 } 343 console.log('getState success:' + JSON.stringify(data)); 344 }) 345}) 346``` 347 348### getState 349 350getState(): Promise\<SocketStateBase\> 351 352获取UDPSocket状态。使用Promise方式作为异步方法。 353 354> **说明：** 355> bind方法调用成功后，才可调用此方法。 356 357**需要权限**：ohos.permission.INTERNET 358 359**系统能力**：SystemCapability.Communication.NetStack 360 361**返回值：** 362 363| 类型 | 说明 | 364| ----------------------------------------------- | ----------------------------------------- | 365| Promise\<[SocketStateBase](#socketstatebase)\> | 以Promise形式返回获取UDPSocket状态的结果。 | 366 367**示例：** 368 369```ts 370import socket from '@ohos.net.socket'; 371import { BusinessError } from '@ohos.base'; 372 373let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 374let bindAddr: socket.NetAddress = { 375 address: '192.168.xx.xxx', 376 port: 8080 377} 378udp.bind(bindAddr, (err: BusinessError) => { 379 if (err) { 380 console.log('bind fail'); 381 return; 382 } 383 console.log('bind success'); 384 udp.getState().then((data: socket.SocketStateBase) => { 385 console.log('getState success:' + JSON.stringify(data)); 386 }).catch((err: BusinessError) => { 387 console.log('getState fail' + JSON.stringify(err)); 388 }); 389}); 390``` 391 392### setExtraOptions 393 394setExtraOptions(options: UDPExtraOptions, callback: AsyncCallback\<void\>): void 395 396设置UDPSocket连接的其他属性。使用callback方式作为异步方法。 397 398> **说明：** 399> bind方法调用成功后，才可调用此方法。 400 401**需要权限**：ohos.permission.INTERNET 402 403**系统能力**：SystemCapability.Communication.NetStack 404 405**参数：** 406 407| 参数名 | 类型 | 必填 | 说明 | 408| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 409| options | [UDPExtraOptions](#udpextraoptions) | 是 | UDPSocket连接的其他属性，参考[UDPExtraOptions](#udpextraoptions)。 | 410| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 411 412**错误码：** 413 414| 错误码ID | 错误信息 | 415| ------- | ----------------------- | 416| 401 | Parameter error. | 417| 201 | Permission denied. | 418 419**示例：** 420 421```ts 422import socket from '@ohos.net.socket'; 423import { BusinessError } from '@ohos.base'; 424 425let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 426 427let bindAddr: socket.NetAddress = { 428 address: '192.168.xx.xxx', 429 port: 8080 430} 431udp.bind(bindAddr, (err: BusinessError) => { 432 if (err) { 433 console.log('bind fail'); 434 return; 435 } 436 console.log('bind success'); 437 let udpextraoptions: socket.UDPExtraOptions = { 438 receiveBufferSize: 1000, 439 sendBufferSize: 1000, 440 reuseAddress: false, 441 socketTimeout: 6000, 442 broadcast: true 443 } 444 udp.setExtraOptions(udpextraoptions, (err: BusinessError) => { 445 if (err) { 446 console.log('setExtraOptions fail'); 447 return; 448 } 449 console.log('setExtraOptions success'); 450 }) 451}) 452``` 453 454### setExtraOptions 455 456setExtraOptions(options: UDPExtraOptions): Promise\<void\> 457 458设置UDPSocket连接的其他属性。使用Promise方式作为异步方法。 459 460> **说明：** 461> bind方法调用成功后，才可调用此方法。 462 463**需要权限**：ohos.permission.INTERNET 464 465**系统能力**：SystemCapability.Communication.NetStack 466 467**参数：** 468 469| 参数名 | 类型 | 必填 | 说明 | 470| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 471| options | [UDPExtraOptions](#udpextraoptions) | 是 | UDPSocket连接的其他属性，参考[UDPExtraOptions](#udpextraoptions)。 | 472 473**返回值：** 474 475| 类型 | 说明 | 476| -------------- | --------------------------------------------------- | 477| Promise\<void\> | 以Promise形式返回设置UDPSocket连接的其他属性的结果。 | 478 479**错误码：** 480 481| 错误码ID | 错误信息 | 482| ------- | ----------------------- | 483| 401 | Parameter error. | 484| 201 | Permission denied. | 485 486**示例：** 487 488```ts 489import socket from '@ohos.net.socket'; 490import { BusinessError } from '@ohos.base'; 491 492let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 493 494let bindAddr: socket.NetAddress = { 495 address: '192.168.xx.xxx', 496 port: 8080 497} 498udp.bind(bindAddr, (err: BusinessError) => { 499 if (err) { 500 console.log('bind fail'); 501 return; 502 } 503 console.log('bind success'); 504 let udpextraoptions: socket.UDPExtraOptions = { 505 receiveBufferSize: 1000, 506 sendBufferSize: 1000, 507 reuseAddress: false, 508 socketTimeout: 6000, 509 broadcast: true 510 } 511 udp.setExtraOptions(udpextraoptions).then(() => { 512 console.log('setExtraOptions success'); 513 }).catch((err: BusinessError) => { 514 console.log('setExtraOptions fail'); 515 }); 516}) 517``` 518 519### on('message') 520 521on(type: 'message', callback: Callback\<SocketMessageInfo\>): void 522 523订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。 524 525**系统能力**：SystemCapability.Communication.NetStack 526 527**参数：** 528 529| 参数名 | 类型 | 必填 | 说明 | 530| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 531| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 532| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 是 | 回调函数。 | 533 534**示例：** 535 536```ts 537import socket from "@ohos.net.socket"; 538import { BusinessError } from '@ohos.base'; 539let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 540 541let messageView = ''; 542udp.on('message', (value: socket.SocketMessageInfo) => { 543 for (let i: number = 0; i < value.message.byteLength; i++) { 544 let uint8Array = new Uint8Array(value.message) 545 let messages = uint8Array[i] 546 let message = String.fromCharCode(messages); 547 messageView += message; 548 } 549 console.log('on message message: ' + JSON.stringify(messageView)); 550 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 551}); 552``` 553 554### off('message') 555 556off(type: 'message', callback?: Callback\<SocketMessageInfo\>): void 557 558取消订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。 559 560> **说明：** 561> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 562 563**系统能力**：SystemCapability.Communication.NetStack 564 565**参数：** 566 567| 参数名 | 类型 | 必填 | 说明 | 568| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 569| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 570| callback | Callback<[SocketMessageInfo](#socketmessageinfo11)> | 否 | 回调函数。 | 571 572**示例：** 573 574```ts 575import socket from "@ohos.net.socket"; 576import { BusinessError } from '@ohos.base'; 577let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 578let messageView = ''; 579let callback = (value: socket.SocketMessageInfo) => { 580 for (let i: number = 0; i < value.message.byteLength; i++) { 581 let uint8Array = new Uint8Array(value.message) 582 let messages = uint8Array[i] 583 let message = String.fromCharCode(messages); 584 messageView += message; 585 } 586 console.log('on message message: ' + JSON.stringify(messageView)); 587 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 588} 589udp.on('message', callback); 590// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 591udp.off('message', callback); 592udp.off('message'); 593``` 594 595### on('listening' | 'close') 596 597on(type: 'listening' | 'close', callback: Callback\<void\>): void 598 599订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。 600 601**系统能力**：SystemCapability.Communication.NetStack 602 603**参数：** 604 605| 参数名 | 类型 | 必填 | 说明 | 606| -------- | ---------------- | ---- | ------------------------------------------------------------ | 607| type | string | 是 | 订阅的事件类型。<br />- 'listening'：数据包消息事件。<br />- 'close'：关闭事件。 | 608| callback | Callback\<void\> | 是 | 回调函数。 | 609 610**示例：** 611 612```ts 613import socket from "@ohos.net.socket"; 614import { BusinessError } from '@ohos.base'; 615let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 616udp.on('listening', () => { 617 console.log("on listening success"); 618}); 619udp.on('close', () => { 620 console.log("on close success"); 621}); 622``` 623 624### off('listening' | 'close') 625 626off(type: 'listening' | 'close', callback?: Callback\<void\>): void 627 628取消订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。 629 630> **说明：** 631> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 632 633**系统能力**：SystemCapability.Communication.NetStack 634 635**参数：** 636 637| 参数名 | 类型 | 必填 | 说明 | 638| -------- | ---------------- | ---- | ------------------------------------------------------------ | 639| type | string | 是 | 订阅事件类型。<br />- 'listening'：数据包消息事件。<br />- 'close'：关闭事件。 | 640| callback | Callback\<void\> | 否 | 回调函数。 | 641 642**示例：** 643 644```ts 645import socket from "@ohos.net.socket"; 646import { BusinessError } from '@ohos.base'; 647let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 648let callback1 = () => { 649 console.log("on listening, success"); 650} 651udp.on('listening', callback1); 652// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 653udp.off('listening', callback1); 654udp.off('listening'); 655let callback2 = () => { 656 console.log("on close, success"); 657} 658udp.on('close', callback2); 659// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 660udp.off('close', callback2); 661udp.off('close'); 662``` 663 664### on('error') 665 666on(type: 'error', callback: ErrorCallback): void 667 668订阅UDPSocket连接的error事件。使用callback方式作为异步方法。 669 670**系统能力**：SystemCapability.Communication.NetStack 671 672**参数：** 673 674| 参数名 | 类型 | 必填 | 说明 | 675| -------- | ------------- | ---- | ------------------------------------ | 676| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 677| callback | ErrorCallback | 是 | 回调函数。 | 678 679**示例：** 680 681```ts 682import socket from "@ohos.net.socket"; 683import { BusinessError } from '@ohos.base'; 684let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 685udp.on('error', (err: BusinessError) => { 686 console.log("on error, err:" + JSON.stringify(err)) 687}); 688``` 689 690### off('error') 691 692off(type: 'error', callback?: ErrorCallback): void 693 694取消订阅UDPSocket连接的error事件。使用callback方式作为异步方法。 695 696> **说明：** 697> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 698 699**系统能力**：SystemCapability.Communication.NetStack 700 701**参数：** 702 703| 参数名 | 类型 | 必填 | 说明 | 704| -------- | ------------- | ---- | ------------------------------------ | 705| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 706| callback | ErrorCallback | 否 | 回调函数。 | 707 708**示例：** 709 710```ts 711import socket from "@ohos.net.socket"; 712import { BusinessError } from '@ohos.base'; 713let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 714let callback = (err: BusinessError) => { 715 console.log("on error, err:" + JSON.stringify(err)); 716} 717udp.on('error', callback); 718// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 719udp.off('error', callback); 720udp.off('error'); 721``` 722 723## NetAddress 724 725目标地址信息。 726 727**系统能力**：SystemCapability.Communication.NetStack 728 729| 名称 | 类型 | 必填 | 说明 | 730| ------- | ------ | ---- | ------------------------------------------------------------ | 731| address | string | 是 | 本地绑定的ip地址。 | 732| port | number | 否 | 端口号 ，范围0~65535。如果不指定系统随机分配端口。 | 733| family | number | 否 | 网络协议类型，可选类型：<br />- 1：IPv4<br />- 2：IPv6<br />默认为1。 | 734 735## UDPSendOptions 736 737UDPSocket发送参数。 738 739**系统能力**：SystemCapability.Communication.NetStack 740 741| 名称 | 类型 | 必填 | 说明 | 742| ------- | ---------------------------------- | ---- | -------------- | 743| data | string \| ArrayBuffer | 是 | 发送的数据。 | 744| address | [NetAddress](#netaddress) | 是 | 目标地址信息。 | 745 746## UDPExtraOptions 747 748UDPSocket连接的其他属性。 749 750**系统能力**：SystemCapability.Communication.NetStack 751 752| 名称 | 类型 | 必填 | 说明 | 753| ----------------- | ------- | ---- | -------------------------------- | 754| broadcast | boolean | 否 | 是否可以发送广播。默认为false。 | 755| receiveBufferSize | number | 否 | 接收缓冲区大小（单位：Byte），默认为0。 | 756| sendBufferSize | number | 否 | 发送缓冲区大小（单位：Byte），默认为0。 | 757| reuseAddress | boolean | 否 | 是否重用地址。默认为false。 | 758| socketTimeout | number | 否 | 套接字超时时间，单位毫秒（ms），默认为0。 | 759 760## SocketMessageInfo<sup>11+</sup> 761 762socket连接信息 763 764**系统能力**：SystemCapability.Communication.NetStack 765 766| 名称 | 类型 | 必填 | 说明 | 767| ---------- | ------ | ---- | ------------------------------------- | 768| message | ArrayBuffer | 是 | 接收的事件消息。 | 769| remoteInfo | [SocketRemoteInfo](#socketremoteinfo) | 是 | socket连接信息。 | 770 771## SocketStateBase 772 773Socket的状态信息。 774 775**系统能力**：SystemCapability.Communication.NetStack 776 777| 名称 | 类型 | 必填 | 说明 | 778| ----------- | ------- | ---- | ---------- | 779| isBound | boolean | 是 | 是否绑定。 | 780| isClose | boolean | 是 | 是否关闭。 | 781| isConnected | boolean | 是 | 是否连接。 | 782 783## SocketRemoteInfo 784 785Socket的连接信息。 786 787**系统能力**：SystemCapability.Communication.NetStack 788 789| 名称 | 类型 | 必填 | 说明 | 790| ------- | ------ | ---- | ------------------------------------------------------------ | 791| address | string | 是 | 本地绑定的ip地址。 | 792| family | string | 是 | 网络协议类型，可选类型：<br />- IPv4<br />- IPv6<br />默认为IPv4。 | 793| port | number | 是 | 端口号，范围0~65535。 | 794| size | number | 是 | 服务器响应信息的字节长度。 | 795 796## UDP 错误码说明 797 798UDP 其余错误码映射形式为：2301000 + Linux内核错误码。 799 800错误码的详细介绍参见[Socket错误码](errorcode-net-socket.md) 801 802## socket.constructMulticastSocketInstance<sup>11+</sup> 803 804constructMulticastSocketInstance(): MulticastSocket 805 806创建一个MulticastSocket对象。 807 808**系统能力**：SystemCapability.Communication.NetStack 809 810**返回值：** 811 812| 类型 | 说明 | 813| ----------------------------------- | ----------------------------- | 814| [MulticastSocket](#multicastsocket11) | 返回一个MulticastSocket对象。 | 815 816**示例：** 817 818```ts 819import socket from "@ohos.net.socket"; 820let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 821``` 822## MulticastSocket<sup>11+</sup> 823 824MulticastSocket连接。在调用MulticastSocket的方法前，需要先通过[socket.constructMulticastSocketInstance](#socketconstructmulticastsocketinstance11)创建MulticastSocket对象。 825 826### addMembership<sup>11+</sup> 827 828addMembership(multicastAddress: NetAddress, callback: AsyncCallback\<void\>): void; 829 830加入多播组。使用callback方法作为异步方法。 831 832> **说明：** 833> 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 834> 加入多播组后，既可以是发送端，也可以是接收端，相互之间以广播的形式传递数据，不区分客户端或服务端。 835 836**需要权限**：ohos.permission.INTERNET 837 838**系统能力**：SystemCapability.Communication.NetStack 839 840**参数：** 841 842| 参数名 | 类型 | 必填 | 说明 | 843| ----------------- | ----------------------------- | ---- | ----------------------------------------- | 844| multicastAddress | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 845| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 846 847**错误码：** 848 849| 错误码ID | 错误信息 | 850| ------- | ----------------------- | 851| 401 | Parameter error. | 852| 201 | Permission denied. | 853| 2301022 | Invalid argument. | 854| 2301088 | Not a socket. | 855| 2301098 | Address in use. | 856 857**示例：** 858 859```ts 860import socket from "@ohos.net.socket"; 861let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 862let addr: socket.NetAddress = { 863 address: '239.255.0.1', 864 port: 8080 865} 866multicast.addMembership(addr, (err: Object) => { 867 if (err) { 868 console.log('add membership fail, err: ' + JSON.stringify(err)); 869 return; 870 } 871 console.log('add membership success'); 872}) 873``` 874 875### addMembership<sup>11+</sup> 876 877addMembership(multicastAddress: NetAddress): Promise\<void\>; 878 879加入多播组。使用Promise方法作为异步方法。。 880 881> **说明：** 882> 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 883> 加入多播组后，既可以是发送端，也可以是接收端，相互之间以广播的形式传递数据，不区分客户端或服务端。 884 885**需要权限**：ohos.permission.INTERNET 886 887**系统能力**：SystemCapability.Communication.NetStack 888 889**参数：** 890 891| 参数名 | 类型 | 必填 | 说明 | 892| ----------------- | ----------------------------- | ---- | -------------------------------------------- | 893| multicastAddress | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 894 895**返回值：** 896 897| 类型 | 说明 | 898| -------------- | ----------------------------------------------- | 899| Promise\<void\> | 以Promise形式返回MulticastSocket加入多播组的行为结果。 | 900 901**错误码：** 902 903| 错误码ID | 错误信息 | 904| ------- | ----------------------- | 905| 401 | Parameter error. | 906| 201 | Permission denied. | 907| 2301088 | Not a socket. | 908| 2301098 | Address in use. | 909 910**示例：** 911 912```ts 913import socket from "@ohos.net.socket"; 914let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 915let addr: socket.NetAddress = { 916 address: '239.255.0.1', 917 port: 8080 918} 919multicast.addMembership(addr).then(() => { 920 console.log('addMembership success'); 921}).catch((err: Object) => { 922 console.log('addMembership fail'); 923}); 924``` 925 926### dropMembership<sup>11+</sup> 927 928dropMembership(multicastAddress: NetAddress, callback: AsyncCallback\<void\>): void; 929 930退出多播组。使用callback方法作为异步方法。 931 932> **说明：** 933> 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 934> 从已加入的多播组中退出，必须在加入多播组 [addMembership](#addmembership11) 之后退出才有效。 935 936**需要权限**：ohos.permission.INTERNET 937 938**系统能力**：SystemCapability.Communication.NetStack 939 940**参数：** 941 942| 参数名 | 类型 | 必填 | 说明 | 943| ----------------- | ----------------------------- | ---- | ------------------------------------------- | 944| multicastAddress | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 945| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 946 947**错误码：** 948 949| 错误码ID | 错误信息 | 950| ------- | ----------------------- | 951| 401 | Parameter error. | 952| 201 | Permission denied. | 953| 2301088 | Not a socket. | 954| 2301098 | Address in use. | 955 956**示例：** 957 958```ts 959import socket from "@ohos.net.socket"; 960let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 961let addr: socket.NetAddress = { 962 address: '239.255.0.1', 963 port: 8080 964} 965multicast.dropMembership(addr, (err: Object) => { 966 if (err) { 967 console.log('drop membership fail, err: ' + JSON.stringify(err)); 968 return; 969 } 970 console.log('drop membership success'); 971}) 972``` 973 974### dropMembership<sup>11+</sup> 975 976dropMembership(multicastAddress: NetAddress): Promise\<void\>; 977 978退出多播组。使用Promise方法作为异步方法。。 979 980> **说明：** 981> 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 982> 从已加入的多播组中退出，必须在加入多播组 [addMembership](#addmembership11) 之后退出才有效。 983 984**需要权限**：ohos.permission.INTERNET 985 986**系统能力**：SystemCapability.Communication.NetStack 987 988**参数：** 989 990| 参数名 | 类型 | 必填 | 说明 | 991| ----------------- | ------------------------------------- | ---- | -------------------------------------------- | 992| multicastAddress | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 993 994**返回值：** 995 996| 类型 | 说明 | 997| -------------- | ----------------------------------------------- | 998| Promise\<void\> | 以Promise形式返回MulticastSocket加入多播组的执行结果。 | 999 1000**错误码：** 1001 1002| 错误码ID | 错误信息 | 1003| ------- | ----------------------- | 1004| 401 | Parameter error. | 1005| 201 | Permission denied. | 1006| 2301088 | Not a socket. | 1007| 2301098 | Address in use. | 1008 1009**示例：** 1010 1011```ts 1012import socket from "@ohos.net.socket"; 1013let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1014let addr: socket.NetAddress = { 1015 address: '239.255.0.1', 1016 port: 8080 1017} 1018multicast.dropMembership(addr).then(() => { 1019 console.log('drop membership success'); 1020}).catch((err: Object) => { 1021 console.log('drop membership fail'); 1022}); 1023``` 1024 1025### setMulticastTTL<sup>11+</sup> 1026 1027setMulticastTTL(ttl: number, callback: AsyncCallback\<void\>): void; 1028 1029设置多播通信时数据包在网络传输过程中路由器最大跳数。使用callback方法作为异步方法。 1030 1031> **说明：** 1032> 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 1033> 范围为 0～255，默认值为 1 。 1034> 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 1035> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1036 1037**系统能力**：SystemCapability.Communication.NetStack 1038 1039**参数：** 1040 1041| 参数名 | 类型 | 必填 | 说明 | 1042| ------------- | --------------------- | ---- | ----------------------------- | 1043| ttl | number | 是 | ttl设置数值，类型为数字number。 | 1044| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 1045 1046**错误码：** 1047 1048| 错误码ID | 错误信息 | 1049| ------- | ----------------------- | 1050| 401 | Parameter error. | 1051| 2301022 | Invalid argument. | 1052| 2301088 | Not a socket. | 1053 1054**示例：** 1055 1056```ts 1057import socket from "@ohos.net.socket"; 1058let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1059let ttl = 8 1060multicast.setMulticastTTL(ttl, (err: Object) => { 1061 if (err) { 1062 console.log('set ttl fail, err: ' + JSON.stringify(err)); 1063 return; 1064 } 1065 console.log('set ttl success'); 1066}) 1067``` 1068 1069### setMulticastTTL<sup>11+</sup> 1070 1071setMulticastTTL(ttl: number): Promise\<void\>; 1072 1073设置多播通信时数据包在网络传输过程中路由器最大跳数。使用Promise方法作为异步方法。。 1074 1075> **说明：** 1076> 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 1077> 范围为 0～255，默认值为 1 。 1078> 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 1079> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1080 1081**系统能力**：SystemCapability.Communication.NetStack 1082 1083**参数：** 1084 1085| 参数名 | 类型 | 必填 | 说明 | 1086| ------------- | ---------------------- | ---- | ------------------------------ | 1087| ttl | number | 是 | ttl设置数值，类型为数字Number。 | 1088 1089**返回值：** 1090 1091| 类型 | 说明 | 1092| -------------- | ---------------------------------------------- | 1093| Promise\<void\> | 以Promise形式返回MulticastSocket设置TTL数值的结果。 | 1094 1095**错误码：** 1096 1097| 错误码ID | 错误信息 | 1098| ------- | ----------------------- | 1099| 401 | Parameter error. | 1100| 2301022 | Invalid argument. | 1101| 2301088 | Not a socket. | 1102 1103**示例：** 1104 1105```ts 1106import socket from "@ohos.net.socket"; 1107let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1108multicast.setMulticastTTL(8).then(() => { 1109 console.log('set ttl success'); 1110}).catch((err: Object) => { 1111 console.log('set ttl failed'); 1112}); 1113``` 1114 1115### getMulticastTTL<sup>11+</sup> 1116 1117getMulticastTTL(callback: AsyncCallback\<number\>): void; 1118 1119获取数据包在网络传输过程中路由器最大跳数(TTL)的值。使用callback方法作为异步方法。 1120 1121> **说明：** 1122> 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 1123> 范围为 0～255，默认值为 1 。 1124> 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 1125> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1126 1127**系统能力**：SystemCapability.Communication.NetStack 1128 1129**参数：** 1130 1131| 参数名 | 类型 | 必填 | 说明 | 1132| ------------- | ----------------------- | ---- | --------------------------- | 1133| callback | AsyncCallback\<number\> | 是 | 回调函数。 | 1134 1135**错误码：** 1136 1137| 错误码ID | 错误信息 | 1138| ------- | ----------------------- | 1139| 401 | Parameter error. | 1140| 2301088 | Not a socket. | 1141 1142**示例：** 1143 1144```ts 1145import socket from "@ohos.net.socket"; 1146let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1147multicast.getMulticastTTL((err: Object, value: Number) => { 1148 if (err) { 1149 console.log('set ttl fail, err: ' + JSON.stringify(err)); 1150 return; 1151 } 1152 console.log('set ttl success, value: ' + JSON.stringify(value)); 1153}) 1154``` 1155 1156### getMulticastTTL<sup>11+</sup> 1157 1158getMulticastTTL(): Promise\<number\>; 1159 1160获取数据包在网络传输过程中路由器最大跳数(TTL)的值。使用Promise方法作为异步方法。 1161 1162> **说明：** 1163> 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 1164> 范围为 0～255，默认值为 1 。 1165> 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 1166> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1167 1168**系统能力**：SystemCapability.Communication.NetStack 1169 1170**返回值：** 1171 1172| 类型 | 说明 | 1173| ---------------- | --------------------------- | 1174| Promise\<number\> | 以Promise形式返回当前TTL数值。 | 1175 1176**错误码：** 1177 1178| 错误码ID | 错误信息 | 1179| ------- | ----------------------- | 1180| 401 | Parameter error. | 1181| 2301088 | Not a socket. | 1182 1183**示例：** 1184 1185```ts 1186import socket from "@ohos.net.socket"; 1187let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1188multicast.getMulticastTTL().then((value: Number) => { 1189 console.log('ttl: ', JSON.stringify(value)); 1190}).catch((err: Object) => { 1191 console.log('set ttl failed'); 1192}); 1193``` 1194 1195### setLoopbackMode<sup>11+</sup> 1196 1197setLoopbackMode(flag: boolean, callback: AsyncCallback\<void\>): void; 1198 1199设置多播通信中的环回模式标志位。使用callback方法作为异步方法。 1200 1201> **说明：** 1202> 用于设置环回模式，开启或关闭两种状态，默认为开启状态。 1203> 如果一个多播通信中环回模式设置值为 true，那么它允许主机在本地循环接收自己发送的多播数据包。如果为 false，则主机不会接收到自己发送的多播数据包。 1204> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1205 1206**系统能力**：SystemCapability.Communication.NetStack 1207 1208**参数：** 1209 1210| 参数名 | 类型 | 必填 | 说明 | 1211| ------------- | --------------------- | ---- | ---------------------------- | 1212| flag | boolean | 是 | ttl设置数值，类型为boolen 。 | 1213| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 1214 1215**错误码：** 1216 1217| 错误码ID | 错误信息 | 1218| ------- | ----------------------- | 1219| 401 | Parameter error. | 1220| 2301088 | Not a socket. | 1221 1222**示例：** 1223 1224```ts 1225import socket from "@ohos.net.socket"; 1226let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1227multicast.setLoopbackMode(false, (err: Object) => { 1228 if (err) { 1229 console.log('set loopback mode fail, err: ' + JSON.stringify(err)); 1230 return; 1231 } 1232 console.log('set loopback mode success'); 1233}) 1234``` 1235 1236### setLoopbackMode<sup>11+</sup> 1237 1238setLoopbackMode(flag: boolean): Promise\<void\>; 1239 1240设置多播通信中的环回模式标志位。使用callback方法作为异步方法。 1241 1242> **说明：** 1243> 用于设置环回模式，开启或关闭两种状态，默认为开启状态。 1244> 如果一个多播通信中环回模式设置值为 true，那么它允许主机在本地循环接收自己发送的多播数据包。如果为 false，则主机不会接收到自己发送的多播数据包。 1245> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1246 1247**系统能力**：SystemCapability.Communication.NetStack 1248 1249**参数：** 1250 1251| 参数名 | 类型 | 必填 | 说明 | 1252| ------------- | ---------------------- | ---- | -------------------------------- | 1253| flag | boolean | 是 | 环回模式标志位，类型为数字boolean。| 1254 1255**返回值：** 1256 1257| 类型 | 说明 | 1258| -------------- | ---------------------------------------------- | 1259| Promise\<void\> | 以Promise形式返回MulticastSocket设置环回模式的结果。 | 1260 1261**错误码：** 1262 1263| 错误码ID | 错误信息 | 1264| ------- | ----------------------- | 1265| 401 | Parameter error. | 1266| 2301088 | Not a socket. | 1267 1268**示例：** 1269 1270```ts 1271import socket from "@ohos.net.socket"; 1272let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1273multicast.setLoopbackMode(false).then(() => { 1274 console.log('set loopback mode success'); 1275}).catch((err: Object) => { 1276 console.log('set loopback mode failed'); 1277}); 1278``` 1279 1280### getLoopbackMode<sup>11+</sup> 1281 1282getLoopbackMode(callback: AsyncCallback\<boolean\>): void; 1283 1284获取多播通信中的环回模式状态。使用Promise方法作为异步方法。 1285 1286> **说明：** 1287> 用于获取当前环回模式开启或关闭的状态。 1288> 如果获取的属性值为 true，表示环回模式是开启的状态，允许主机在本地循环接收自己发送的多播数据包。如果为 false，则表示环回模式是关闭的状态，主机不会接收到自己发送的多播数据包。 1289> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1290 1291**系统能力**：SystemCapability.Communication.NetStack 1292 1293**参数：** 1294 1295| 参数名 | 类型 | 必填 | 说明 | 1296| ------------- | ----------------------- | ---- | --------------------------- | 1297| callback | AsyncCallback\<number\> | 是 | 回调函数。 | 1298 1299**错误码：** 1300 1301| 错误码ID | 错误信息 | 1302| ------- | ----------------------- | 1303| 401 | Parameter error. | 1304| 2301088 | Not a socket. | 1305 1306**示例：** 1307 1308```ts 1309import socket from "@ohos.net.socket"; 1310let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1311multicast.getLoopbackMode((err: Object, value: Boolean) => { 1312 if (err) { 1313 console.log('get loopback mode fail, err: ' + JSON.stringify(err)); 1314 return; 1315 } 1316 console.log('get loopback mode success, value: ' + JSON.stringify(value)); 1317}) 1318``` 1319 1320### getLoopbackMode<sup>11+</sup> 1321 1322getLoopbackMode(): Promise\<boolean\>; 1323 1324获取多播通信中的环回模式状态。使用Promise方法作为异步方法。 1325 1326> **说明：** 1327> 用于获取当前环回模式开启或关闭的状态。 1328> 如果获取的属性值为 true，表示环回模式是开启的状态，允许主机在本地循环接收自己发送的多播数据包。如果为 false，则表示环回模式是关闭的状态，主机不会接收到自己发送的多播数据包。 1329> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1330 1331**系统能力**：SystemCapability.Communication.NetStack 1332 1333**返回值：** 1334 1335| 类型 | 说明 | 1336| ---------------- | --------------------------- | 1337| Promise\<boolean\> | 以Promise形式返回当前TTL数值。 | 1338 1339**错误码：** 1340 1341| 错误码ID | 错误信息 | 1342| ------- | ----------------------- | 1343| 401 | Parameter error. | 1344| 2301088 | Not a socket. | 1345 1346**示例：** 1347 1348```ts 1349import socket from "@ohos.net.socket"; 1350let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1351multicast.getLoopbackMode().then((value: Boolean) => { 1352 console.log('loopback mode: ', JSON.stringify(value)); 1353}).catch((err: Object) => { 1354 console.log('get loopback mode failed'); 1355}); 1356``` 1357 1358 1359### send<sup>7+</sup> 1360 1361send(options: UDPSendOptions, callback: AsyncCallback\<void\>): void 1362 1363发送数据。使用callback方式作为异步方法。 1364 1365发送数据前，需要先调用 [addMembership](#addmembership11) 加入多播组。 1366 1367**需要权限**：ohos.permission.INTERNET 1368 1369**系统能力**：SystemCapability.Communication.NetStack 1370 1371**参数：** 1372 1373| 参数名 | 类型 | 必填 | 说明 | 1374| -------- | --------------------------------- | ---- | ------------------------------------------------------------ | 1375| options | [UDPSendOptions](#udpsendoptions) | 是 | UDPSocket发送参数，参考[UDPSendOptions](#udpsendoptions)。 | 1376| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 1377 1378**错误码：** 1379 1380| 错误码ID | 错误信息 | 1381| ------- | ----------------------- | 1382| 401 | Parameter error. | 1383| 201 | Permission denied. | 1384 1385**示例：** 1386 1387```ts 1388import socket from '@ohos.net.socket'; 1389let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1390let sendOptions: socket.UDPSendOptions = { 1391 data: 'Hello, server!', 1392 address: { 1393 address: '239.255.0.1', 1394 port: 8080 1395 } 1396} 1397multicast.send(sendOptions, (err: Object) => { 1398 if (err) { 1399 console.log('send fail: ' + JSON.stringify(err)); 1400 return; 1401 } 1402 console.log('send success'); 1403}); 1404``` 1405 1406### send<sup>7+</sup> 1407 1408send(options: UDPSendOptions): Promise\<void\> 1409 1410发送数据。使用Promise方式作为异步方法。 1411 1412发送数据前，需要先调用 [addMembership](#addmembership11) 加入多播组。 1413 1414**需要权限**：ohos.permission.INTERNET 1415 1416**系统能力**：SystemCapability.Communication.NetStack 1417 1418**参数：** 1419 1420| 参数名 | 类型 | 必填 | 说明 | 1421| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 1422| options | [UDPSendOptions](#udpsendoptions) | 是 | UDPSocket发送参数，参考[UDPSendOptions](#udpsendoptions)。 | 1423 1424**错误码：** 1425 1426| 错误码ID | 错误信息 | 1427| ------- | ----------------------- | 1428| 401 | Parameter error. | 1429| 201 | Permission denied. | 1430 1431**返回值：** 1432 1433| 类型 | 说明 | 1434| :-------------- | :------------------------------- | 1435| Promise\<void\> | 以Promise形式返回发送数据的执行结果。 | 1436 1437**示例：** 1438 1439```ts 1440import socket from '@ohos.net.socket'; 1441let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1442let sendOptions: socket.UDPSendOptions = { 1443 data: 'Hello, server!', 1444 address: { 1445 address: '239.255.0.1', 1446 port: 8080 1447 } 1448} 1449multicast.send(sendOptions).then(() => { 1450 console.log('send success'); 1451}).catch((err: Object) => { 1452 console.log('send fail, ' + JSON.stringify(err)); 1453}); 1454``` 1455 1456### on('message')<sup>7+</sup> 1457 1458on(type: 'message', callback: Callback\<SocketMessageInfo\>): void 1459 1460订阅MulticastSocket接收消息事件。使用callback方式作为异步方法。 1461 1462**系统能力**：SystemCapability.Communication.NetStack 1463 1464**参数：** 1465 1466| 参数名 | 类型 | 必填 | 说明 | 1467| -------- | ------------------------------------------------------------------------------------- | ---- | ----------------------------------- | 1468| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 1469| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 是 | 回调函数。 | 1470 1471**示例：** 1472 1473```ts 1474import socket from "@ohos.net.socket" 1475let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance() 1476 1477multicast.on('message', (data) => { 1478 console.info('接收的数据: ' + JSON.stringify(data)) 1479 const uintArray = new Uint8Array(data.message) 1480 let str = '' 1481 for (let i = 0; i < uintArray.length; ++i) { 1482 str += String.fromCharCode(uintArray[i]) 1483 } 1484 console.info(str) 1485}) 1486``` 1487 1488### off('message')<sup>7+</sup> 1489 1490off(type: 'message', callback?: Callback\<SocketMessageInfo\>): void 1491 1492取消订阅消息事件。使用callback方式作为异步方法。 1493 1494**系统能力**：SystemCapability.Communication.NetStack 1495 1496**参数：** 1497 1498| 参数名 | 类型 | 必填 | 说明 | 1499| -------- | ----------------------------------------------------------------------------------- | ---- | ----------------------------------- | 1500| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 1501| callback | Callback<[SocketMessageInfo](#socketmessageinfo11)> | 否 | 回调函数。 | 1502 1503**示例：** 1504 1505```ts 1506import socket from "@ohos.net.socket" 1507let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance() 1508multicast.on('message', (data) => { 1509 console.info('接收的数据: ' + JSON.stringify(data)) 1510 const uintArray = new Uint8Array(data.message) 1511 let str = '' 1512 for (let i = 0; i < uintArray.length; ++i) { 1513 str += String.fromCharCode(uintArray[i]) 1514 } 1515 console.info(str) 1516}) 1517multicast.off('message') 1518``` 1519 1520 1521## socket.constructTCPSocketInstance<sup>7+</sup> 1522 1523constructTCPSocketInstance(): TCPSocket 1524 1525创建一个TCPSocket对象。 1526 1527**系统能力**：SystemCapability.Communication.NetStack 1528 1529**返回值：** 1530 1531| 类型 | 说明 | 1532| --------------------------------- | ---------------------- | 1533| [TCPSocket](#tcpsocket) | 返回一个TCPSocket对象。 | 1534 1535**示例：** 1536 1537```ts 1538import socket from "@ohos.net.socket"; 1539let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1540``` 1541 1542## TCPSocket 1543 1544TCPSocket连接。在调用TCPSocket的方法前，需要先通过[socket.constructTCPSocketInstance](#socketconstructtcpsocketinstance7)创建TCPSocket对象。 1545 1546### bind 1547 1548bind(address: NetAddress, callback: AsyncCallback\<void\>): void 1549 1550绑定IP地址和端口，端口可以指定为0由系统随机分配或指定为其它非0端口。使用callback方法作为异步方法。 1551 1552> **说明：** 1553> bind方法如果因为端口冲突而执行失败，则会由系统随机分配端口号。 1554> TCP客户端可先调用该接口(tcp.bind)显式绑定IP地址和端口号，再调用tcp.connect完成与服务端的连接；也可直接调用tcp.connect由系统自动绑定IP地址和端口号，完成与服务端的连接。 1555> bind的IP为'localhost'或'127.0.0.1'时，只允许本地回环接口的连接，即服务端和客户端运行在同一台机器上。 1556 1557**需要权限**：ohos.permission.INTERNET 1558 1559**系统能力**：SystemCapability.Communication.NetStack 1560 1561**参数：** 1562 1563| 参数名 | 类型 | 必填 | 说明 | 1564| -------- | ---------------------------------- | ---- | ------------------------------------------------------ | 1565| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 1566| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 1567 1568**错误码：** 1569 1570| 错误码ID | 错误信息 | 1571| ------- | ----------------------- | 1572| 401 | Parameter error. | 1573| 201 | Permission denied. | 1574 1575**示例：** 1576 1577```ts 1578import socket from "@ohos.net.socket"; 1579import { BusinessError } from '@ohos.base'; 1580let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1581let bindAddr: socket.NetAddress = { 1582 address: '192.168.xx.xxx', 1583 port: 8080 1584} 1585tcp.bind(bindAddr, (err: BusinessError) => { 1586 if (err) { 1587 console.log('bind fail'); 1588 return; 1589 } 1590 console.log('bind success'); 1591}) 1592``` 1593 1594### bind 1595 1596bind(address: NetAddress): Promise\<void\> 1597 1598绑定IP地址和端口，端口可以指定为0由系统随机分配或指定为其它非0端口。使用Promise方法作为异步方法。 1599 1600> **说明：** 1601> bind方法如果因为端口冲突而执行失败，则会由系统随机分配端口号。 1602> TCP客户端可先调用该接口(tcp.bind)显式绑定IP地址和端口号，再调用tcp.connect完成与服务端的连接；也可直接调用tcp.connect由系统自动绑定IP地址和端口号，完成与服务端的连接。 1603> bind的IP为'localhost'或'127.0.0.1'时，只允许本地回环接口的连接，即服务端和客户端运行在同一台机器上。 1604 1605**需要权限**：ohos.permission.INTERNET 1606 1607**系统能力**：SystemCapability.Communication.NetStack 1608 1609**参数：** 1610 1611| 参数名 | 类型 | 必填 | 说明 | 1612| ------- | ---------------------------------- | ---- | ------------------------------------------------------ | 1613| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 1614 1615**返回值：** 1616 1617| 类型 | 说明 | 1618| --------------- | ------------------------------------------------------- | 1619| Promise\<void\> | 以Promise形式返回TCPSocket绑定本机的IP地址和端口的结果。 | 1620 1621**错误码：** 1622 1623| 错误码ID | 错误信息 | 1624| ------- | ----------------------- | 1625| 401 | Parameter error. | 1626| 201 | Permission denied. | 1627 1628**示例：** 1629 1630```ts 1631import socket from "@ohos.net.socket"; 1632import { BusinessError } from '@ohos.base'; 1633let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1634let bindAddr: socket.NetAddress = { 1635 address: '192.168.xx.xxx', 1636 port: 8080 1637} 1638tcp.bind(bindAddr).then(() => { 1639 console.log('bind success'); 1640}).catch((err: BusinessError) => { 1641 console.log('bind fail'); 1642}); 1643``` 1644 1645### connect 1646 1647connect(options: TCPConnectOptions, callback: AsyncCallback\<void\>): void 1648 1649连接到指定的IP地址和端口。使用callback方法作为异步方法。 1650 1651> **说明：** 1652> 在没有执行tcp.bind的情况下，也可以直接调用该接口完成与TCP服务端的连接 1653 1654**需要权限**：ohos.permission.INTERNET 1655 1656**系统能力**：SystemCapability.Communication.NetStack 1657 1658**参数：** 1659 1660| 参数名 | 类型 | 必填 | 说明 | 1661| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 1662| options | [TCPConnectOptions](#tcpconnectoptions) | 是 | TCPSocket连接的参数，参考[TCPConnectOptions](#tcpconnectoptions)。 | 1663| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 1664 1665**错误码：** 1666 1667| 错误码ID | 错误信息 | 1668| ------- | ----------------------- | 1669| 401 | Parameter error. | 1670| 201 | Permission denied. | 1671 1672**示例：** 1673 1674```ts 1675import socket from "@ohos.net.socket"; 1676import { BusinessError } from '@ohos.base'; 1677let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1678 1679let tcpconnectoptions: socket.TCPConnectOptions = { 1680 address: { 1681 address: '192.168.xx.xxx', 1682 port: 8080 1683 }, 1684 timeout: 6000 1685} 1686tcp.connect(tcpconnectoptions, (err: BusinessError) => { 1687 if (err) { 1688 console.log('connect fail'); 1689 return; 1690 } 1691 console.log('connect success'); 1692}) 1693``` 1694 1695### connect 1696 1697connect(options: TCPConnectOptions): Promise\<void\> 1698 1699连接到指定的IP地址和端口。使用promise方法作为异步方法。 1700 1701> **说明：** 1702> 在没有执行tcp.bind的情况下，也可以直接调用该接口完成与TCP服务端的连接。 1703 1704**需要权限**：ohos.permission.INTERNET 1705 1706**系统能力**：SystemCapability.Communication.NetStack 1707 1708**参数：** 1709 1710| 参数名 | 类型 | 必填 | 说明 | 1711| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 1712| options | [TCPConnectOptions](#tcpconnectoptions) | 是 | TCPSocket连接的参数，参考[TCPConnectOptions](#tcpconnectoptions)。 | 1713 1714**返回值：** 1715 1716| 类型 | 说明 | 1717| -------------- | --------------------------------------------------------- | 1718| Promise\<void\> | 以Promise形式返回TCPSocket连接到指定的IP地址和端口的结果。 | 1719 1720**错误码：** 1721 1722| 错误码ID | 错误信息 | 1723| ------- | ----------------------- | 1724| 401 | Parameter error. | 1725| 201 | Permission denied. | 1726 1727**示例：** 1728 1729```ts 1730import socket from "@ohos.net.socket"; 1731import { BusinessError } from '@ohos.base'; 1732let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1733 1734let tcpconnectoptions: socket.TCPConnectOptions = { 1735 address: { 1736 address: '192.168.xx.xxx', 1737 port: 8080 1738 }, 1739 timeout: 6000 1740} 1741tcp.connect(tcpconnectoptions).then(() => { 1742 console.log('connect success') 1743}).catch((err: BusinessError) => { 1744 console.log('connect fail'); 1745}); 1746``` 1747 1748### send 1749 1750send(options: TCPSendOptions, callback: AsyncCallback\<void\>): void 1751 1752通过TCPSocket连接发送数据。使用callback方式作为异步方法。 1753 1754> **说明：** 1755> connect方法调用成功后，才可调用此方法。 1756 1757**需要权限**：ohos.permission.INTERNET 1758 1759**系统能力**：SystemCapability.Communication.NetStack 1760 1761**参数：** 1762 1763| 参数名 | 类型 | 必填 | 说明 | 1764| -------- | --------------------------------------- | ---- | ------------------------------------------------------------ | 1765| options | [TCPSendOptions](#tcpsendoptions) | 是 | TCPSocket发送请求的参数，参考[TCPSendOptions](#tcpsendoptions)。 | 1766| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 1767 1768**错误码：** 1769 1770| 错误码ID | 错误信息 | 1771| ------- | ----------------------- | 1772| 401 | Parameter error. | 1773| 201 | Permission denied. | 1774 1775**示例：** 1776 1777```ts 1778import socket from "@ohos.net.socket"; 1779import { BusinessError } from '@ohos.base'; 1780let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1781 1782let tcpconnectoptions: socket.TCPConnectOptions = { 1783 address: { 1784 address: '192.168.xx.xxx', 1785 port: 8080 1786 }, 1787 timeout: 6000 1788} 1789tcp.connect(tcpconnectoptions, () => { 1790 console.log('connect success'); 1791 let tcpSendOptions: socket.TCPSendOptions = { 1792 data: 'Hello, server!' 1793 } 1794 tcp.send(tcpSendOptions, (err: BusinessError) => { 1795 if (err) { 1796 console.log('send fail'); 1797 return; 1798 } 1799 console.log('send success'); 1800 }) 1801}) 1802``` 1803 1804### send 1805 1806send(options: TCPSendOptions): Promise\<void\> 1807 1808通过TCPSocket连接发送数据。使用Promise方式作为异步方法。 1809 1810> **说明：** 1811> connect方法调用成功后，才可调用此方法。 1812 1813**需要权限**：ohos.permission.INTERNET 1814 1815**系统能力**：SystemCapability.Communication.NetStack 1816 1817**参数：** 1818 1819| 参数名 | 类型 | 必填 | 说明 | 1820| ------- | --------------------------------------- | ---- | ------------------------------------------------------------ | 1821| options | [TCPSendOptions](#tcpsendoptions) | 是 | TCPSocket发送请求的参数，参考[TCPSendOptions](#tcpsendoptions)。 | 1822 1823**返回值：** 1824 1825| 类型 | 说明 | 1826| -------------- | ------------------------------------------------- | 1827| Promise\<void\> | 以Promise形式返回通过TCPSocket连接发送数据的结果。 | 1828 1829**错误码：** 1830 1831| 错误码ID | 错误信息 | 1832| ------- | ----------------------- | 1833| 401 | Parameter error. | 1834| 201 | Permission denied. | 1835 1836**示例：** 1837 1838```ts 1839import socket from "@ohos.net.socket"; 1840import { BusinessError } from '@ohos.base'; 1841let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1842 1843let tcpconnectoptions: socket.TCPConnectOptions = { 1844 address: { 1845 address: '192.168.xx.xxx', 1846 port: 8080 1847 }, 1848 timeout: 6000 1849} 1850tcp.connect(tcpconnectoptions, () => { 1851 console.log('connect success'); 1852 let tcpSendOptions: socket.TCPSendOptions = { 1853 data: 'Hello, server!' 1854 } 1855 tcp.send(tcpSendOptions).then(() => { 1856 console.log('send success'); 1857 }).catch((err: BusinessError) => { 1858 console.log('send fail'); 1859 }); 1860}) 1861``` 1862 1863### close 1864 1865close(callback: AsyncCallback\<void\>): void 1866 1867关闭TCPSocket连接。使用callback方式作为异步方法。 1868 1869**需要权限**：ohos.permission.INTERNET 1870 1871**系统能力**：SystemCapability.Communication.NetStack 1872 1873**参数：** 1874 1875| 参数名 | 类型 | 必填 | 说明 | 1876| -------- | --------------------- | ---- | ---------- | 1877| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 1878 1879**错误码：** 1880 1881| 错误码ID | 错误信息 | 1882| ------- | ----------------------- | 1883| 201 | Permission denied. | 1884 1885**示例：** 1886 1887```ts 1888import socket from "@ohos.net.socket"; 1889import { BusinessError } from '@ohos.base'; 1890let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1891 1892tcp.close((err: BusinessError) => { 1893 if (err) { 1894 console.log('close fail'); 1895 return; 1896 } 1897 console.log('close success'); 1898}) 1899``` 1900 1901### close 1902 1903close(): Promise\<void\> 1904 1905关闭TCPSocket连接。使用Promise方式作为异步方法。 1906 1907**需要权限**：ohos.permission.INTERNET 1908 1909**系统能力**：SystemCapability.Communication.NetStack 1910 1911**返回值：** 1912 1913| 类型 | 说明 | 1914| -------------- | ----------------------------------------- | 1915| Promise\<void\> | 以Promise形式返回关闭TCPSocket连接的结果。 | 1916 1917**错误码：** 1918 1919| 错误码ID | 错误信息 | 1920| ------- | ----------------------- | 1921| 201 | Permission denied. | 1922 1923**示例：** 1924 1925```ts 1926import socket from "@ohos.net.socket"; 1927let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1928 1929tcp.close().then(() => { 1930 console.log('close success'); 1931}).catch((err: BusinessError) => { 1932 console.log('close fail'); 1933}); 1934``` 1935 1936### getRemoteAddress 1937 1938getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void 1939 1940获取对端Socket地址。使用callback方式作为异步方法。 1941 1942> **说明：** 1943> connect方法调用成功后，才可调用此方法。 1944 1945**需要权限**：ohos.permission.INTERNET 1946 1947**系统能力**：SystemCapability.Communication.NetStack 1948 1949**参数：** 1950 1951| 参数名 | 类型 | 必填 | 说明 | 1952| -------- | ------------------------------------------------- | ---- | ---------- | 1953| callback | AsyncCallback<[NetAddress](#netaddress)> | 是 | 回调函数。 | 1954 1955**错误码：** 1956 1957| 错误码ID | 错误信息 | 1958| ------- | ----------------------- | 1959| 201 | Permission denied. | 1960 1961**示例：** 1962 1963```ts 1964import socket from "@ohos.net.socket"; 1965import { BusinessError } from '@ohos.base'; 1966let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1967 1968let tcpconnectoptions: socket.TCPConnectOptions = { 1969 address: { 1970 address: '192.168.xx.xxx', 1971 port: 8080 1972 }, 1973 timeout: 6000 1974} 1975tcp.connect(tcpconnectoptions, () => { 1976 console.log('connect success'); 1977 tcp.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => { 1978 if (err) { 1979 console.log('getRemoteAddressfail'); 1980 return; 1981 } 1982 console.log('getRemoteAddresssuccess:' + JSON.stringify(data)); 1983 }) 1984}); 1985``` 1986 1987### getRemoteAddress 1988 1989getRemoteAddress(): Promise\<NetAddress\> 1990 1991获取对端Socket地址。使用Promise方式作为异步方法。 1992 1993> **说明：** 1994> connect方法调用成功后，才可调用此方法。 1995 1996**需要权限**：ohos.permission.INTERNET 1997 1998**系统能力**：SystemCapability.Communication.NetStack 1999 2000**返回值：** 2001 2002| 类型 | 说明 | 2003| ------------------------------------------ | ------------------------------------------ | 2004| Promise<[NetAddress](#netaddress)> | 以Promise形式返回获取对端socket地址的结果。 | 2005 2006**错误码：** 2007 2008| 错误码ID | 错误信息 | 2009| ------- | ----------------------- | 2010| 201 | Permission denied. | 2011 2012**示例：** 2013 2014```ts 2015import socket from "@ohos.net.socket"; 2016import { BusinessError } from '@ohos.base'; 2017let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2018 2019let tcpconnectoptions: socket.TCPConnectOptions = { 2020 address: { 2021 address: '192.168.xx.xxx', 2022 port: 8080 2023 }, 2024 timeout: 6000 2025} 2026tcp.connect(tcpconnectoptions).then(() => { 2027 console.log('connect success'); 2028 tcp.getRemoteAddress().then(() => { 2029 console.log('getRemoteAddress success'); 2030 }).catch((err: BusinessError) => { 2031 console.log('getRemoteAddressfail'); 2032 }); 2033}).catch((err: BusinessError) => { 2034 console.log('connect fail'); 2035}); 2036``` 2037 2038### getState 2039 2040getState(callback: AsyncCallback\<SocketStateBase\>): void 2041 2042获取TCPSocket状态。使用callback方式作为异步方法。 2043 2044> **说明：** 2045> bind或connect方法调用成功后，才可调用此方法。 2046 2047**需要权限**：ohos.permission.INTERNET 2048 2049**系统能力**：SystemCapability.Communication.NetStack 2050 2051**参数：** 2052 2053| 参数名 | 类型 | 必填 | 说明 | 2054| -------- | ------------------------------------------------------ | ---- | ---------- | 2055| callback | AsyncCallback<[SocketStateBase](#socketstatebase)> | 是 | 回调函数。 | 2056 2057**错误码：** 2058 2059| 错误码ID | 错误信息 | 2060| ------- | ----------------------- | 2061| 201 | Permission denied. | 2062 2063**示例：** 2064 2065```ts 2066import socket from "@ohos.net.socket"; 2067import { BusinessError } from '@ohos.base'; 2068let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2069 2070let tcpconnectoptions: socket.TCPConnectOptions = { 2071 address: { 2072 address: '192.168.xx.xxx', 2073 port: 8080 2074 }, 2075 timeout: 6000 2076} 2077tcp.connect(tcpconnectoptions, () => { 2078 console.log('connect success'); 2079 tcp.getState((err: BusinessError, data: socket.SocketStateBase) => { 2080 if (err) { 2081 console.log('getState fail'); 2082 return; 2083 } 2084 console.log('getState success:' + JSON.stringify(data)); 2085 }); 2086}); 2087``` 2088 2089### getState 2090 2091getState(): Promise\<SocketStateBase\> 2092 2093获取TCPSocket状态。使用Promise方式作为异步方法。 2094 2095> **说明：** 2096> bind或connect方法调用成功后，才可调用此方法。 2097 2098**需要权限**：ohos.permission.INTERNET 2099 2100**系统能力**：SystemCapability.Communication.NetStack 2101 2102**返回值：** 2103 2104| 类型 | 说明 | 2105| ----------------------------------------------- | ----------------------------------------- | 2106| Promise<[SocketStateBase](#socketstatebase)> | 以Promise形式返回获取TCPSocket状态的结果。 | 2107 2108**错误码：** 2109 2110| 错误码ID | 错误信息 | 2111| ------- | ----------------------- | 2112| 201 | Permission denied. | 2113 2114**示例：** 2115 2116```ts 2117import socket from "@ohos.net.socket"; 2118import { BusinessError } from '@ohos.base'; 2119let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2120 2121let tcpconnectoptions: socket.TCPConnectOptions = { 2122 address: { 2123 address: '192.168.xx.xxx', 2124 port: 8080 2125 }, 2126 timeout: 6000 2127} 2128tcp.connect(tcpconnectoptions).then(() => { 2129 console.log('connect success'); 2130 tcp.getState().then(() => { 2131 console.log('getState success'); 2132 }).catch((err: BusinessError) => { 2133 console.log('getState fail'); 2134 }); 2135}).catch((err: BusinessError) => { 2136 console.log('connect fail'); 2137}); 2138``` 2139 2140### getSocketFd<sup>10+</sup> 2141 2142getSocketFd(callback: AsyncCallback\<number\>): void 2143 2144获取TCPSocket的文件描述符。使用callback方式作为异步方法。 2145 2146> **说明：** 2147> bind或connect方法调用成功后，才可调用此方法。 2148 2149**系统能力**：SystemCapability.Communication.NetStack 2150 2151**参数：** 2152 2153| 参数名 | 类型 | 必填 | 说明 | 2154| -------- | ------------------------------------------------------ | ---- | ---------- | 2155| callback | AsyncCallback\<number\> | 是 | 回调函数，当成功时，返回socket的文件描述符，失败时，返回undefined。 | 2156 2157**示例：** 2158 2159```ts 2160import socket from "@ohos.net.socket"; 2161import { BusinessError } from '@ohos.base'; 2162let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2163let bindAddr: socket.NetAddress = { 2164 address: '0.0.0.0' 2165} 2166tcp.bind(bindAddr) 2167let tcpconnectoptions: socket.TCPConnectOptions = { 2168 address: { 2169 address: '192.168.xx.xxx', 2170 port: 8080 2171 }, 2172 timeout: 6000 2173} 2174tcp.connect(tcpconnectoptions) 2175tcp.getSocketFd((err: BusinessError, data: number) => { 2176 console.info("getSocketFd failed: " + err); 2177 console.info("tunenlfd: " + data); 2178}) 2179``` 2180### getSocketFd<sup>10+</sup> 2181 2182getSocketFd(): Promise\<number\> 2183 2184获取TCPSocket的文件描述符。使用Promise方式作为异步方法。 2185 2186> **说明：** 2187> bind或connect方法调用成功后，才可调用此方法。 2188 2189**系统能力**：SystemCapability.Communication.NetStack 2190 2191**返回值：** 2192 2193| 类型 | 说明 | 2194| ----------------------------------------------- | ----------------------------------------- | 2195| Promise\<number\> | 以Promise形式返回socket的文件描述符。 | 2196 2197**示例：** 2198 2199```ts 2200import socket from "@ohos.net.socket"; 2201import { BusinessError } from '@ohos.base'; 2202let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2203let bindAddr: socket.NetAddress = { 2204 address: '0.0.0.0' 2205} 2206tcp.bind(bindAddr) 2207let tcpconnectoptions: socket.TCPConnectOptions = { 2208 address: { 2209 address: '192.168.xx.xxx', 2210 port: 8080 2211 }, 2212 timeout: 6000 2213} 2214tcp.connect(tcpconnectoptions) 2215tcp.getSocketFd().then((data: number) => { 2216 console.info("tunenlfd: " + data); 2217}) 2218``` 2219 2220### setExtraOptions 2221 2222setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void 2223 2224设置TCPSocket连接的其他属性。使用callback方式作为异步方法。 2225 2226> **说明：** 2227> bind或connect方法调用成功后，才可调用此方法。 2228 2229**需要权限**：ohos.permission.INTERNET 2230 2231**系统能力**：SystemCapability.Communication.NetStack 2232 2233**参数：** 2234 2235| 参数名 | 类型 | 必填 | 说明 | 2236| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 2237| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 | 2238| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 2239 2240**错误码：** 2241 2242| 错误码ID | 错误信息 | 2243| ------- | ----------------------- | 2244| 401 | Parameter error. | 2245| 201 | Permission denied. | 2246 2247**示例：** 2248 2249```ts 2250import socket from "@ohos.net.socket"; 2251import { BusinessError } from '@ohos.base'; 2252let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2253let tcpconnectoptions: socket.TCPConnectOptions = { 2254 address: { 2255 address: '192.168.xx.xxx', 2256 port: 8080 2257 }, 2258 timeout: 6000 2259} 2260tcp.connect(tcpconnectoptions, () => { 2261 console.log('connect success'); 2262 let tcpExtraOptions: socket.TCPExtraOptions = { 2263 keepAlive: true, 2264 OOBInline: true, 2265 TCPNoDelay: true, 2266 socketLinger: { on: true, linger: 10 }, 2267 receiveBufferSize: 1000, 2268 sendBufferSize: 1000, 2269 reuseAddress: true, 2270 socketTimeout: 3000 2271 } 2272 tcp.setExtraOptions(tcpExtraOptions, (err: BusinessError) => { 2273 if (err) { 2274 console.log('setExtraOptions fail'); 2275 return; 2276 } 2277 console.log('setExtraOptions success'); 2278 }); 2279}); 2280``` 2281 2282### setExtraOptions 2283 2284setExtraOptions(options: TCPExtraOptions): Promise\<void\> 2285 2286设置TCPSocket连接的其他属性，使用Promise方式作为异步方法。 2287 2288> **说明：** 2289> bind或connect方法调用成功后，才可调用此方法。 2290 2291**需要权限**：ohos.permission.INTERNET 2292 2293**系统能力**：SystemCapability.Communication.NetStack 2294 2295**参数：** 2296 2297| 参数名 | 类型 | 必填 | 说明 | 2298| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 2299| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 | 2300 2301**返回值：** 2302 2303| 类型 | 说明 | 2304| -------------- | --------------------------------------------------- | 2305| Promise\<void\> | 以Promise形式返回设置TCPSocket连接的其他属性的结果。 | 2306 2307**错误码：** 2308 2309| 错误码ID | 错误信息 | 2310| ------- | ----------------------- | 2311| 401 | Parameter error. | 2312| 201 | Permission denied. | 2313 2314**示例：** 2315 2316```ts 2317import socket from "@ohos.net.socket"; 2318import { BusinessError } from '@ohos.base'; 2319let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2320let tcpconnectoptions: socket.TCPConnectOptions = { 2321 address: { 2322 address: '192.168.xx.xxx', 2323 port: 8080 2324 }, 2325 timeout: 6000 2326} 2327tcp.connect(tcpconnectoptions, () => { 2328 console.log('connect success'); 2329 let tcpExtraOptions: socket.TCPExtraOptions = { 2330 keepAlive: true, 2331 OOBInline: true, 2332 TCPNoDelay: true, 2333 socketLinger: { on: true, linger: 10 }, 2334 receiveBufferSize: 1000, 2335 sendBufferSize: 1000, 2336 reuseAddress: true, 2337 socketTimeout: 3000 2338 } 2339 tcp.setExtraOptions(tcpExtraOptions).then(() => { 2340 console.log('setExtraOptions success'); 2341 }).catch((err: BusinessError) => { 2342 console.log('setExtraOptions fail'); 2343 }); 2344}); 2345``` 2346 2347### on('message') 2348 2349on(type: 'message', callback: Callback<SocketMessageInfo\>): void 2350 2351订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。 2352 2353**系统能力**：SystemCapability.Communication.NetStack 2354 2355**参数：** 2356 2357| 参数名 | 类型 | 必填 | 说明 | 2358| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 2359| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 2360| callback | Callback<[SocketMessageInfo](#socketmessageinfo11)> | 是 | 回调函数。 | 2361 2362**示例：** 2363 2364```ts 2365import socket from "@ohos.net.socket"; 2366import { BusinessError } from '@ohos.base'; 2367let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2368let messageView = ''; 2369tcp.on('message', (value: socket.SocketMessageInfo) => { 2370 for (let i: number = 0; i < value.message.byteLength; i++) { 2371 let uint8Array = new Uint8Array(value.message) 2372 let messages = uint8Array[i] 2373 let message = String.fromCharCode(messages); 2374 messageView += message; 2375 } 2376 console.log('on message message: ' + JSON.stringify(messageView)); 2377 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 2378}); 2379``` 2380 2381### off('message') 2382 2383off(type: 'message', callback?: Callback<SocketMessageInfo\>): void 2384 2385取消订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。 2386 2387> **说明：** 2388> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2389 2390**系统能力**：SystemCapability.Communication.NetStack 2391 2392**参数：** 2393 2394| 参数名 | 类型 | 必填 | 说明 | 2395| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 2396| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 2397| callback | Callback<[SocketMessageInfo](#socketmessageinfo11)> | 否 | 回调函数。 | 2398 2399**示例：** 2400 2401```ts 2402import socket from "@ohos.net.socket"; 2403import { BusinessError } from '@ohos.base'; 2404let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2405let messageView = ''; 2406let callback = (value: socket.SocketMessageInfo) => { 2407 for (let i: number = 0; i < value.message.byteLength; i++) { 2408 let uint8Array = new Uint8Array(value.message) 2409 let messages = uint8Array[i] 2410 let message = String.fromCharCode(messages); 2411 messageView += message; 2412 } 2413 console.log('on message message: ' + JSON.stringify(messageView)); 2414 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 2415} 2416tcp.on('message', callback); 2417// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2418tcp.off('message', callback); 2419tcp.off('message'); 2420``` 2421 2422### on('connect' | 'close') 2423 2424on(type: 'connect' | 'close', callback: Callback\<void\>): void 2425 2426订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。 2427 2428**系统能力**：SystemCapability.Communication.NetStack 2429 2430**参数：** 2431 2432| 参数名 | 类型 | 必填 | 说明 | 2433| -------- | ---------------- | ---- | ------------------------------------------------------------ | 2434| type | string | 是 | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 | 2435| callback | Callback\<void\> | 是 | 回调函数。 | 2436 2437**示例：** 2438 2439```ts 2440import socket from "@ohos.net.socket"; 2441import { BusinessError } from '@ohos.base'; 2442let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2443tcp.on('connect', () => { 2444 console.log("on connect success") 2445}); 2446tcp.on('close', () => { 2447 console.log("on close success") 2448}); 2449``` 2450 2451### off('connect' | 'close') 2452 2453off(type: 'connect' | 'close', callback?: Callback\<void\>): void 2454 2455取消订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。 2456 2457> **说明：** 2458> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2459 2460**系统能力**：SystemCapability.Communication.NetStack 2461 2462**参数：** 2463 2464| 参数名 | 类型 | 必填 | 说明 | 2465| -------- | ---------------- | ---- | ------------------------------------------------------------ | 2466| type | string | 是 | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 | 2467| callback | Callback\<void\> | 否 | 回调函数。 | 2468 2469**示例：** 2470 2471```ts 2472import socket from "@ohos.net.socket"; 2473import { BusinessError } from '@ohos.base'; 2474let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2475let callback1 = () => { 2476 console.log("on connect success"); 2477} 2478tcp.on('connect', callback1); 2479// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2480tcp.off('connect', callback1); 2481tcp.off('connect'); 2482let callback2 = () => { 2483 console.log("on close success"); 2484} 2485tcp.on('close', callback2); 2486// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2487tcp.off('close', callback2); 2488tcp.off('close'); 2489``` 2490 2491### on('error') 2492 2493on(type: 'error', callback: ErrorCallback): void 2494 2495订阅TCPSocket连接的error事件。使用callback方式作为异步方法。 2496 2497**系统能力**：SystemCapability.Communication.NetStack 2498 2499**参数：** 2500 2501| 参数名 | 类型 | 必填 | 说明 | 2502| -------- | ------------- | ---- | ------------------------------------ | 2503| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 2504| callback | ErrorCallback | 是 | 回调函数。 | 2505 2506**示例：** 2507 2508```ts 2509import socket from "@ohos.net.socket"; 2510import { BusinessError } from '@ohos.base'; 2511let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2512tcp.on('error', (err: BusinessError) => { 2513 console.log("on error, err:" + JSON.stringify(err)) 2514}); 2515``` 2516 2517### off('error') 2518 2519off(type: 'error', callback?: ErrorCallback): void 2520 2521取消订阅TCPSocket连接的error事件。使用callback方式作为异步方法。 2522 2523> **说明：** 2524> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2525 2526**系统能力**：SystemCapability.Communication.NetStack 2527 2528**参数：** 2529 2530| 参数名 | 类型 | 必填 | 说明 | 2531| -------- | ------------- | ---- | ------------------------------------ | 2532| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 2533| callback | ErrorCallback | 否 | 回调函数。 | 2534 2535**示例：** 2536 2537```ts 2538import socket from "@ohos.net.socket"; 2539import { BusinessError } from '@ohos.base'; 2540let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2541let callback = (err: BusinessError) => { 2542 console.log("on error, err:" + JSON.stringify(err)); 2543} 2544tcp.on('error', callback); 2545// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2546tcp.off('error', callback); 2547tcp.off('error'); 2548``` 2549 2550## TCPConnectOptions 2551 2552TCPSocket连接的参数。 2553 2554**系统能力**：SystemCapability.Communication.NetStack 2555 2556| 名称 | 类型 | 必填 | 说明 | 2557| ------- | ---------------------------------- | ---- | -------------------------- | 2558| address | [NetAddress](#netaddress) | 是 | 绑定的地址以及端口。 | 2559| timeout | number | 否 | 超时时间，单位毫秒（ms）。 | 2560 2561## TCPSendOptions 2562 2563TCPSocket发送请求的参数。 2564 2565**系统能力**：SystemCapability.Communication.NetStack 2566 2567| 名称 | 类型 | 必填 | 说明 | 2568| -------- | ------ | ---- | ------------------------------------------------------------ | 2569| data | string\| ArrayBuffer | 是 | 发送的数据。 | 2570| encoding | string | 否 | 字符编码(UTF-8，UTF-16BE，UTF-16LE，UTF-16，US-AECII，ISO-8859-1)，默认为UTF-8。 | 2571 2572## TCPExtraOptions 2573 2574TCPSocket连接的其他属性。 2575 2576**系统能力**：SystemCapability.Communication.NetStack 2577 2578| 名称 | 类型 | 必填 | 说明 | 2579| ----------------- | ------- | ---- | ------------------------------------------------------------ | 2580| keepAlive | boolean | 否 | 是否保持连接。默认为false。 | 2581| OOBInline | boolean | 否 | 是否为OOB内联。默认为false。 | 2582| TCPNoDelay | boolean | 否 | TCPSocket连接是否无时延。默认为false。 | 2583| socketLinger | Object | 是 | socket是否继续逗留。<br />- on：是否逗留（true：逗留；false：不逗留）。<br />- linger：逗留时长，单位毫秒（ms），取值范围为0~65535。<br />当入参on设置为true时，才需要设置。 | 2584| receiveBufferSize | number | 否 | 接收缓冲区大小（单位：Byte），默认为0。 | 2585| sendBufferSize | number | 否 | 发送缓冲区大小（单位：Byte），默认为0。 | 2586| reuseAddress | boolean | 否 | 是否重用地址。默认为false。 | 2587| socketTimeout | number | 否 | 套接字超时时间，单位毫秒（ms），默认为0。 | 2588 2589## socket.constructTCPSocketServerInstance<sup>10+</sup> 2590 2591constructTCPSocketServerInstance(): TCPSocketServer 2592 2593创建一个TCPSocketServer对象。 2594 2595**系统能力**：SystemCapability.Communication.NetStack 2596 2597**返回值：** 2598 2599| 类型 | 说明 | 2600| ---------------------------------- | ---------------------------- | 2601| [TCPSocketServer](#tcpsocketserver10) | 返回一个TCPSocketServer对象。 | 2602 2603**示例：** 2604 2605```ts 2606import socket from "@ohos.net.socket"; 2607let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2608``` 2609 2610## TCPSocketServer<sup>10+</sup> 2611 2612TCPSocketServer连接。在调用TCPSocketServer的方法前，需要先通过[socket.constructTCPSocketServerInstance](#socketconstructtcpsocketserverinstance10)创建TCPSocketServer对象。 2613 2614### listen<sup>10+</sup> 2615 2616listen(address: NetAddress, callback: AsyncCallback\<void\>): void 2617 2618绑定IP地址和端口，端口可以指定或由系统随机分配。监听并接受与此套接字建立的TCPSocket连接。该接口使用多线程并发处理客户端的数据。使用callback方法作为异步方法。 2619 2620> **说明：** 2621> 服务端使用该方法完成bind，listen，accept操作，bind方法失败会由系统随机分配端口号。 2622 2623**需要权限**：ohos.permission.INTERNET 2624 2625**系统能力**：SystemCapability.Communication.NetStack 2626 2627**参数：** 2628 2629| 参数名 | 类型 | 必填 | 说明 | 2630| -------- | ------------------------- | ---- | --------------------------------------------- | 2631| address | [NetAddress](#netaddress) | 是 | 目标地址信息。 | 2632| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 2633 2634**错误码：** 2635 2636| 错误码ID | 错误信息 | 2637| -------- | ------------------------------------------- | 2638| 401 | Parameter error. | 2639| 201 | Permission denied. | 2640| 2300002 | System internal error. | 2641| 2303109 | Bad file number. | 2642| 2303111 | Resource temporarily unavailable try again. | 2643| 2303198 | Address already in use. | 2644| 2303199 | Cannot assign requested address. | 2645 2646**示例：** 2647 2648```ts 2649import socket from "@ohos.net.socket"; 2650import { BusinessError } from '@ohos.base'; 2651let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2652let listenAddr: socket.NetAddress = { 2653 address: '192.168.xx.xxx', 2654 port: 8080, 2655 family: 1 2656} 2657tcpServer.listen(listenAddr, (err: BusinessError) => { 2658 if (err) { 2659 console.log("listen fail"); 2660 return; 2661 } 2662 console.log("listen success"); 2663}) 2664``` 2665 2666### listen<sup>10+</sup> 2667 2668listen(address: NetAddress): Promise\<void\> 2669 2670绑定IP地址和端口，端口可以指定或由系统随机分配。监听并接受与此套接字建立的TCPSocket连接。该接口使用多线程并发处理客户端的数据。使用Promise方法作为异步方法。 2671 2672> **说明：** 2673> 服务端使用该方法完成bind，listen，accept操作，bind方法失败会由系统随机分配端口号。 2674 2675**需要权限**：ohos.permission.INTERNET 2676 2677**系统能力**：SystemCapability.Communication.NetStack 2678 2679**参数：** 2680 2681| 参数名 | 类型 | 必填 | 说明 | 2682| ------- | ------------------------- | ---- | --------------------------------------------- | 2683| address | [NetAddress](#netaddress) | 是 | 目标地址信息。 | 2684 2685**返回值：** 2686 2687| 类型 | 说明 | 2688| -------------- | ----------------------------------------------------------- | 2689| Promise\<void\> | 以Promise形式返回, 成功返回空，失败返回错误码错误信息。| 2690 2691**错误码：** 2692 2693| 错误码ID | 错误信息 | 2694| -------- | ------------------------------------------- | 2695| 401 | Parameter error. | 2696| 201 | Permission denied. | 2697| 2300002 | System internal error. | 2698| 2303109 | Bad file number. | 2699| 2303111 | Resource temporarily unavailable try again. | 2700| 2303198 | Address already in use. | 2701| 2303199 | Cannot assign requested address. | 2702 2703**示例：** 2704 2705```ts 2706import socket from "@ohos.net.socket"; 2707import { BusinessError } from '@ohos.base'; 2708let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2709let listenAddr: socket.NetAddress = { 2710 address: '192.168.xx.xxx', 2711 port: 8080, 2712 family: 1 2713} 2714tcpServer.listen(listenAddr).then(() => { 2715 console.log('listen success'); 2716}).catch((err: BusinessError) => { 2717 console.log('listen fail'); 2718}); 2719``` 2720 2721### getState<sup>10+</sup> 2722 2723getState(callback: AsyncCallback\<SocketStateBase\>): void 2724 2725获取TCPSocketServer状态。使用callback方式作为异步方法。 2726 2727> **说明：** 2728> listen方法调用成功后，才可调用此方法。 2729 2730**需要权限**：ohos.permission.INTERNET 2731 2732**系统能力**：SystemCapability.Communication.NetStack 2733 2734**参数：** 2735 2736| 参数名 | 类型 | 必填 | 说明 | 2737| -------- | -------------------------------------------------- | ---- | ---------- | 2738| callback | AsyncCallback<[SocketStateBase](#socketstatebase)> | 是 | 回调函数。 | 2739 2740**错误码：** 2741 2742| 错误码ID | 错误信息 | 2743| -------- | ------------------------------- | 2744| 401 | Parameter error. | 2745| 201 | Permission denied. | 2746| 2300002 | System internal error. | 2747| 2303188 | Socket operation on non-socket. | 2748 2749**示例：** 2750 2751```ts 2752import socket from "@ohos.net.socket"; 2753import { BusinessError } from '@ohos.base'; 2754let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2755let listenAddr: socket.NetAddress = { 2756 address: '192.168.xx.xxx', 2757 port: 8080, 2758 family: 1 2759} 2760tcpServer.listen(listenAddr, (err: BusinessError) => { 2761 if (err) { 2762 console.log("listen fail"); 2763 return; 2764 } 2765 console.log("listen success"); 2766}) 2767tcpServer.getState((err: BusinessError, data: socket.SocketStateBase) => { 2768 if (err) { 2769 console.log('getState fail'); 2770 return; 2771 } 2772 console.log('getState success:' + JSON.stringify(data)); 2773}) 2774``` 2775 2776### getState<sup>10+</sup> 2777 2778getState(): Promise\<SocketStateBase\> 2779 2780获取TCPSocketServer状态。使用Promise方式作为异步方法。 2781 2782> **说明：** 2783> listen方法调用成功后，才可调用此方法。 2784 2785**需要权限**：ohos.permission.INTERNET 2786 2787**系统能力**：SystemCapability.Communication.NetStack 2788 2789**返回值：** 2790 2791| 类型 | 说明 | 2792| ------------------------------------------- | ----------------------------------------- | 2793| Promise<[SocketStateBase](#socketstatebase)> | 以Promise形式返回获取TCPSocket状态的结果。 | 2794 2795**错误码：** 2796 2797| 错误码ID | 错误信息 | 2798| -------- | ------------------------------- | 2799| 201 | Permission denied. | 2800| 2300002 | System internal error. | 2801| 2303188 | Socket operation on non-socket. | 2802 2803**示例：** 2804 2805```ts 2806import socket from "@ohos.net.socket"; 2807import { BusinessError } from '@ohos.base'; 2808let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2809let listenAddr: socket.NetAddress = { 2810 address: '192.168.xx.xxx', 2811 port: 8080, 2812 family: 1 2813} 2814tcpServer.listen(listenAddr, (err: BusinessError) => { 2815 if (err) { 2816 console.log("listen fail"); 2817 return; 2818 } 2819 console.log("listen success"); 2820}) 2821tcpServer.getState().then((data: socket.SocketStateBase) => { 2822 console.log('getState success' + JSON.stringify(data)); 2823}).catch((err: BusinessError) => { 2824 console.log('getState fail'); 2825}); 2826``` 2827 2828### setExtraOptions<sup>10+</sup> 2829 2830setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void 2831 2832设置TCPSocketServer连接的其他属性。使用callback方式作为异步方法。 2833 2834> **说明：** 2835> listen方法调用成功后，才可调用此方法。 2836 2837**需要权限**：ohos.permission.INTERNET 2838 2839**系统能力**：SystemCapability.Communication.NetStack 2840 2841**参数：** 2842 2843| 参数名 | 类型 | 必填 | 说明 | 2844| -------- | ----------------------------------- | ---- | ------------------------------------------------------------ | 2845| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocketServer连接的其他属性。 | 2846| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 2847 2848**错误码：** 2849 2850| 错误码ID | 错误信息 | 2851| -------- | ------------------------------- | 2852| 401 | Parameter error. | 2853| 201 | Permission denied. | 2854| 2300002 | System internal error. | 2855| 2303188 | Socket operation on non-socket. | 2856 2857**示例：** 2858 2859```ts 2860import socket from "@ohos.net.socket"; 2861import { BusinessError } from '@ohos.base'; 2862let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2863let listenAddr: socket.NetAddress = { 2864 address: '192.168.xx.xxx', 2865 port: 8080, 2866 family: 1 2867} 2868tcpServer.listen(listenAddr, (err: BusinessError) => { 2869 if (err) { 2870 console.log("listen fail"); 2871 return; 2872 } 2873 console.log("listen success"); 2874}) 2875 2876let tcpExtraOptions: socket.TCPExtraOptions = { 2877 keepAlive: true, 2878 OOBInline: true, 2879 TCPNoDelay: true, 2880 socketLinger: { on: true, linger: 10 }, 2881 receiveBufferSize: 1000, 2882 sendBufferSize: 1000, 2883 reuseAddress: true, 2884 socketTimeout: 3000 2885} 2886tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => { 2887 if (err) { 2888 console.log('setExtraOptions fail'); 2889 return; 2890 } 2891 console.log('setExtraOptions success'); 2892}); 2893``` 2894 2895### setExtraOptions<sup>10+</sup> 2896 2897setExtraOptions(options: TCPExtraOptions): Promise\<void\> 2898 2899设置TCPSocketServer连接的其他属性，使用Promise方式作为异步方法。 2900 2901> **说明：** 2902> listen方法调用成功后，才可调用此方法。 2903 2904**需要权限**：ohos.permission.INTERNET 2905 2906**系统能力**：SystemCapability.Communication.NetStack 2907 2908**参数：** 2909 2910| 参数名 | 类型 | 必填 | 说明 | 2911| ------- | ----------------------------------- | ---- | ------------------------------------------------------------ | 2912| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocketServer连接的其他属性。 | 2913 2914**返回值：** 2915 2916| 类型 | 说明 | 2917| -------------- | --------------------------------------------------------- | 2918| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 2919 2920**错误码：** 2921 2922| 错误码ID | 错误信息 | 2923| -------- | ------------------------------- | 2924| 401 | Parameter error. | 2925| 201 | Permission denied. | 2926| 2300002 | System internal error. | 2927| 2303188 | Socket operation on non-socket. | 2928 2929**示例：** 2930 2931```ts 2932import socket from "@ohos.net.socket"; 2933import { BusinessError } from '@ohos.base'; 2934let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2935let listenAddr: socket.NetAddress = { 2936 address: '192.168.xx.xxx', 2937 port: 8080, 2938 family: 1 2939} 2940tcpServer.listen(listenAddr, (err: BusinessError) => { 2941 if (err) { 2942 console.log("listen fail"); 2943 return; 2944 } 2945 console.log("listen success"); 2946}) 2947 2948let tcpExtraOptions: socket.TCPExtraOptions = { 2949 keepAlive: true, 2950 OOBInline: true, 2951 TCPNoDelay: true, 2952 socketLinger: { on: true, linger: 10 }, 2953 receiveBufferSize: 1000, 2954 sendBufferSize: 1000, 2955 reuseAddress: true, 2956 socketTimeout: 3000 2957} 2958tcpServer.setExtraOptions(tcpExtraOptions).then(() => { 2959 console.log('setExtraOptions success'); 2960}).catch((err: BusinessError) => { 2961 console.log('setExtraOptions fail'); 2962}); 2963``` 2964 2965### on('connect')<sup>10+</sup> 2966 2967on(type: 'connect', callback: Callback\<TCPSocketConnection\>): void 2968 2969订阅TCPSocketServer的连接事件。使用callback方式作为异步方法。 2970 2971> **说明：** 2972> listen方法调用成功后，才可调用此方法。 2973 2974**系统能力**：SystemCapability.Communication.NetStack 2975 2976**参数：** 2977 2978| 参数名 | 类型 | 必填 | 说明 | 2979| -------- | ------------------------------- | ---- | ------------------------------------- | 2980| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 2981| callback | Callback<[TCPSocketConnection](#tcpsocketconnection10)> | 是 | 回调函数。 | 2982 2983**错误码：** 2984 2985| 错误码ID | 错误信息 | 2986| -------- | ---------------- | 2987| 401 | Parameter error. | 2988 2989**示例：** 2990 2991```ts 2992import socket from "@ohos.net.socket"; 2993let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2994tcpServer.on('connect', (data: socket.TCPSocketConnection) => { 2995 console.log(JSON.stringify(data)) 2996}); 2997``` 2998 2999### off('connect')<sup>10+</sup> 3000 3001off(type: 'connect', callback?: Callback\<TCPSocketConnection\>): void 3002 3003取消订阅TCPSocketServer的连接事件。使用callback方式作为异步方法。 3004 3005> **说明：** 3006> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3007 3008**系统能力**：SystemCapability.Communication.NetStack 3009 3010**参数：** 3011 3012| 参数名 | 类型 | 必填 | 说明 | 3013| -------- | ------------------------------- | ---- | ------------------------------------- | 3014| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 3015| callback | Callback<[TCPSocketConnection](#tcpsocketconnection10)> | 否 | 回调函数。 | 3016 3017**错误码：** 3018 3019| 错误码ID | 错误信息 | 3020| -------- | ---------------- | 3021| 401 | Parameter error. | 3022 3023**示例：** 3024 3025```ts 3026import socket from "@ohos.net.socket"; 3027let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3028let callback = (data: socket.TCPSocketConnection) => { 3029 console.log('on connect message: ' + JSON.stringify(data)); 3030} 3031tcpServer.on('connect', callback); 3032// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3033tcpServer.off('connect', callback); 3034tcpServer.off('connect'); 3035``` 3036 3037### on('error')<sup>10+</sup> 3038 3039on(type: 'error', callback: ErrorCallback): void 3040 3041订阅TCPSocketServer连接的error事件。使用callback方式作为异步方法。 3042 3043> **说明：** 3044> listen方法调用成功后，才可调用此方法。 3045 3046**系统能力**：SystemCapability.Communication.NetStack 3047 3048**参数：** 3049 3050| 参数名 | 类型 | 必填 | 说明 | 3051| -------- | ------------- | ---- | ------------------------------------ | 3052| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 3053| callback | ErrorCallback | 是 | 回调函数。 | 3054 3055**错误码：** 3056 3057| 错误码ID | 错误信息 | 3058| -------- | ---------------- | 3059| 401 | Parameter error. | 3060 3061**示例：** 3062 3063```ts 3064import socket from "@ohos.net.socket"; 3065import { BusinessError } from '@ohos.base'; 3066let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3067tcpServer.on('error', (err: BusinessError) => { 3068 console.log("on error, err:" + JSON.stringify(err)) 3069}); 3070``` 3071 3072### off('error')<sup>10+</sup> 3073 3074off(type: 'error', callback?: ErrorCallback): void 3075 3076取消订阅TCPSocketServer连接的error事件。使用callback方式作为异步方法。 3077 3078> **说明：** 3079> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3080 3081**系统能力**：SystemCapability.Communication.NetStack 3082 3083**参数：** 3084 3085| 参数名 | 类型 | 必填 | 说明 | 3086| -------- | ------------- | ---- | ------------------------------------ | 3087| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 3088| callback | ErrorCallback | 否 | 回调函数。 | 3089 3090**错误码：** 3091 3092| 错误码ID | 错误信息 | 3093| -------- | ---------------- | 3094| 401 | Parameter error. | 3095 3096**示例：** 3097 3098```ts 3099import socket from "@ohos.net.socket"; 3100import { BusinessError } from '@ohos.base'; 3101let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3102let callback = (err: BusinessError) => { 3103 console.log("on error, err:" + JSON.stringify(err)); 3104} 3105tcpServer.on('error', callback); 3106// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3107tcpServer.off('error', callback); 3108tcpServer.off('error'); 3109``` 3110 3111## TCPSocketConnection<sup>10+</sup> 3112 3113TCPSocketConnection连接，即TCPSocket客户端与服务端的连接。在调用TCPSocketConnection的方法前，需要先获取TCPSocketConnection对象。 3114 3115> **说明：** 3116> 客户端与服务端成功建立连接后，才能通过返回的TCPSocketConnection对象调用相应的接口。 3117 3118**系统能力**：SystemCapability.Communication.NetStack 3119 3120### 属性 3121 3122| 名称 | 类型 | 必填 | 说明 | 3123| -------- | ------ | ---- | ----------------------------------------- | 3124| clientId | number | 是 | 客户端与TCPSocketServer建立连接的id。 | 3125 3126### send<sup>10+</sup> 3127 3128send(options: TCPSendOptions, callback: AsyncCallback\<void\>): void 3129 3130通过TCPSocketConnection连接发送数据。使用callback方式作为异步方法。 3131 3132> **说明：** 3133> 与客户端建立连接后，才可调用此方法。 3134 3135**需要权限**：ohos.permission.INTERNET 3136 3137**系统能力**：SystemCapability.Communication.NetStack 3138 3139**参数：** 3140 3141| 参数名 | 类型 | 必填 | 说明 | 3142| -------- | --------------------------------- | ---- | ------------------------------------------------------------ | 3143| options | [TCPSendOptions](#tcpsendoptions) | 是 | TCPSocketConnection发送请求的参数。 | 3144| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 3145 3146**错误码：** 3147 3148| 错误码ID | 错误信息 | 3149| -------- | ---------------------- | 3150| 401 | Parameter error. | 3151| 201 | Permission denied. | 3152| 2300002 | System internal error. | 3153 3154**示例：** 3155 3156```ts 3157import socket from "@ohos.net.socket"; 3158let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3159 3160tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3161 let tcpSendOption: socket.TCPSendOptions = { 3162 data: 'Hello, client!' 3163 } 3164 client.send(tcpSendOption, () => { 3165 console.log('send success'); 3166 }); 3167}); 3168``` 3169 3170### send<sup>10+</sup> 3171 3172send(options: TCPSendOptions): Promise\<void\> 3173 3174通过TCPSocketConnection连接发送数据。使用Promise方式作为异步方法。 3175 3176> **说明：** 3177> 与客户端建立连接后，才可调用此方法。 3178 3179**需要权限**：ohos.permission.INTERNET 3180 3181**系统能力**：SystemCapability.Communication.NetStack 3182 3183**参数：** 3184 3185| 参数名 | 类型 | 必填 | 说明 | 3186| ------- | --------------------------------- | ---- | ------------------------------------------------------------ | 3187| options | [TCPSendOptions](#tcpsendoptions) | 是 | TCPSocketConnection发送请求的参数。 | 3188 3189**返回值：** 3190 3191| 类型 | 说明 | 3192| -------------- | ----------------------------------------------------------- | 3193| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 3194 3195**错误码：** 3196 3197| 错误码ID | 错误信息 | 3198| -------- | ---------------------- | 3199| 401 | Parameter error. | 3200| 201 | Permission denied. | 3201| 2300002 | System internal error. | 3202 3203**示例：** 3204 3205```ts 3206import socket from "@ohos.net.socket"; 3207import { BusinessError } from '@ohos.base'; 3208let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3209 3210tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3211 let tcpSendOption: socket.TCPSendOptions = { 3212 data: 'Hello, client!' 3213 } 3214 client.send(tcpSendOption).then(() => { 3215 console.log('send success'); 3216 }).catch((err: BusinessError) => { 3217 console.log('send fail'); 3218 }); 3219}); 3220``` 3221 3222### close<sup>10+</sup> 3223 3224close(callback: AsyncCallback\<void\>): void 3225 3226关闭一个与TCPSocket建立的连接。使用callback方式作为异步方法。 3227 3228**需要权限**：ohos.permission.INTERNET 3229 3230**系统能力**：SystemCapability.Communication.NetStack 3231 3232**参数：** 3233 3234| 参数名 | 类型 | 必填 | 说明 | 3235| -------- | --------------------- | ---- | ---------- | 3236| callback | AsyncCallback\<void\> | 是 | 回调函数。 | 3237 3238**错误码：** 3239 3240| 错误码ID | 错误信息 | 3241| -------- | ---------------------- | 3242| 401 | Parameter error. | 3243| 201 | Permission denied. | 3244| 2300002 | System internal error. | 3245 3246**示例：** 3247 3248```ts 3249import socket from "@ohos.net.socket"; 3250import { BusinessError } from '@ohos.base'; 3251let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3252 3253tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3254 client.close((err: BusinessError) => { 3255 if (err) { 3256 console.log('close fail'); 3257 return; 3258 } 3259 console.log('close success'); 3260 }); 3261}); 3262``` 3263 3264### close<sup>10+</sup> 3265 3266close(): Promise\<void\> 3267 3268关闭一个与TCPSocket建立的连接。使用Promise方式作为异步方法。 3269 3270**需要权限**：ohos.permission.INTERNET 3271 3272**系统能力**：SystemCapability.Communication.NetStack 3273 3274**返回值：** 3275 3276| 类型 | 说明 | 3277| -------------- | ------------------------------------------- | 3278| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 3279 3280**错误码：** 3281 3282| 错误码ID | 错误信息 | 3283| -------- | ---------------------- | 3284| 201 | Permission denied. | 3285| 2300002 | System internal error. | 3286 3287**示例：** 3288 3289```ts 3290import socket from "@ohos.net.socket"; 3291let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3292tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3293 client.close().then(() => { 3294 console.log('close success'); 3295 }).catch((err: BusinessError) => { 3296 console.log('close fail'); 3297 }); 3298}); 3299``` 3300 3301### getRemoteAddress<sup>10+</sup> 3302 3303getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void 3304 3305获取对端Socket地址。使用callback方式作为异步方法。 3306 3307> **说明：** 3308> 与客户端建立连接后，才可调用此方法。 3309 3310**需要权限**：ohos.permission.INTERNET 3311 3312**系统能力**：SystemCapability.Communication.NetStack 3313 3314**参数：** 3315 3316| 参数名 | 类型 | 必填 | 说明 | 3317| -------- | ---------------------------------------- | ---- | ---------- | 3318| callback | AsyncCallback<[NetAddress](#netaddress)> | 是 | 回调函数。 | 3319 3320**错误码：** 3321 3322| 错误码ID | 错误信息 | 3323| -------- | ------------------------------- | 3324| 401 | Parameter error. | 3325| 201 | Permission denied. | 3326| 2300002 | System internal error. | 3327| 2303188 | Socket operation on non-socket. | 3328 3329**示例：** 3330 3331```ts 3332import socket from "@ohos.net.socket"; 3333import { BusinessError } from '@ohos.base'; 3334let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3335tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3336 client.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => { 3337 if (err) { 3338 console.log('getRemoteAddress fail'); 3339 return; 3340 } 3341 console.log('getRemoteAddress success:' + JSON.stringify(data)); 3342 }); 3343}); 3344``` 3345 3346### getRemoteAddress<sup>10+</sup> 3347 3348getRemoteAddress(): Promise\<NetAddress\> 3349 3350获取对端Socket地址。使用Promise方式作为异步方法。 3351 3352> **说明：** 3353> 与客户端建立连接后，才可调用此方法。 3354 3355**需要权限**：ohos.permission.INTERNET 3356 3357**系统能力**：SystemCapability.Communication.NetStack 3358 3359**返回值：** 3360 3361| 类型 | 说明 | 3362| --------------------------------- | ------------------------------------------ | 3363| Promise<[NetAddress](#netaddress)> | 以Promise形式返回获取对端socket地址的结果。 | 3364 3365**错误码：** 3366 3367| 错误码ID | 错误信息 | 3368| -------- | ------------------------------- | 3369| 201 | Permission denied. | 3370| 2300002 | System internal error. | 3371| 2303188 | Socket operation on non-socket. | 3372 3373**示例：** 3374 3375```ts 3376import socket from "@ohos.net.socket"; 3377import { BusinessError } from '@ohos.base'; 3378let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3379tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3380 client.getRemoteAddress().then(() => { 3381 console.log('getRemoteAddress success'); 3382 }).catch((err: BusinessError) => { 3383 console.log('getRemoteAddress fail'); 3384 }); 3385}); 3386``` 3387 3388### on('message')<sup>10+</sup> 3389 3390on(type: 'message', callback: Callback<SocketMessageInfo\>): void 3391 3392订阅TCPSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 3393 3394**系统能力**：SystemCapability.Communication.NetStack 3395 3396**参数：** 3397 3398| 参数名 | 类型 | 必填 | 说明 | 3399| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 3400| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 3401| callback | Callback<[SocketMessageInfo](#socketmessageinfo11)> | 是 | 回调函数。 | 3402 3403**错误码：** 3404 3405| 错误码ID | 错误信息 | 3406| -------- | ---------------- | 3407| 401 | Parameter error. | 3408 3409**示例：** 3410 3411```ts 3412import socket from "@ohos.net.socket"; 3413import { BusinessError } from '@ohos.base'; 3414let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3415 3416tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3417 client.on('message', (value: socket.SocketMessageInfo) => { 3418 let messageView = ''; 3419 for (let i: number = 0; i < value.message.byteLength; i++) { 3420 let uint8Array = new Uint8Array(value.message) 3421 let messages = uint8Array[i] 3422 let message = String.fromCharCode(messages); 3423 messageView += message; 3424 } 3425 console.log('on message message: ' + JSON.stringify(messageView)); 3426 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 3427 }); 3428}); 3429``` 3430 3431### off('message')<sup>10+</sup> 3432 3433off(type: 'message', callback?: Callback<SocketMessageInfo\>): void 3434 3435取消订阅TCPSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 3436 3437> **说明：** 3438> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3439 3440**系统能力**：SystemCapability.Communication.NetStack 3441 3442**参数：** 3443 3444| 参数名 | 类型 | 必填 | 说明 | 3445| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 3446| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 3447| callback | Callback<[SocketMessageInfo](#socketmessageinfo11)> | 否 | 回调函数。 | 3448 3449**错误码：** 3450 3451| 错误码ID | 错误信息 | 3452| -------- | ---------------- | 3453| 401 | Parameter error. | 3454 3455**示例：** 3456 3457```ts 3458import socket from "@ohos.net.socket"; 3459import { BusinessError } from '@ohos.base'; 3460let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3461let callback = (value: socket.SocketMessageInfo) => { 3462 let messageView = ''; 3463 for (let i: number = 0; i < value.message.byteLength; i++) { 3464 let uint8Array = new Uint8Array(value.message) 3465 let messages = uint8Array[i]] 3466 let message = String.fromCharCode(messages); 3467 messageView += message; 3468 } 3469 console.log('on message message: ' + JSON.stringify(messageView)); 3470 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 3471} 3472tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3473 client.on('message', callback); 3474 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3475 client.off('message', callback); 3476 client.off('message'); 3477}); 3478``` 3479 3480### on('close')<sup>10+</sup> 3481 3482on(type: 'close', callback: Callback\<void\>): void 3483 3484订阅TCPSocketConnection的关闭事件。使用callback方式作为异步方法。 3485 3486**系统能力**：SystemCapability.Communication.NetStack 3487 3488**参数：** 3489 3490| 参数名 | 类型 | 必填 | 说明 | 3491| -------- | ---------------- | ---- | ----------------------------------- | 3492| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 3493| callback | Callback\<void\> | 是 | 回调函数。 | 3494 3495**错误码：** 3496 3497| 错误码ID | 错误信息 | 3498| -------- | ---------------- | 3499| 401 | Parameter error. | 3500 3501**示例：** 3502 3503```ts 3504import socket from "@ohos.net.socket"; 3505import { BusinessError } from '@ohos.base'; 3506let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3507tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3508 client.on('close', () => { 3509 console.log("on close success") 3510 }); 3511}); 3512``` 3513 3514### off('close')<sup>10+</sup> 3515 3516off(type: 'close', callback?: Callback\<void\>): void 3517 3518取消订阅TCPSocketConnection的关闭事件。使用callback方式作为异步方法。 3519 3520> **说明：** 3521> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3522 3523**系统能力**：SystemCapability.Communication.NetStack 3524 3525**参数：** 3526 3527| 参数名 | 类型 | 必填 | 说明 | 3528| -------- | ---------------- | ---- | ----------------------------------- | 3529| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 3530| callback | Callback\<void\> | 否 | 回调函数。 | 3531 3532**错误码：** 3533 3534| 错误码ID | 错误信息 | 3535| -------- | ---------------- | 3536| 401 | Parameter error. | 3537 3538**示例：** 3539 3540```ts 3541import socket from "@ohos.net.socket"; 3542let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3543let callback = () => { 3544 console.log("on close success"); 3545} 3546tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3547 client.on('close', callback); 3548 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3549 client.off('close', callback); 3550 client.off('close'); 3551}); 3552``` 3553 3554### on('error')<sup>10+</sup> 3555 3556on(type: 'error', callback: ErrorCallback): void 3557 3558订阅TCPSocketConnection连接的error事件。使用callback方式作为异步方法。 3559 3560**系统能力**：SystemCapability.Communication.NetStack 3561 3562**参数：** 3563 3564| 参数名 | 类型 | 必填 | 说明 | 3565| -------- | ------------- | ---- | ------------------------------------ | 3566| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 3567| callback | ErrorCallback | 是 | 回调函数。 | 3568 3569**错误码：** 3570 3571| 错误码ID | 错误信息 | 3572| -------- | ---------------- | 3573| 401 | Parameter error. | 3574 3575**示例：** 3576 3577```ts 3578import socket from "@ohos.net.socket"; 3579import { BusinessError } from '@ohos.base'; 3580let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3581tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3582 client.on('error', (err: BusinessError) => { 3583 console.log("on error, err:" + JSON.stringify(err)) 3584 }); 3585}); 3586``` 3587 3588### off('error')<sup>10+</sup> 3589 3590off(type: 'error', callback?: ErrorCallback): void 3591 3592取消订阅TCPSocketConnection连接的error事件。使用callback方式作为异步方法。 3593 3594> **说明：** 3595> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3596 3597**系统能力**：SystemCapability.Communication.NetStack 3598 3599**参数：** 3600 3601| 参数名 | 类型 | 必填 | 说明 | 3602| -------- | ------------- | ---- | ------------------------------------ | 3603| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 3604| callback | ErrorCallback | 否 | 回调函数。 | 3605 3606**错误码：** 3607 3608| 错误码ID | 错误信息 | 3609| -------- | ---------------- | 3610| 401 | Parameter error. | 3611 3612**示例：** 3613 3614```ts 3615import socket from "@ohos.net.socket"; 3616import { BusinessError } from '@ohos.base'; 3617let callback = (err: BusinessError) => { 3618 console.log("on error, err:" + JSON.stringify(err)); 3619} 3620let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3621tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3622 client.on('error', callback); 3623 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3624 client.off('error', callback); 3625 client.off('error'); 3626}); 3627``` 3628 3629## TCP 错误码说明 3630 3631TCP 其余错误码映射形式为：2301000 + Linux内核错误码。 3632 3633错误码的详细介绍参见[Socket错误码](errorcode-net-socket.md) 3634 3635## socket.constructLocalSocketInstance<sup>11+</sup> 3636 3637constructLocalSocketInstance(): LocalSocket 3638 3639创建一个LocalSocket对象。 3640 3641**系统能力**：SystemCapability.Communication.NetStack 3642 3643**返回值：** 3644 3645| 类型 | 说明 | 3646 | :--------------------------------- | :---------------------- | 3647| [LocalSocket](#localsocket11) | 返回一个LocalSocket对象。 | 3648 3649**示例：** 3650 3651```ts 3652import socket from "@ohos.net.socket"; 3653let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 3654``` 3655 3656## LocalSocket<sup>11+</sup> 3657 3658LocalSocket连接。在调用LocalSocket的方法前，需要先通过[socket.constructLocalSocketInstance](#socketconstructlocalsocketinstance11)创建LocalSocket对象。 3659 3660### bind<sup>11+</sup> 3661 3662bind(address: LocalAddress): Promise\<void\>; 3663 3664绑定本地套接字文件的路径。使用promise方法作为异步方法。 3665 3666> **说明：** 3667> bind方法可以使客户端确保有个明确的本地套接字路径，显式的绑定一个本地套接字文件。 3668> bind方法在本地套接字通信中非必须。 3669 3670**系统能力**：SystemCapability.Communication.NetStack 3671 3672**参数：** 3673 3674| 参数名 | 类型 | 必填 | 说明 | 3675| -------- | ---------------------------------- | ---- | ------------------------------------------------------ | 3676| address | [LocalAddress](#localaddress11) | 是 | 目标地址信息，参考[LocalAddress](#localaddress11)。 | 3677 3678**错误码：** 3679 3680| 错误码ID | 错误信息 | 3681| ------- | -------------------------- | 3682| 401 | Parameter error. | 3683| 2301013 | Insufficient permissions. | 3684| 2301022 | Invalid argument. | 3685| 2301098 | Address already in use. | 3686 3687**示例：** 3688 3689```ts 3690import socket from "@ohos.net.socket"; 3691 3692let client = socket.constructLocalSocketInstance() 3693let sandboxPath: string = getContext().filesDir + '/testSocket' 3694let address : socket.LocalAddress = { 3695 address: sandboxPath 3696} 3697client.bind(address).then(() => { 3698 console.log('bind success') 3699}).catch((err: Object) => { 3700 console.error('failed to bind: ' + JSON.stringify(err)) 3701}) 3702``` 3703 3704### connect<sup>11+</sup> 3705 3706connect(options: LocalConnectOptions): Promise\<void\> 3707 3708连接到指定的套接字文件。使用promise方法作为异步方法。 3709 3710> **说明：** 3711> 在没有执行localsocket.bind的情况下，也可以直接调用该接口完成与LocalSocket服务端的连接。 3712 3713**系统能力**：SystemCapability.Communication.NetStack 3714 3715**参数：** 3716 3717| 参数名 | 类型 | 必填 | 说明 | 3718| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 3719| options | [LocalConnectOptions](#localconnectoptions11) | 是 | LocalSocket连接的参数，参考[LocalConnectOptions](#localconnectoptions11)。 | 3720 3721**返回值：** 3722 3723| 类型 | 说明 | 3724| :-------------- | :---------------------------------------- | 3725| Promise\<void\> | 以Promise形式返回LocalSocket连接服务端的结果。 | 3726 3727**错误码：** 3728 3729| 错误码ID | 错误信息 | 3730| ------- | ----------------------- | 3731| 401 | Parameter error. | 3732| 2301013 | Insufficient permissions. | 3733| 2301022 | Invalid argument. | 3734| 2301111 | Connection refused. | 3735| 2301099 | Cannot assign requested address. | 3736 3737**示例：** 3738 3739```ts 3740import socket from "@ohos.net.socket"; 3741 3742let client = socket.constructLocalSocketInstance(); 3743let sandboxPath: string = getContext().filesDir + '/testSocket' 3744let connectOpt: socket.LocalConnectOptions = { 3745 address: { 3746 address: sandboxPath 3747 }, 3748 timeout: 6000 3749} 3750client.connect(connectOpt).then(() => { 3751 console.log('connect success') 3752}).catch((err: Object) => { 3753 console.error('connect fail: ' + JSON.stringify(err)); 3754}); 3755``` 3756 3757### send<sup>11+</sup> 3758 3759send(options: LocalSendOptions): Promise\<void\> 3760 3761通过LocalSocket连接发送数据。使用Promise方式作为异步方法。 3762 3763> **说明：** 3764> connect方法调用成功后，才可调用此方法。 3765 3766**系统能力**：SystemCapability.Communication.NetStack 3767 3768**参数：** 3769 3770| 参数名 | 类型 | 必填 | 说明 | 3771| ------- | --------------------------------------- | ---- | ------------------------------------------------------------ | 3772| options | [LocalSendOptions](#localsendoptions11) | 是 | LocalSocket发送请求的参数，参考[LocalSendOptions](#localsendoptions11)。 | 3773 3774**返回值：** 3775 3776| 类型 | 说明 | 3777| :-------------- | :------------------------------------------ | 3778| Promise\<void\> | 以Promise形式返回通过LocalSocket发送数据的结果。 | 3779 3780**错误码：** 3781 3782| 错误码ID | 错误信息 | 3783| ------- | ----------------------- | 3784| 401 | Parameter error. | 3785| 2301011 | Operation would block. | 3786 3787**示例：** 3788 3789```ts 3790import socket from "@ohos.net.socket" 3791 3792let client: socket.LocalSocket = socket.constructLocalSocketInstance() 3793let sandboxPath: string = getContext().filesDir + '/testSocket' 3794let connectOpt: socket.LocalConnectOptions = { 3795 address: { 3796 address: sandboxPath 3797 }, 3798 timeout: 6000 3799} 3800client.connect(connectOpt).then(() => { 3801 console.log('connect success') 3802}).catch((err: Object) => { 3803 console.error('connect failed: ' + JSON.stringify(err)) 3804}) 3805let sendOpt: socket.LocalSendOptions = { 3806 data: 'Hello world!' 3807} 3808client.send(sendOpt).then(() => { 3809 console.log('send success') 3810}).catch((err: Object) => { 3811 console.error('send fail: ' + JSON.stringify(err)) 3812}) 3813``` 3814 3815### close<sup>11+</sup> 3816 3817close(): Promise\<void\> 3818 3819关闭LocalSocket连接。使用Promise方式作为异步方法。 3820 3821**系统能力**：SystemCapability.Communication.NetStack 3822 3823**返回值：** 3824 3825| 类型 | 说明 | 3826| :-------------- | :----------------------------------------- | 3827| Promise\<void\> | 以Promise形式返回关闭LocalSocket连接的结果。 | 3828 3829**错误码：** 3830 3831| 错误码ID | 错误信息 | 3832| ------- | ----------------------- | 3833| 2301009 | Bad file descriptor. | 3834 3835**示例：** 3836 3837```ts 3838import socket from "@ohos.net.socket"; 3839let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 3840 3841client.close().then(() => { 3842 console.log('close success'); 3843}).catch((err: Object) => { 3844 console.error('close fail: ' + JSON.stringify(err)); 3845}); 3846``` 3847 3848### getState<sup>11+</sup> 3849 3850getState(): Promise\<SocketStateBase\> 3851 3852获取LocalSocket状态。使用Promise方式作为异步方法。 3853 3854> **说明：** 3855> bind或connect方法调用成功后，才可调用此方法。 3856 3857**系统能力**：SystemCapability.Communication.NetStack 3858 3859**返回值：** 3860 3861| 类型 | 说明 | 3862| :------------------------------------------- | :--------------------------------------- | 3863| Promise<[SocketStateBase](#socketstatebase)> | 以Promise形式返回获取LocalSocket状态的结果。 | 3864 3865**示例：** 3866 3867```ts 3868import socket from "@ohos.net.socket"; 3869let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 3870let sandboxPath: string = getContext().filesDir + '/testSocket' 3871let connectOpt: socket.LocalConnectOptions = { 3872 address: { 3873 address: sandboxPath 3874 }, 3875 timeout: 6000 3876} 3877client.connect(connectOpt).then(() => { 3878 console.log('connect success'); 3879 client.getState().then(() => { 3880 console.log('getState success'); 3881 }).catch((err: Object) => { 3882 console.error('getState fail: ' + JSON.stringify(err)) 3883 }); 3884}).catch((err: Object) => { 3885 console.error('connect fail: ' + JSON.stringify(err)); 3886}); 3887``` 3888 3889### getSocketFd<sup>11+</sup> 3890 3891getSocketFd(): Promise\<number\> 3892 3893获取LocalSocket的文件描述符。使用Promise方式作为异步方法。 3894 3895> **说明：** 3896> bind或connect方法调用成功后，才可调用此方法。 3897> 获取由系统内核分配的唯一文件描述符，用于标识当前使用的套接字。 3898 3899**系统能力**：SystemCapability.Communication.NetStack 3900 3901**返回值：** 3902 3903| 类型 | 说明 | 3904| :---------------- | :-------------------------------- | 3905| Promise\<number\> | 以Promise形式返回socket的文件描述符。 | 3906 3907**示例：** 3908 3909```ts 3910import socket from "@ohos.net.socket"; 3911let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 3912let sandboxPath: string = getContext().filesDir + '/testSocket' 3913let connectOpt: socket.LocalConnectOptions = { 3914 address: { 3915 address: sandboxPath 3916 }, 3917 timeout: 6000 3918} 3919client.connect(connectOpt).then(() => { 3920 console.log('connect ok') 3921}).catch((err: Object) => { 3922 console.error('connect fail: ' + JSON.stringify(err)) 3923}) 3924client.getSocketFd().then((data: number) => { 3925 console.info("fd: " + data); 3926}).catch((err: Object) => { 3927 console.error("getSocketFd faile: " + JSON.stringify(err)); 3928}) 3929``` 3930 3931### setExtraOptions<sup>11+</sup> 3932 3933setExtraOptions(options: ExtraOptionsBase): Promise\<void\> 3934 3935设置LocalSocket的套接字属性，使用Promise方式作为异步方法。 3936 3937> **说明：** 3938> bind或connect方法调用成功后，才可调用此方法。 3939 3940**系统能力**：SystemCapability.Communication.NetStack 3941 3942**参数：** 3943 3944| 参数名 | 类型 | 必填 | 说明 | 3945| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 3946| options | [ExtraOptionsBase](#extraoptionsbase7) | 是 | LocalSocket连接的其他属性，参考[ExtraOptionsBase](#extraoptionsbase7)。 | 3947 3948**返回值：** 3949 3950| 类型 | 说明 | 3951| :-------------- | :-------------------------------------------- | 3952| Promise\<void\> | 以Promise形式返回设置LocalSocket套接字属性的结果。 | 3953 3954**错误码：** 3955 3956| 错误码ID | 错误信息 | 3957| ------- | ----------------------- | 3958| 401 | Parameter error. | 3959| 2301009 | Bad file descriptor. | 3960 3961**示例：** 3962 3963```ts 3964import socket from "@ohos.net.socket"; 3965let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 3966let sandboxPath: string = getContext().filesDir + '/testSocket' 3967let connectOpt: socket.LocalConnectOptions = { 3968 address: { 3969 address: sandboxPath 3970 }, 3971 timeout: 6000 3972} 3973client.connect(connectOpt).then(() => { 3974 console.log('connect success'); 3975 let options: socket.ExtraOptionsBase = { 3976 receiveBufferSize: 8000, 3977 sendBufferSize: 8000, 3978 socketTimeout: 3000 3979 } 3980 client.setExtraOptions(options).then(() => { 3981 console.log('setExtraOptions success'); 3982 }).catch((err: Object) => { 3983 console.error('setExtraOptions fail: ' + JSON.stringify(err)); 3984 }); 3985}).catch((err: Object) => { 3986 console.error('connect fail: ' + JSON.stringify(err)); 3987}); 3988``` 3989 3990### getExtraOptions<sup>11+</sup> 3991 3992getExtraOptions(): Promise\<ExtraOptionsBase\>; 3993 3994获取LocalSocket的套接字属性，使用Promise方式作为异步方法。 3995 3996> **说明：** 3997> bind或connect方法调用成功后，才可调用此方法。 3998 3999**系统能力**：SystemCapability.Communication.NetStack 4000 4001**返回值：** 4002 4003| 类型 | 说明 | 4004| :-------------------------- | :---------------------------------------- | 4005| Promise\<[ExtraOptionsBase](#extraoptionsbase7)\> | 以Promise形式返回设置LocalSocket套接字的属性。 | 4006 4007**错误码：** 4008 4009| 错误码ID | 错误信息 | 4010| ------- | ----------------------- | 4011| 2301009 | Bad file descriptor. | 4012 4013**示例：** 4014 4015```ts 4016import socket from "@ohos.net.socket"; 4017let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4018let sandboxPath: string = getContext().filesDir + '/testSocket' 4019let connectOpt: socket.LocalConnectOptions = { 4020 address: { 4021 address: sandboxPath 4022 }, 4023 timeout: 6000 4024} 4025client.connect(connectOpt).then(() => { 4026 console.log('connect success'); 4027 client.getExtraOptions().then((options : socket.ExtraOptionsBase) => { 4028 console.log('options: ' + JSON.stringify(options)); 4029 }).catch((err: Object) => { 4030 console.error('setExtraOptions fail: ' + JSON.stringify(err)); 4031 }); 4032}).catch((err: Object) => { 4033 console.error('connect fail: ' + JSON.stringify(err)); 4034}); 4035``` 4036 4037### on('message')<sup>11+</sup> 4038 4039on(type: 'message', callback: Callback\<LocalSocketMessageInfo\>): void 4040 4041订阅LocalSocket连接的接收消息事件。使用callback方式作为异步方法。 4042 4043**系统能力**：SystemCapability.Communication.NetStack 4044 4045**参数：** 4046 4047| 参数名 | 类型 | 必填 | 说明 | 4048| -------- | ----------------------------------------------- | ---- | ----------------------------------- | 4049| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 4050| callback | Callback\<[LocalSocketMessageInfo](#localsocketmessageinfo11)\> | 是 | 以callback的形式异步返回接收的消息。| 4051 4052**示例：** 4053 4054```ts 4055import socket from "@ohos.net.socket"; 4056let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4057client.on('message', (value: socket.LocalSocketMessageInfo) => { 4058 const uintArray = new Uint8Array(value.message) 4059 let messageView = ''; 4060 for (let i = 0; i < uintArray.length; i++) { 4061 messageView += String.fromCharCode(uintArray[i]); 4062 } 4063 console.log('total: ' + JSON.stringify(value)); 4064 console.log('message infomation: ' + messageView); 4065}); 4066``` 4067 4068### off('message')<sup>11+</sup> 4069 4070off(type: 'message', callback?: Callback\<LocalSocketMessageInfo\>): void 4071 4072取消订阅LocalSocket连接的接收消息事件。使用callback方式作为异步方法。 4073 4074> **说明：** 4075> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4076 4077**系统能力**：SystemCapability.Communication.NetStack 4078 4079**参数：** 4080 4081| 参数名 | 类型 | 必填 | 说明 | 4082| -------- | ------------------------------------------------ | ---- | ----------------------------------- | 4083| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 4084| callback | Callback\<[LocalSocketMessageInfo](#localsocketmessageinfo11)\> | 否 | 指定传入on中的callback取消一个订阅。| 4085 4086**示例：** 4087 4088```ts 4089import socket from "@ohos.net.socket"; 4090let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4091let messageView = ''; 4092let callback = (value: socket.LocalSocketMessageInfo) => { 4093 const uintArray = new Uint8Array(value.message) 4094 let messageView = ''; 4095 for (let i = 0; i < uintArray.length; i++) { 4096 messageView += String.fromCharCode(uintArray[i]); 4097 } 4098 console.log('total: ' + JSON.stringify(value)); 4099 console.log('message infomation: ' + messageView); 4100} 4101client.on('message', callback); 4102client.off('message'); 4103``` 4104 4105### on('connect')<sup>11+</sup> 4106 4107on(type: 'connect', callback: Callback\<void\>): void; 4108 4109订阅LocalSocket的连接事件。使用callback方式作为异步方法。 4110 4111**系统能力**：SystemCapability.Communication.NetStack 4112 4113**参数：** 4114 4115| 参数名 | 类型 | 必填 | 说明 | 4116| -------- | ---------------- | ---- | --------------------------------------------------------- | 4117| type | string | 是 | 订阅的事件类型。 | 4118| callback | Callback\<void\> | 是 | 以callback的形式异步返回与服务端连接的结果。 | 4119 4120**示例：** 4121 4122```ts 4123import socket from "@ohos.net.socket"; 4124let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4125client.on('connect', () => { 4126 console.log("on connect success") 4127}); 4128``` 4129 4130### off('connect')<sup>11+</sup> 4131 4132off(type: 'connect', callback?: Callback\<void\>): void; 4133 4134取消订阅LocalSocket的连接事件。使用callback方式作为异步方法。 4135 4136**系统能力**：SystemCapability.Communication.NetStack 4137 4138**参数：** 4139 4140| 参数名 | 类型 | 必填 | 说明 | 4141| -------- | ---------------- | ---- | --------------------------------------------------------- | 4142| type | string | 是 | 订阅的事件类型。 | 4143| callback | Callback\<void\> | 否 | 指定传入on中的callback取消一个订阅。 | 4144 4145**示例：** 4146 4147```ts 4148import socket from "@ohos.net.socket"; 4149let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4150let callback = () => { 4151 console.log("on connect success"); 4152} 4153client.on('connect', callback); 4154// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4155client.off('connect', callback); 4156client.off('connect'); 4157``` 4158 4159### on('close')<sup>11+</sup> 4160 4161on(type: 'close', callback: Callback\<void\>): void; 4162 4163订阅LocalSocket的关闭事件。使用callback方式作为异步方法。 4164 4165> **说明：** 4166> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4167 4168**系统能力**：SystemCapability.Communication.NetStack 4169 4170**参数：** 4171 4172| 参数名 | 类型 | 必填 | 说明 | 4173| -------- | ---------------- | ---- | ------------------------ | 4174| type | string | 是 | 订阅LocalSocket的关闭事件。 | 4175| callback | Callback\<void\> | 是 | 以callback的形式异步返回关闭localsocket的结果。| 4176 4177**示例：** 4178 4179```ts 4180import socket from "@ohos.net.socket"; 4181let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4182let callback = () => { 4183 console.log("on close success"); 4184} 4185client.on('close', callback); 4186``` 4187 4188### off('close')<sup>11+</sup> 4189 4190off(type: 'close', callback?: Callback\<void\>): void; 4191 4192订阅LocalSocket的关闭事件。使用callback方式作为异步方法。 4193 4194> **说明：** 4195> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4196 4197**系统能力**：SystemCapability.Communication.NetStack 4198 4199**参数：** 4200 4201| 参数名 | 类型 | 必填 | 说明 | 4202| -------- | ---------------- | ---- | ------------------------ | 4203| type | string | 是 | 订阅LocalSocket的关闭事件。 | 4204| callback | Callback\<void\> | 否 | 取消指定传入on中的callback取消一个订阅。| 4205 4206**示例：** 4207 4208```ts 4209import socket from "@ohos.net.socket"; 4210let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4211let callback = () => { 4212 console.log("on close success"); 4213} 4214client.on('close', callback); 4215// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4216client.off('close', callback); 4217client.off('close'); 4218``` 4219 4220### on('error')<sup>11+</sup> 4221 4222on(type: 'error', callback: ErrorCallback): void 4223 4224订阅LocalSocket连接的error事件。使用callback方式作为异步方法。 4225 4226**系统能力**：SystemCapability.Communication.NetStack 4227 4228**参数：** 4229 4230| 参数名 | 类型 | 必填 | 说明 | 4231| -------- | ------------- | ---- | ---------------------------- | 4232| type | string | 是 | 订阅LocalSocket的error事件。 | 4233| callback | ErrorCallback | 是 | 以callback的形式异步返回出现错误的结果。| 4234 4235**示例：** 4236 4237```ts 4238import socket from "@ohos.net.socket"; 4239let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4240client.on('error', (err: Object) => { 4241 console.log("on error, err:" + JSON.stringify(err)) 4242}); 4243``` 4244 4245### off('error')<sup>11+</sup> 4246 4247off(type: 'error', callback?: ErrorCallback): void; 4248 4249取消订阅LocalSocket连接的error事件。使用callback方式作为异步方法。 4250 4251> **说明：** 4252> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4253 4254**系统能力**：SystemCapability.Communication.NetStack 4255 4256**参数：** 4257 4258| 参数名 | 类型 | 必填 | 说明 | 4259| -------- | ------------- | ---- | ----------------------------- | 4260| type | string | 是 | 取消订阅LocalSocket的error事件。 | 4261| callback | ErrorCallback | 否 | 指定传入on中的callback取消一个订阅。| 4262 4263**示例：** 4264 4265```ts 4266import socket from "@ohos.net.socket"; 4267let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4268let callback = (err: Object) => { 4269 console.log("on error, err:" + JSON.stringify(err)); 4270} 4271client.on('error', callback); 4272// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4273client.off('error', callback); 4274client.off('error'); 4275``` 4276 4277## LocalSocketMessageInfo<sup>11+</sup> 4278 4279LocalSocket客户端与服务端通信时接收的数据。 4280 4281**系统能力**：SystemCapability.Communication.NetStack 4282 4283| 名称 | 类型 | 必填 | 说明 | 4284| ------- | --------------- | --- | ------------------ | 4285| message | ArrayBuffer | 是 | 收到的消息数据。 | 4286| address | string | 是 | 使用的本地套接字路径。| 4287| size | number | 是 | 数据长度。 | 4288 4289## LocalAddress<sup>11+</sup> 4290 4291LocalSocket本地套接字文件路径信息，在传入套接字路径进行绑定时，会在此路径下创建套接字文件。 4292 4293**系统能力**：SystemCapability.Communication.NetStack 4294 4295| 名称 | 类型 | 必填 | 说明 | 4296| ------- | ---------- | --- | ------------------ | 4297| address | string | 是 | 本地套接字路径。 | 4298 4299## LocalConnectOptions<sup>11+</sup> 4300 4301LocalSocket客户端在连接服务端时传入的参数信息。 4302 4303**系统能力**：SystemCapability.Communication.NetStack 4304 4305| 名称 | 类型 | 必填 | 说明 | 4306| ------- | ---------- | --- | ------------------------------ | 4307| address | string | 是 | 指定的本地套接字路径。 | 4308| timeout | number | 否 | 连接服务端的超时时间，单位为毫秒。 | 4309 4310## LocalSendOptions<sup>11+</sup> 4311 4312LocalSocket发送请求的参数。 4313 4314**系统能力**：SystemCapability.Communication.NetStack 4315 4316| 名称 | 类型 | 必填 | 说明 | 4317| ------- | ---------- | --- | ------------------- | 4318| data | string \| ArrayBuffer | 是 | 需要发送的数据。 | 4319| encoding | string | 否 | 字符编码。 | 4320 4321## ExtraOptionsBase<sup>7+</sup> 4322 4323Socket套接字的基础属性。 4324 4325**系统能力**：SystemCapability.Communication.NetStack 4326 4327| 名称 | 类型 | 必填 | 说明 | 4328| ----------------- | ------- | ---- | ----------------------------- | 4329| receiveBufferSize | number | 否 | 接收缓冲区大小（单位：Byte）。 | 4330| sendBufferSize | number | 否 | 发送缓冲区大小（单位：Byte）。 | 4331| reuseAddress | boolean | 否 | 是否重用地址。 | 4332| socketTimeout | number | 否 | 套接字超时时间，单位毫秒（ms）。 | 4333 4334## socket.constructLocalSocketServerInstance<sup>11+</sup> 4335 4336constructLocalSocketServerInstance(): LocalSocketServer 4337 4338创建一个LocalSocketServer对象。 4339 4340**系统能力**：SystemCapability.Communication.NetStack 4341 4342**返回值：** 4343 4344| 类型 | 说明 | 4345| :---------------------------------- | :---------------------------- | 4346| [LocalSocketServer](#localsocketserver11) | 返回一个LocalSocketServer对象。 | 4347 4348**示例：** 4349 4350```ts 4351import socket from "@ohos.net.socket"; 4352let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4353``` 4354 4355## LocalSocketServer<sup>11+</sup> 4356 4357LocalSocketServer类。在调用LocalSocketServer的方法前，需要先通过[socket.constructLocalSocketServerInstance](#socketconstructlocalsocketserverinstance11)创建LocalSocketServer对象。 4358 4359### listen<sup>11+</sup> 4360 4361listen(address: LocalAddress): Promise\<void\> 4362 4363绑定本地套接字文件，监听并接受与此套接字建立的LocalSocket连接。该接口使用多线程并发处理客户端的数据。使用Promise方法作为异步方法。 4364 4365> **说明：** 4366> 服务端使用该方法完成bind，listen，accept操作，传入套接字文件路径，调用此接口后会自动生成本地套接字文件。 4367 4368**系统能力**：SystemCapability.Communication.NetStack 4369 4370**参数：** 4371 4372| 参数名 | 类型 | 必填 | 说明 | 4373| ------- | ------------------------- | ---- | --------------------------------------------- | 4374| address | [LocalAddress](#localaddress11) | 是 | 目标地址信息。 | 4375 4376**返回值：** 4377 4378| 类型 | 说明 | 4379| :-------------- | :---------------------------------------------------- | 4380| Promise\<void\> | 以Promise形式返回执行结果, 成功返回空，失败返回错误码错误信息。| 4381 4382**错误码：** 4383 4384| 错误码ID | 错误信息 | 4385| -------- | --------------------------- | 4386| 401 | Parameter error. | 4387| 2303109 | Bad file number. | 4388| 2301013 | Insufficient permissions. | 4389| 2301022 | Invalid argument. | 4390| 2301098 | Address already in use. | 4391 4392**示例：** 4393 4394```ts 4395import socket from "@ohos.net.socket"; 4396let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4397let sandboxPath: string = getContext().filesDir + '/testSocket' 4398let addr: socket.LocalAddress = { 4399 address: sandboxPath 4400} 4401server.listen(addr).then(() => { 4402 console.log('listen success'); 4403}).catch((err: Object) => { 4404 console.error('listen fail: ' + JSON.stringify(err)); 4405}); 4406``` 4407 4408### getState<sup>11+</sup> 4409 4410getState(): Promise\<SocketStateBase\> 4411 4412获取LocalSocketServer状态。使用Promise方式作为异步方法。 4413 4414> **说明：** 4415> listen方法调用成功后，才可调用此方法。 4416 4417**系统能力**：SystemCapability.Communication.NetStack 4418 4419**返回值：** 4420 4421| 类型 | 说明 | 4422| :------------------------------------------- | :--------------------------------------------- | 4423| Promise\<[SocketStateBase](#socketstatebase)\> | 以Promise形式返回获取LocalSocketServer状态的结果。 | 4424 4425**示例：** 4426 4427```ts 4428import socket from "@ohos.net.socket"; 4429let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4430let sandboxPath: string = getContext().filesDir + '/testSocket' 4431let listenAddr: socket.LocalAddress = { 4432 address: sandboxPath 4433} 4434server.listen(listenAddr).then(() => { 4435 console.log("listen success"); 4436}).catch((err: Object) => { 4437 console.error("listen fail: " + JSON.stringify(err)); 4438}) 4439server.getState().then((data: socket.SocketStateBase) => { 4440 console.log('getState success: ' + JSON.stringify(data)); 4441}).catch((err: Object) => { 4442 console.error('getState fail: ' + JSON.stringify(err)); 4443}); 4444``` 4445 4446### setExtraOptions<sup>11+</sup> 4447 4448setExtraOptions(options: ExtraOptionsBase): Promise\<void\> 4449 4450设置LocalSocketServer连接的套接字属性，使用Promise方式作为异步方法。 4451 4452> **说明：** 4453> listen方法调用成功后，才可调用此方法。 4454 4455**系统能力**：SystemCapability.Communication.NetStack 4456 4457**参数：** 4458 4459| 参数名 | 类型 | 必填 | 说明 | 4460| ------- | --------------------------------------- | ---- | ------------------------------ | 4461| options | [ExtraOptionsBase](#extraoptionsbase7) | 是 | LocalSocketServer连接的其他属性。 | 4462 4463**返回值：** 4464 4465| 类型 | 说明 | 4466| :-------------- | :---------------------------------------------- | 4467| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 4468 4469**错误码：** 4470 4471| 错误码ID | 错误信息 | 4472| -------- | ------------------------------- | 4473| 401 | Parameter error. | 4474| 2301009 | Bad file descriptor. | 4475 4476**示例：** 4477 4478```ts 4479import socket from "@ohos.net.socket"; 4480let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4481let sandboxPath: string = getContext().filesDir + '/testSocket' 4482let listenAddr: socket.NetAddress = { 4483 address: sandboxPath 4484} 4485server.listen(listenAddr).then(() => { 4486 console.log("listen success"); 4487}).catch((err: Object) => { 4488 console.error("listen fail: " + JSON.stringify(err)); 4489}) 4490 4491let options: socket.ExtraOptionsBase = { 4492 receiveBufferSize: 6000, 4493 sendBufferSize: 6000, 4494 socketTimeout: 3000 4495} 4496server.setExtraOptions(options).then(() => { 4497 console.log('setExtraOptions success'); 4498}).catch((err: Object) => { 4499 console.error('setExtraOptions fail: ' + JSON.stringify(err)); 4500}); 4501``` 4502 4503### getExtraOptions<sup>11+</sup> 4504 4505getExtraOptions(): Promise\<ExtraOptionsBase\>; 4506 4507获取LocalSocketServer中连接的套接字的属性，使用Promise方式作为异步方法。 4508 4509> **说明：** 4510> listen方法调用成功后，才可调用此方法。 4511 4512**系统能力**：SystemCapability.Communication.NetStack 4513 4514**返回值：** 4515 4516| 类型 | 说明 | 4517| :-------------------------- | :-------------------------- | 4518| Promise\<[ExtraOptionsBase](#extraoptionsbase7)\> | 以Promise形式返回套接字的属性。 | 4519 4520**错误码：** 4521 4522| 错误码ID | 错误信息 | 4523| -------- | -------------------- | 4524| 401 | Parameter error. | 4525 4526**示例：** 4527 4528```ts 4529import socket from "@ohos.net.socket"; 4530let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4531let sandboxPath: string = getContext(this).filesDir + '/testSocket' 4532let listenAddr: socket.LocalAddress = { 4533 address: sandboxPath 4534} 4535server.listen(listenAddr).then(() => { 4536 console.log("listen success"); 4537}).catch((err: Object) => { 4538 console.error("listen fail: " + JSON.stringify(err)); 4539}) 4540server.getExtraOptions().then((options) => { 4541 console.log('options: ' + JSON.stringify(options)); 4542}).catch((err: Object) => { 4543 console.error('getExtraOptions fail: ' + JSON.stringify(err)); 4544}); 4545``` 4546 4547### on('connect')<sup>11+</sup> 4548 4549on(type: 'connect', callback: Callback\<LocalSocketConnection\>): void 4550 4551订阅LocalSocketServer的连接事件。使用callback方式作为异步方法。 4552 4553> **说明：** 4554> listen方法调用成功后，才可调用此方法。 4555 4556**系统能力**：SystemCapability.Communication.NetStack 4557 4558**参数：** 4559 4560| 参数名 | 类型 | 必填 | 说明 | 4561| -------- | ------------------------------- | ---- | ------------------------------------- | 4562| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 4563| callback | Callback\<[LocalSocketConnection](#localsocketconnection11)\> | 是 | 以callback的形式异步返回接收到客户端连接的结果。| 4564 4565**错误码：** 4566 4567| 错误码ID | 错误信息 | 4568| -------- | ---------------- | 4569| 401 | Parameter error. | 4570 4571**示例：** 4572 4573```ts 4574import socket from "@ohos.net.socket"; 4575let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4576server.on('connect', (connection: socket.LocalSocketConnection) => { 4577 if (connection) { 4578 console.log('accept a client') 4579 } 4580}); 4581``` 4582 4583### off('connect')<sup>11+</sup> 4584 4585off(type: 'connect', callback?: Callback\<LocalSocketConnection\>): void 4586 4587取消订阅LocalSocketServer的连接事件。使用callback方式作为异步方法。 4588 4589> **说明：** 4590> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4591 4592**系统能力**：SystemCapability.Communication.NetStack 4593 4594**参数：** 4595 4596| 参数名 | 类型 | 必填 | 说明 | 4597| -------- | ------------------------------- | ---- | ------------------------------------- | 4598| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 4599| callback | Callback\<[LocalSocketConnection](#localsocketconnection11)\> | 否 | 指定传入on的一个callback取消注册。| 4600 4601**错误码：** 4602 4603| 错误码ID | 错误信息 | 4604| -------- | ---------------- | 4605| 401 | Parameter error. | 4606 4607**示例：** 4608 4609```ts 4610import socket from "@ohos.net.socket"; 4611let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4612let callback = (connection: socket.LocalSocketConnection) => { 4613 if (connection) { 4614 console.log('accept a client') 4615 } 4616} 4617server.on('connect', callback); 4618// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4619server.off('connect', callback); 4620server.off('connect'); 4621``` 4622 4623### on('error')<sup>11+</sup> 4624 4625on(type: 'error', callback: ErrorCallback): void 4626 4627订阅LocalSocketServer连接的error事件。使用callback方式作为异步方法。 4628 4629> **说明：** 4630> listen方法调用成功后，才可调用此方法。 4631 4632**系统能力**：SystemCapability.Communication.NetStack 4633 4634**参数：** 4635 4636| 参数名 | 类型 | 必填 | 说明 | 4637| -------- | ------------- | ---- | ------------------------------------ | 4638| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 4639| callback | ErrorCallback | 是 | 以callback的形式异步返回出现错误的结果。| 4640 4641**错误码：** 4642 4643| 错误码ID | 错误信息 | 4644| -------- | ---------------- | 4645| 401 | Parameter error. | 4646 4647**示例：** 4648 4649```ts 4650import socket from "@ohos.net.socket"; 4651let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4652server.on('error', (err: Object) => { 4653 console.error("on error, err:" + JSON.stringify(err)) 4654}); 4655``` 4656 4657### off('error')<sup>11+</sup> 4658 4659off(type: 'error', callback?: ErrorCallback): void 4660 4661取消订阅LocalSocketServer连接的error事件。使用callback方式作为异步方法。 4662 4663> **说明：** 4664> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4665 4666**系统能力**：SystemCapability.Communication.NetStack 4667 4668**参数：** 4669 4670| 参数名 | 类型 | 必填 | 说明 | 4671| -------- | ------------- | ---- | ------------------------------------ | 4672| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 4673| callback | ErrorCallback | 否 | 指定传入on的一个callback取消订阅。 | 4674 4675**错误码：** 4676 4677| 错误码ID | 错误信息 | 4678| -------- | ---------------- | 4679| 401 | Parameter error. | 4680 4681**示例：** 4682 4683```ts 4684import socket from "@ohos.net.socket"; 4685let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4686let callback = (err: Object) => { 4687 console.error("on error, err:" + JSON.stringify(err)); 4688} 4689server.on('error', callback); 4690// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4691server.off('error', callback); 4692server.off('error'); 4693``` 4694 4695 4696## LocalSocketConnection<sup>11+</sup> 4697 4698LocalSocketConnection连接，即LocalSocket客户端与服务端的会话连接。在调用LocalSocketConnection的方法前，需要先获取LocalSocketConnection对象。 4699 4700> **说明：** 4701> 客户端与服务端成功建立连接后，才能通过返回的LocalSocketConnection对象调用相应的接口。 4702 4703**系统能力**：SystemCapability.Communication.NetStack 4704 4705### 属性 4706 4707| 名称 | 类型 | 必填 | 说明 | 4708| -------- | ------ | ---- | ---------------------------- | 4709| clientId | number | 是 | 客户端与服务端建立的会话连接的id。 | 4710 4711### send<sup>11+</sup> 4712 4713send(options: LocalSendOptions): Promise\<void\> 4714 4715通过LocalSocketConnection连接对象发送数据。使用Promise方式作为异步方法。 4716 4717> **说明：** 4718> 服务端与客户端建立连接后，服务端通过connect事件回调得到LocalSocketConnection连接对象后，才可使用连接对象调用此方法。 4719 4720**系统能力**：SystemCapability.Communication.NetStack 4721 4722**参数：** 4723 4724| 参数名 | 类型 | 必填 | 说明 | 4725| ------- | --------------------------------- | ---- | -------------------------------------- | 4726| options | [LocalSendOptions](#localsendoptions11) | 是 | LocalSocketConnection发送请求的参数。 | 4727 4728**返回值：** 4729 4730| 类型 | 说明 | 4731| :-------------- | :---------------------------------------------- | 4732| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 4733 4734**错误码：** 4735 4736| 错误码ID | 错误信息 | 4737| -------- | ---------------------- | 4738| 401 | Parameter error. | 4739| 2301011 | Operation would block. | 4740 4741**示例：** 4742 4743```ts 4744import socket from "@ohos.net.socket"; 4745let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4746 4747server.on('connect', (connection: socket.LocalSocketConnection) => { 4748 let sendOptions: socket.LocalSendOptions = { 4749 data: 'Hello, client!' 4750 } 4751 connection.send(sendOptions).then(() => { 4752 console.log('send success'); 4753 }).catch((err: Object) => { 4754 console.error('send fail: ' + JSON.stringify(err)); 4755 }); 4756}); 4757``` 4758 4759### close<sup>11+</sup> 4760 4761close(): Promise\<void\> 4762 4763关闭一个LocalSocket客户端与服务端建立的连接。使用Promise方式作为异步方法。 4764 4765**系统能力**：SystemCapability.Communication.NetStack 4766 4767**返回值：** 4768 4769| 类型 | 说明 | 4770| :-------------- | :------------------------------------------- | 4771| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 4772 4773**错误码：** 4774 4775| 错误码ID | 错误信息 | 4776| -------- | -------------------- | 4777| 201 | Permission denied. | 4778| 2301009 | Bad file descriptor. | 4779 4780**示例：** 4781 4782```ts 4783import socket from "@ohos.net.socket"; 4784let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4785server.on('connect', (connection: socket.LocalSocketConnection) => { 4786 connection.close().then(() => { 4787 console.log('close success'); 4788 }).catch((err: Object) => { 4789 console.error('close fail: ' + JSON.stringify(err)); 4790 }); 4791}); 4792``` 4793 4794### on('message')<sup>11+</sup> 4795 4796on(type: 'message', callback: Callback\<LocalSocketMessageInfo\>): void; 4797 4798订阅LocalSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 4799 4800**系统能力**：SystemCapability.Communication.NetStack 4801 4802**参数：** 4803 4804| 参数名 | 类型 | 必填 | 说明 | 4805| -------- | ----------------------------------------------- | ---- | --------------------------------------- | 4806| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 4807| callback | Callback\<[LocalSocketMessageInfo](#localsocketmessageinfo11)\> | 是 | 以callback的形式异步返回接收到的来自客户端的消息。 | 4808 4809**错误码：** 4810 4811| 错误码ID | 错误信息 | 4812| -------- | ---------------- | 4813| 401 | Parameter error. | 4814 4815**示例：** 4816 4817```ts 4818import socket from "@ohos.net.socket"; 4819let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4820let sandboxPath: string = getContext().filesDir + '/testSocket' 4821let listenAddr: socket.LocalAddress = { 4822 address: sandboxPath 4823} 4824server.listen(listenAddr).then(() => { 4825 console.log("listen success"); 4826}).catch((err: Object) => { 4827 console.error("listen fail: " + JSON.stringify(err)); 4828}); 4829server.on('connect', (connection: socket.LocalSocketConnection) => { 4830 connection.on('message', (value: socket.LocalSocketMessageInfo) => { 4831 const uintArray = new Uint8Array(value.message); 4832 let messageView = ''; 4833 for (let i = 0; i < uintArray.length; i++) { 4834 messageView += String.fromCharCode(uintArray[i]); 4835 } 4836 console.log('total: ' + JSON.stringify(value)); 4837 console.log('message infomation: ' + messageView); 4838 }); 4839}); 4840``` 4841 4842### off('message')<sup>11+</sup> 4843 4844off(type: 'message', callback?: Callback\<LocalSocketMessageInfo\>): void 4845 4846取消订阅LocalSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 4847 4848> **说明：** 4849> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4850 4851**系统能力**：SystemCapability.Communication.NetStack 4852 4853**参数：** 4854 4855| 参数名 | 类型 | 必填 | 说明 | 4856| -------- | ----------------------------------------------- | ---- | ----------------------------------- | 4857| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 4858| callback | Callback\<[LocalSocketMessageInfo](#localsocketmessageinfo11)\> | 否 | 指定传入on的一个callback取消注册。 | 4859 4860**错误码：** 4861 4862| 错误码ID | 错误信息 | 4863| -------- | ---------------- | 4864| 401 | Parameter error. | 4865 4866**示例：** 4867 4868```ts 4869import socket from "@ohos.net.socket"; 4870let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4871let callback = (value: socket.LocalSocketMessageInfo) => { 4872 const uintArray = new Uint8Array(value.message) 4873 let messageView = ''; 4874 for (let i = 0; i < uintArray.length; i++) { 4875 messageView += String.fromCharCode(uintArray[i]); 4876 } 4877 console.log('total: ' + JSON.stringify(value)); 4878 console.log('message infomation: ' + messageView); 4879} 4880server.on('connect', (connection: socket.LocalSocketConnection) => { 4881 connection.on('message', callback); 4882 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4883 connection.off('message', callback); 4884 connection.off('message'); 4885}); 4886``` 4887 4888### on('close')<sup>11+</sup> 4889 4890on(type: 'close', callback: Callback\<void\>): void 4891 4892订阅LocalSocketConnection的关闭事件。使用callback方式作为异步方法。 4893 4894**系统能力**：SystemCapability.Communication.NetStack 4895 4896**参数：** 4897 4898| 参数名 | 类型 | 必填 | 说明 | 4899| -------- | ---------------- | ---- | ----------------------------------- | 4900| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 4901| callback | Callback\<void\> | 是 | 以callback的形式异步返回会话关闭的结果。 | 4902 4903**错误码：** 4904 4905| 错误码ID | 错误信息 | 4906| -------- | ---------------- | 4907| 401 | Parameter error. | 4908 4909**示例：** 4910 4911```ts 4912import socket from "@ohos.net.socket"; 4913let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4914server.on('connect', (connection: socket.LocalSocketConnection) => { 4915 connection.on('close', () => { 4916 console.log("on close success") 4917 }); 4918}); 4919``` 4920 4921### off('close')<sup>11+</sup> 4922 4923off(type: 'close', callback?: Callback\<void\>): void 4924 4925取消订阅LocalSocketConnection的关闭事件。使用callback方式作为异步方法。 4926 4927> **说明：** 4928> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4929 4930**系统能力**：SystemCapability.Communication.NetStack 4931 4932**参数：** 4933 4934| 参数名 | 类型 | 必填 | 说明 | 4935| -------- | ---------------- | ---- | ----------------------------------- | 4936| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 4937| callback | Callback\<void\> | 否 | 指定传入on的一个callback取消订阅。 | 4938 4939**错误码：** 4940 4941| 错误码ID | 错误信息 | 4942| -------- | ---------------- | 4943| 401 | Parameter error. | 4944 4945**示例：** 4946 4947```ts 4948import socket from "@ohos.net.socket"; 4949let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4950let callback = () => { 4951 console.log("on close success"); 4952} 4953server.on('connect', (connection: socket.LocalSocketConnection) => { 4954 connection.on('close', callback); 4955 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4956 connection.off('close', callback); 4957 connection.off('close'); 4958}); 4959``` 4960 4961### on('error')<sup>11+</sup> 4962 4963on(type: 'error', callback: ErrorCallback): void 4964 4965订阅LocalSocketConnection连接的error事件。使用callback方式作为异步方法。 4966 4967**系统能力**：SystemCapability.Communication.NetStack 4968 4969**参数：** 4970 4971| 参数名 | 类型 | 必填 | 说明 | 4972| -------- | ------------- | ---- | ------------------------------------ | 4973| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 4974| callback | ErrorCallback | 是 | 以callback的形式异步返回出现错误的结果。| 4975 4976**错误码：** 4977 4978| 错误码ID | 错误信息 | 4979| -------- | ---------------- | 4980| 401 | Parameter error. | 4981 4982**示例：** 4983 4984```ts 4985import socket from "@ohos.net.socket"; 4986let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4987server.on('connect', (connection: socket.LocalSocketConnection) => { 4988 connection.on('error', (err: Object) => { 4989 console.error("on error, err:" + JSON.stringify(err)) 4990 }); 4991}); 4992``` 4993 4994### off('error')<sup>11+</sup> 4995 4996off(type: 'error', callback?: ErrorCallback): void 4997 4998取消订阅LocalSocketConnection连接的error事件。使用callback方式作为异步方法。 4999 5000> **说明：** 5001> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5002 5003**系统能力**：SystemCapability.Communication.NetStack 5004 5005**参数：** 5006 5007| 参数名 | 类型 | 必填 | 说明 | 5008| -------- | ------------- | ---- | ------------------------------------ | 5009| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 5010| callback | ErrorCallback | 否 | 指定传入on的一个callback取消订阅。 | 5011 5012**错误码：** 5013 5014| 错误码ID | 错误信息 | 5015| -------- | ---------------- | 5016| 401 | Parameter error. | 5017 5018**示例：** 5019 5020```ts 5021import socket from "@ohos.net.socket"; 5022let callback = (err: Object) => { 5023 console.error("on error, err: " + JSON.stringify(err)); 5024} 5025let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5026server.on('connect', (connection: socket.LocalSocketConnection) => { 5027 connection.on('error', callback); 5028 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5029 connection.off('error', callback); 5030 connection.off('error'); 5031}); 5032``` 5033 5034## LocalSocket 错误码说明 5035 5036LocalSocket 错误码映射形式为：2301000 + Linux内核错误码。 5037 5038错误码的详细介绍参见[Socket错误码](errorcode-net-socket.md) 5039 5040## socket.constructTLSSocketInstance<sup>9+</sup> 5041 5042constructTLSSocketInstance(): TLSSocket 5043 5044创建并返回一个TLSSocket对象。 5045 5046**系统能力**：SystemCapability.Communication.NetStack 5047 5048**返回值:** 5049 5050| 类型 | 说明 | 5051| --------------------------------- | ---------------------- | 5052| [TLSSocket](#tlssocket9) | 返回一个TLSSocket对象。 | 5053 5054**示例：** 5055 5056```ts 5057import socket from "@ohos.net.socket"; 5058let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5059``` 5060 5061## TLSSocket<sup>9+</sup> 5062 5063TLSSocket连接。在调用TLSSocket的方法前，需要先通过[socket.constructTLSSocketInstance](#socketconstructtlssocketinstance9)创建TLSSocket对象。 5064 5065### bind<sup>9+</sup> 5066 5067bind(address: NetAddress, callback: AsyncCallback\<void\>): void 5068 5069绑定IP地址和端口。使用callback方法作为异步方法。 5070 5071**需要权限**：ohos.permission.INTERNET 5072 5073**系统能力**：SystemCapability.Communication.NetStack 5074 5075**参数：** 5076 5077| 参数名 | 类型 | 必填 | 说明 | 5078| -------- | ---------------------------------- | ---- | ------------------------------------------------------ | 5079| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 5080| callback | AsyncCallback\<void\> | 是 | 回调函数。成功返回TLSSocket绑定本机的IP地址和端口的结果。 失败返回错误码，错误信息。| 5081 5082**错误码：** 5083 5084| 错误码ID | 错误信息 | 5085| ------- | ----------------------- | 5086| 401 | Parameter error. | 5087| 201 | Permission denied. | 5088| 2303198 | Address already in use. | 5089| 2300002 | System internal error. | 5090 5091**示例：** 5092 5093```ts 5094import socket from "@ohos.net.socket"; 5095import { BusinessError } from '@ohos.base'; 5096let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5097let bindAddr: socket.NetAddress = { 5098 address: '192.168.xx.xxx', 5099 port: 8080 5100} 5101tls.bind(bindAddr, (err: BusinessError) => { 5102 if (err) { 5103 console.log('bind fail'); 5104 return; 5105 } 5106 console.log('bind success'); 5107}); 5108``` 5109 5110### bind<sup>9+</sup> 5111 5112bind(address: NetAddress): Promise\<void\> 5113 5114绑定IP地址和端口。使用Promise方法作为异步方法。 5115 5116**需要权限**：ohos.permission.INTERNET 5117 5118**系统能力**：SystemCapability.Communication.NetStack 5119 5120**参数：** 5121 5122| 参数名 | 类型 | 必填 | 说明 | 5123| ------- | ---------------------------------- | ---- | ------------------------------------------------------ | 5124| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 5125 5126**返回值：** 5127 5128| 类型 | 说明 | 5129| -------------- | ------------------------------------------------------- | 5130| Promise\<void\> | 以Promise形式返回TLSSocket绑定本机的IP地址和端口的结果。失败返回错误码，错误信息。 | 5131 5132**错误码：** 5133 5134| 错误码ID | 错误信息 | 5135| ------- | ----------------------- | 5136| 401 | Parameter error. | 5137| 201 | Permission denied. | 5138| 2303198 | Address already in use. | 5139| 2300002 | System internal error. | 5140 5141**示例：** 5142 5143```ts 5144import socket from "@ohos.net.socket"; 5145import { BusinessError } from '@ohos.base'; 5146let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5147let bindAddr: socket.NetAddress = { 5148 address: '192.168.xx.xxx', 5149 port: 8080 5150} 5151tls.bind(bindAddr).then(() => { 5152 console.log('bind success'); 5153}).catch((err: BusinessError) => { 5154 console.log('bind fail'); 5155}); 5156``` 5157 5158### getState<sup>9+</sup> 5159 5160getState(callback: AsyncCallback\<SocketStateBase\>): void 5161 5162在TLSSocket的bind成功之后，获取TLSSocket状态。使用callback方式作为异步方法。 5163 5164**系统能力**：SystemCapability.Communication.NetStack 5165 5166**参数：** 5167 5168| 参数名 | 类型 | 必填 | 说明 | 5169| -------- | ------------------------------------------------------ | ---- | ---------- | 5170| callback | AsyncCallback\<[SocketStateBase](#socketstatebase)> | 是 | 回调函数。成功返回TLSSocket状态，失败返回错误码,错误信息。 | 5171 5172**错误码：** 5173 5174| 错误码ID | 错误信息 | 5175| ------- | ------------------------------ | 5176| 2303188 | Socket operation on non-socket.| 5177| 2300002 | System internal error. | 5178 5179**示例：** 5180 5181```ts 5182import socket from "@ohos.net.socket"; 5183import { BusinessError } from '@ohos.base'; 5184let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5185let bindAddr: socket.NetAddress = { 5186 address: '192.168.xx.xxx', 5187 port: 8080 5188} 5189tls.bind(bindAddr, (err: BusinessError) => { 5190 if (err) { 5191 console.log('bind fail'); 5192 return; 5193 } 5194 console.log('bind success'); 5195}); 5196tls.getState((err: BusinessError, data: socket.SocketStateBase) => { 5197 if (err) { 5198 console.log('getState fail'); 5199 return; 5200 } 5201 console.log('getState success:' + JSON.stringify(data)); 5202}); 5203``` 5204 5205### getState<sup>9+</sup> 5206 5207getState(): Promise\<SocketStateBase\> 5208 5209在TLSSocket的bind成功之后，获取TLSSocket状态。使用Promise方式作为异步方法。 5210 5211**系统能力**：SystemCapability.Communication.NetStack 5212 5213**返回值：** 5214 5215| 类型 | 说明 | 5216| ----------------------------------------------- | ----------------------------------------- | 5217| Promise\<[SocketStateBase](#socketstatebase)> | 以Promise形式返回获取TLSSocket状态的结果。失败返回错误码，错误信息。| 5218 5219**错误码：** 5220 5221| 错误码ID | 错误信息 | 5222| ------- | ------------------------------ | 5223| 2303188 | Socket operation on non-socket.| 5224| 2300002 | System internal error. | 5225 5226**示例：** 5227 5228```ts 5229import socket from "@ohos.net.socket"; 5230import { BusinessError } from '@ohos.base'; 5231let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5232let bindAddr: socket.NetAddress = { 5233 address: '192.168.xx.xxx', 5234 port: 8080 5235} 5236tls.bind(bindAddr, (err: BusinessError) => { 5237 if (err) { 5238 console.log('bind fail'); 5239 return; 5240 } 5241 console.log('bind success'); 5242}); 5243tls.getState().then(() => { 5244 console.log('getState success'); 5245}).catch((err: BusinessError) => { 5246 console.log('getState fail'); 5247}); 5248``` 5249 5250### setExtraOptions<sup>9+</sup> 5251 5252setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void 5253 5254在TLSSocket的bind成功之后，设置TCPSocket连接的其他属性。使用callback方式作为异步方法。 5255 5256**系统能力**：SystemCapability.Communication.NetStack 5257 5258**参数：** 5259 5260| 参数名 | 类型 | 必填 | 说明 | 5261| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 5262| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 | 5263| callback | AsyncCallback\<void\> | 是 | 回调函数。成功返回设置TCPSocket连接的其他属性的结果，失败返回错误码，错误信息。| 5264 5265**错误码：** 5266 5267| 错误码ID | 错误信息 | 5268| ------- | ----------------------------- | 5269| 401 | Parameter error. | 5270| 2303188 | Socket operation on non-socket.| 5271| 2300002 | System internal error. | 5272 5273**示例：** 5274 5275```ts 5276import socket from "@ohos.net.socket"; 5277import { BusinessError } from '@ohos.base'; 5278let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5279let bindAddr: socket.NetAddress = { 5280 address: '192.168.xx.xxx', 5281 port: 8080 5282} 5283tls.bind(bindAddr, (err: BusinessError) => { 5284 if (err) { 5285 console.log('bind fail'); 5286 return; 5287 } 5288 console.log('bind success'); 5289}); 5290 5291let tcpExtraOptions: socket.TCPExtraOptions = { 5292 keepAlive: true, 5293 OOBInline: true, 5294 TCPNoDelay: true, 5295 socketLinger: { on: true, linger: 10 }, 5296 receiveBufferSize: 1000, 5297 sendBufferSize: 1000, 5298 reuseAddress: true, 5299 socketTimeout: 3000 5300} 5301tls.setExtraOptions(tcpExtraOptions, (err: BusinessError) => { 5302 if (err) { 5303 console.log('setExtraOptions fail'); 5304 return; 5305 } 5306 console.log('setExtraOptions success'); 5307}); 5308``` 5309 5310### setExtraOptions<sup>9+</sup> 5311 5312setExtraOptions(options: TCPExtraOptions): Promise\<void\> 5313 5314在TLSSocket的bind成功之后，设置TCPSocket连接的其他属性，使用Promise方式作为异步方法。 5315 5316**系统能力**：SystemCapability.Communication.NetStack 5317 5318**参数：** 5319 5320| 参数名 | 类型 | 必填 | 说明 | 5321| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 5322| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 | 5323 5324**返回值：** 5325 5326| 类型 | 说明 | 5327| -------------- | --------------------------------------------------- | 5328| Promise\<void\> | 以Promise形式返回设置TCPSocket连接的其他属性的结果。失败返回错误码，错误信息。 | 5329 5330**错误码：** 5331 5332| 错误码ID | 错误信息 | 5333| ------- | ------------------------------ | 5334| 401 | Parameter error. | 5335| 2303188 | Socket operation on non-socket.| 5336| 2300002 | System internal error. | 5337 5338**示例：** 5339 5340```ts 5341import socket from "@ohos.net.socket"; 5342import { BusinessError } from '@ohos.base'; 5343let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5344let bindAddr: socket.NetAddress = { 5345 address: '192.168.xx.xxx', 5346 port: 8080 5347} 5348tls.bind(bindAddr, (err: BusinessError) => { 5349 if (err) { 5350 console.log('bind fail'); 5351 return; 5352 } 5353 console.log('bind success'); 5354}); 5355 5356let tcpExtraOptions: socket.TCPExtraOptions = { 5357 keepAlive: true, 5358 OOBInline: true, 5359 TCPNoDelay: true, 5360 socketLinger: { on: true, linger: 10 }, 5361 receiveBufferSize: 1000, 5362 sendBufferSize: 1000, 5363 reuseAddress: true, 5364 socketTimeout: 3000 5365} 5366tls.setExtraOptions(tcpExtraOptions).then(() => { 5367 console.log('setExtraOptions success'); 5368}).catch((err: BusinessError) => { 5369 console.log('setExtraOptions fail'); 5370}); 5371``` 5372 5373### on('message')<sup>9+</sup> 5374 5375on(type: 'message', callback: Callback\<SocketMessageInfo\>): void; 5376 5377订阅TLSSocket连接的接收消息事件。使用callback方式作为异步方法。 5378 5379**系统能力**：SystemCapability.Communication.NetStack 5380 5381**参数：** 5382 5383| 参数名 | 类型 | 必填 | 说明 | 5384| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 5385| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 5386| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 是 | 回调函数。 | 5387 5388**示例：** 5389 5390```ts 5391import socket from "@ohos.net.socket"; 5392import { BusinessError } from '@ohos.base'; 5393let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5394let messageView = ''; 5395tls.on('message', (value: socket.SocketMessageInfo) => { 5396 for (let i: number = 0; i < value.message.byteLength; i++) { 5397 let uint8Array = new Uint8Array(value.message) 5398 let messages = uint8Array[i] 5399 let message = String.fromCharCode(messages); 5400 messageView += message; 5401 } 5402 console.log('on message message: ' + JSON.stringify(messageView)); 5403 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 5404}); 5405``` 5406 5407### off('message')<sup>9+</sup> 5408 5409off(type: 'message', callback?: Callback\<SocketMessageInfo\>): void 5410 5411取消订阅TLSSocket连接的接收消息事件。使用callback方式作为异步方法。 5412 5413> **说明：** 5414> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5415 5416**系统能力**：SystemCapability.Communication.NetStack 5417 5418**参数：** 5419 5420| 参数名 | 类型 | 必填 | 说明 | 5421| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 5422| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 5423| callback | Callback<[SocketMessageInfo](#socketmessageinfo11)> | 否 | 回调函数。 | 5424 5425**示例：** 5426 5427```ts 5428import socket from "@ohos.net.socket"; 5429import { BusinessError } from '@ohos.base'; 5430let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5431let messageView = ''; 5432let callback = (value: socket.SocketMessageInfo) => { 5433 for (let i: number = 0; i < value.message.byteLength; i++) { 5434 let uint8Array = new Uint8Array(value.message) 5435 let messages = uint8Array[i] 5436 let message = String.fromCharCode(messages); 5437 messageView += message; 5438 } 5439 console.log('on message message: ' + JSON.stringify(messageView)); 5440 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 5441} 5442tls.on('message', callback); 5443// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5444tls.off('message', callback); 5445``` 5446### on('connect' | 'close')<sup>9+</sup> 5447 5448on(type: 'connect' | 'close', callback: Callback\<void\>): void 5449 5450订阅TLSSocket的连接事件或关闭事件。使用callback方式作为异步方法。 5451 5452**系统能力**：SystemCapability.Communication.NetStack 5453 5454**参数：** 5455 5456| 参数名 | 类型 | 必填 | 说明 | 5457| -------- | ---------------- | ---- | ------------------------------------------------------------ | 5458| type | string | 是 | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 | 5459| callback | Callback\<void\> | 是 | 回调函数。 | 5460 5461**示例：** 5462 5463```ts 5464import socket from "@ohos.net.socket"; 5465import { BusinessError } from '@ohos.base'; 5466let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5467tls.on('connect', () => { 5468 console.log("on connect success") 5469}); 5470tls.on('close', () => { 5471 console.log("on close success") 5472}); 5473``` 5474 5475### off('connect' | 'close')<sup>9+</sup> 5476 5477off(type: 'connect' | 'close', callback?: Callback\<void\>): void 5478 5479取消订阅TLSSocket的连接事件或关闭事件。使用callback方式作为异步方法。 5480 5481> **说明：** 5482> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5483 5484**系统能力**：SystemCapability.Communication.NetStack 5485 5486**参数：** 5487 5488| 参数名 | 类型 | 必填 | 说明 | 5489| -------- | ---------------- | ---- | ------------------------------------------------------------ | 5490| type | string | 是 | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 | 5491| callback | Callback\<void\> | 否 | 回调函数。 | 5492 5493**示例：** 5494 5495```ts 5496import socket from "@ohos.net.socket"; 5497import { BusinessError } from '@ohos.base'; 5498let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5499let callback1 = () => { 5500 console.log("on connect success"); 5501} 5502tls.on('connect', callback1); 5503// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5504tls.off('connect', callback1); 5505tls.off('connect'); 5506let callback2 = () => { 5507 console.log("on close success"); 5508} 5509tls.on('close', callback2); 5510// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5511tls.off('close', callback2); 5512``` 5513 5514### on('error')<sup>9+</sup> 5515 5516on(type: 'error', callback: ErrorCallback): void 5517 5518订阅TLSSocket连接的error事件。使用callback方式作为异步方法。 5519 5520**系统能力**：SystemCapability.Communication.NetStack 5521 5522**参数：** 5523 5524| 参数名 | 类型 | 必填 | 说明 | 5525| -------- | ------------- | ---- | ------------------------------------ | 5526| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 5527| callback | ErrorCallback | 是 | 回调函数。 | 5528 5529**示例：** 5530 5531```ts 5532import socket from "@ohos.net.socket"; 5533import { BusinessError } from '@ohos.base'; 5534let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5535tls.on('error', (err: BusinessError) => { 5536 console.log("on error, err:" + JSON.stringify(err)) 5537}); 5538``` 5539 5540### off('error')<sup>9+</sup> 5541 5542off(type: 'error', callback?: ErrorCallback): void 5543 5544取消订阅TLSSocket连接的error事件。使用callback方式作为异步方法。 5545 5546> **说明：** 5547> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5548 5549**系统能力**：SystemCapability.Communication.NetStack 5550 5551**参数：** 5552 5553| 参数名 | 类型 | 必填 | 说明 | 5554| -------- | ------------- | ---- | ------------------------------------ | 5555| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 5556| callback | ErrorCallback | 否 | 回调函数。 | 5557 5558**示例：** 5559 5560```ts 5561import socket from "@ohos.net.socket"; 5562import { BusinessError } from '@ohos.base'; 5563let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5564let callback = (err: BusinessError) => { 5565 console.log("on error, err:" + JSON.stringify(err)); 5566} 5567tls.on('error', callback); 5568// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5569tls.off('error', callback); 5570``` 5571 5572### connect<sup>9+</sup> 5573 5574connect(options: TLSConnectOptions, callback: AsyncCallback\<void\>): void 5575 5576在TLSSocket上bind成功之后，进行通信连接，并创建和初始化TLS会话，实现建立连接过程，启动与服务器的TLS/SSL握手，实现数据传输功能，使用callback方式作为异步方法。需要注意options入参下secureOptions内的ca为必填项，需填入服务端的ca证书(用于认证校验服务端的数字证书),证书内容以"-----BEGIN CERTIFICATE-----"开头，以"-----END CERTIFICATE-----"结尾。 5577 5578**系统能力**：SystemCapability.Communication.NetStack 5579 5580**参数：** 5581 5582| 参数名 | 类型 | 必填 | 说明 | 5583| -------- | ---------------------------------------| ----| --------------- | 5584| options | [TLSConnectOptions](#tlsconnectoptions9) | 是 | TLSSocket连接所需要的参数。| 5585| callback | AsyncCallback\<void\> | 是 | 回调函数，成功无返回，失败返回错误码，错误信息。| 5586 5587**错误码：** 5588 5589| 错误码ID | 错误信息 | 5590| ------- | -------------------------------------------- | 5591| 401 | Parameter error. | 5592| 2303104 | Interrupted system call. | 5593| 2303109 | Bad file number. | 5594| 2303111 | Resource temporarily unavailable try again. | 5595| 2303188 | Socket operation on non-socket. | 5596| 2303191 | Protocol wrong type for socket. | 5597| 2303198 | Address already in use. | 5598| 2303199 | Cannot assign requested address. | 5599| 2303210 | Connection timed out. | 5600| 2303501 | SSL is null. | 5601| 2303502 | Error in tls reading. | 5602| 2303503 | Error in tls writing | 5603| 2303505 | Error occurred in the tls system call. | 5604| 2303506 | Error clearing tls connection. | 5605| 2300002 | System internal error. | 5606 5607**示例：** 5608 5609```ts 5610import socket from "@ohos.net.socket"; 5611import { BusinessError } from '@ohos.base'; 5612let tlsTwoWay: socket.TLSSocket = socket.constructTLSSocketInstance(); // Two way authentication 5613let bindAddr: socket.NetAddress = { 5614 address: '0.0.0.0', 5615} 5616tlsTwoWay.bind(bindAddr, (err: BusinessError) => { 5617 if (err) { 5618 console.log('bind fail'); 5619 return; 5620 } 5621 console.log('bind success'); 5622}); 5623 5624let tlsConnectOptions: socket.TLSConnectOptions = { 5625 address: { 5626 address: '192.168.xx.xxx', 5627 port: 8080 5628 }, 5629 secureOptions: { 5630 key: "xxxx", 5631 cert: "xxxx", 5632 ca: ["xxxx"], 5633 password: "xxxx", 5634 protocols: socket.Protocol.TLSv12, 5635 useRemoteCipherPrefer: true, 5636 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 5637 cipherSuite: "AES256-SHA256" 5638 }, 5639 ALPNProtocols: ["spdy/1", "http/1.1"] 5640} 5641 5642tlsTwoWay.connect(tlsConnectOptions, (err: BusinessError) => { 5643 console.error("connect callback error" + err); 5644}); 5645 5646let tlsOneWay: socket.TLSSocket = socket.constructTLSSocketInstance(); // One way authentication 5647tlsOneWay.bind(bindAddr, (err: BusinessError) => { 5648 if (err) { 5649 console.log('bind fail'); 5650 return; 5651 } 5652 console.log('bind success'); 5653}); 5654 5655let tlsOneWayConnectOptions: socket.TLSConnectOptions = { 5656 address: { 5657 address: '192.168.xx.xxx', 5658 port: 8080 5659 }, 5660 secureOptions: { 5661 ca: ["xxxx", "xxxx"], 5662 cipherSuite: "AES256-SHA256" 5663 } 5664} 5665tlsOneWay.connect(tlsOneWayConnectOptions, (err: BusinessError) => { 5666 console.error("connect callback error" + err); 5667}); 5668``` 5669 5670### connect<sup>9+</sup> 5671 5672connect(options: TLSConnectOptions): Promise\<void\> 5673 5674在TLSSocket上bind成功之后，进行通信连接，并创建和初始化TLS会话，实现建立连接过程，启动与服务器的TLS/SSL握手，实现数据传输功能，该连接包括两种认证方式，单向认证与双向认证，使用Promise方式作为异步方法。需要注意options入参下secureOptions内的ca为必填项，需填入服务端的ca证书(用于认证校验服务端的数字证书),证书内容以"-----BEGIN CERTIFICATE-----"开头，以"-----END CERTIFICATE-----"结尾。 5675 5676**系统能力**：SystemCapability.Communication.NetStack 5677 5678**参数：** 5679 5680| 参数名 | 类型 | 必填 | 说明 | 5681| -------- | --------------------------------------| ----| --------------- | 5682| options | [TLSConnectOptions](#tlsconnectoptions9) | 是 | 连接所需要的参数。| 5683 5684**返回值：** 5685 5686| 类型 | 说明 | 5687| ------------------------------------------- | ----------------------------- | 5688| Promise\<void\> | 以Promise形式返回，成功无返回，失败返回错误码，错误信息。| 5689 5690**错误码：** 5691 5692| 错误码ID | 错误信息 | 5693| ------- | -------------------------------------------- | 5694| 401 | Parameter error. | 5695| 2303104 | Interrupted system call. | 5696| 2303109 | Bad file number. | 5697| 2303111 | Resource temporarily unavailable try again. | 5698| 2303188 | Socket operation on non-socket. | 5699| 2303191 | Protocol wrong type for socket. | 5700| 2303198 | Address already in use. | 5701| 2303199 | Cannot assign requested address. | 5702| 2303210 | Connection timed out. | 5703| 2303501 | SSL is null. | 5704| 2303502 | Error in tls reading. | 5705| 2303503 | Error in tls writing | 5706| 2303505 | Error occurred in the tls system call. | 5707| 2303506 | Error clearing tls connection. | 5708| 2300002 | System internal error. | 5709 5710**示例：** 5711 5712```ts 5713import socket from "@ohos.net.socket"; 5714import { BusinessError } from '@ohos.base'; 5715let tlsTwoWay: socket.TLSSocket = socket.constructTLSSocketInstance(); // Two way authentication 5716let bindAddr: socket.NetAddress = { 5717 address: '0.0.0.0', 5718} 5719tlsTwoWay.bind(bindAddr, (err: BusinessError) => { 5720 if (err) { 5721 console.log('bind fail'); 5722 return; 5723 } 5724 console.log('bind success'); 5725}); 5726 5727let tlsConnectOptions: socket.TLSConnectOptions = { 5728 address: { 5729 address: '192.168.xx.xxx', 5730 port: 8080 5731 }, 5732 secureOptions: { 5733 key: "xxxx", 5734 cert: "xxxx", 5735 ca: ["xxxx"], 5736 password: "xxxx", 5737 protocols: socket.Protocol.TLSv12, 5738 useRemoteCipherPrefer: true, 5739 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 5740 cipherSuite: "AES256-SHA256" 5741 }, 5742 ALPNProtocols: ["spdy/1", "http/1.1"] 5743} 5744 5745tlsTwoWay.connect(tlsConnectOptions).then(() => { 5746 console.log("connect successfully"); 5747}).catch((err: BusinessError) => { 5748 console.log("connect failed " + JSON.stringify(err)); 5749}); 5750 5751let tlsOneWay: socket.TLSSocket = socket.constructTLSSocketInstance(); // One way authentication 5752tlsOneWay.bind(bindAddr, (err: BusinessError) => { 5753 if (err) { 5754 console.log('bind fail'); 5755 return; 5756 } 5757 console.log('bind success'); 5758}); 5759 5760let tlsOneWayConnectOptions: socket.TLSConnectOptions = { 5761 address: { 5762 address: '192.168.xx.xxx', 5763 port: 8080 5764 }, 5765 secureOptions: { 5766 ca: ["xxxx", "xxxx"], 5767 cipherSuite: "AES256-SHA256" 5768 } 5769} 5770tlsOneWay.connect(tlsOneWayConnectOptions).then(() => { 5771 console.log("connect successfully"); 5772}).catch((err: BusinessError) => { 5773 console.log("connect failed " + JSON.stringify(err)); 5774}); 5775``` 5776 5777### getRemoteAddress<sup>9+</sup> 5778 5779getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void 5780 5781在TLSSocket通信连接成功之后，获取对端Socket地址。使用callback方式作为异步方法。 5782 5783**系统能力**：SystemCapability.Communication.NetStack 5784 5785**参数：** 5786 5787| 参数名 | 类型 | 必填 | 说明 | 5788| -------- | ------------------------------------------------- | ---- | ---------- | 5789| callback | AsyncCallback\<[NetAddress](#netaddress)\> | 是 | 回调函数。成功返回对端的socket地址，失败返回错误码，错误信息。 | 5790 5791**错误码：** 5792 5793| 错误码ID | 错误信息 | 5794| ------- | ----------------------------- | 5795| 2303188 | Socket operation on non-socket.| 5796| 2300002 | System internal error. | 5797 5798**示例：** 5799 5800```ts 5801import socket from "@ohos.net.socket"; 5802import { BusinessError } from '@ohos.base'; 5803let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5804tls.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => { 5805 if (err) { 5806 console.log('getRemoteAddress fail'); 5807 return; 5808 } 5809 console.log('getRemoteAddress success:' + JSON.stringify(data)); 5810}); 5811``` 5812 5813### getRemoteAddress<sup>9+</sup> 5814 5815getRemoteAddress(): Promise\<NetAddress\> 5816 5817在TLSSocket通信连接成功之后，获取对端Socket地址。使用Promise方式作为异步方法。 5818 5819**系统能力**：SystemCapability.Communication.NetStack 5820 5821**返回值：** 5822 5823| 类型 | 说明 | 5824| ------------------------------------------ | ------------------------------------------ | 5825| Promise\<[NetAddress](#netaddress)> | 以Promise形式返回获取对端socket地址的结果。失败返回错误码，错误信息。 | 5826 5827**错误码：** 5828 5829| 错误码ID | 错误信息 | 5830| ------- | ------------------------------ | 5831| 2303188 | Socket operation on non-socket.| 5832| 2300002 | System internal error. | 5833 5834**示例：** 5835 5836```ts 5837import socket from "@ohos.net.socket"; 5838import { BusinessError } from '@ohos.base'; 5839let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5840tls.getRemoteAddress().then(() => { 5841 console.log('getRemoteAddress success'); 5842}).catch((err: BusinessError) => { 5843 console.log('getRemoteAddress fail'); 5844}); 5845``` 5846 5847### getCertificate<sup>9+</sup> 5848 5849getCertificate(callback: AsyncCallback\<[X509CertRawData](#x509certrawdata9)\>): void 5850 5851在TLSSocket通信连接成功之后，获取本地的数字证书，该接口只适用于双向认证时，使用callback方式作为异步方法。 5852 5853**系统能力**：SystemCapability.Communication.NetStack 5854 5855**参数：** 5856 5857| 参数名 | 类型 | 必填 | 说明 | 5858| -------- | ----------------------------------------| ---- | ---------------| 5859| callback | AsyncCallback\<[X509CertRawData](#x509certrawdata9)\> | 是 | 回调函数，成功返回本地的证书，失败返回错误码，错误信息。| 5860 5861**错误码：** 5862 5863| 错误码ID | 错误信息 | 5864| ------- | ------------------------------ | 5865| 2303501 | SSL is null. | 5866| 2303504 | Error looking up x509. | 5867| 2300002 | System internal error. | 5868 5869**示例：** 5870 5871```ts 5872import socket from "@ohos.net.socket"; 5873import { BusinessError } from '@ohos.base'; 5874let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5875tls.getCertificate((err: BusinessError, data: socket.X509CertRawData) => { 5876 if (err) { 5877 console.log("getCertificate callback error = " + err); 5878 } else { 5879 console.log("getCertificate callback = " + data); 5880 } 5881}); 5882``` 5883 5884### getCertificate<sup>9+</sup> 5885 5886getCertificate():Promise\<[X509CertRawData](#x509certrawdata9)\> 5887 5888在TLSSocket通信连接之后，获取本地的数字证书，该接口只适用于双向认证时，使用Promise方式作为异步方法。 5889 5890**系统能力**：SystemCapability.Communication.NetStack 5891 5892**返回值：** 5893 5894| 类型 | 说明 | 5895| -------------- | -------------------- | 5896| Promise\<[X509CertRawData](#x509certrawdata9)\> | 以Promise形式返回本地的数字证书的结果。失败返回错误码，错误信息。 | 5897 5898**错误码：** 5899 5900| 错误码ID | 错误信息 | 5901| ------- | ------------------------------ | 5902| 2303501 | SSL is null. | 5903| 2303504 | Error looking up x509. | 5904| 2300002 | System internal error. | 5905 5906**示例：** 5907 5908```ts 5909import socket from "@ohos.net.socket"; 5910import { BusinessError } from '@ohos.base'; 5911import util from "@ohos.util"; 5912 5913let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5914tls.getCertificate().then((data: socket.X509CertRawData) => { 5915 const decoder = util.TextDecoder.create(); 5916 const str = decoder.decodeWithStream(data.data); 5917 console.log("getCertificate: " + str); 5918}).catch((err: BusinessError) => { 5919 console.error("failed" + err); 5920}); 5921``` 5922 5923### getRemoteCertificate<sup>9+</sup> 5924 5925getRemoteCertificate(callback: AsyncCallback\<[X509CertRawData](#x509certrawdata9)\>): void 5926 5927在TLSSocket通信连接成功之后，获取服务端的数字证书，使用callback方式作为异步方法。 5928 5929**系统能力**：SystemCapability.Communication.NetStack 5930 5931**参数：** 5932 5933| 参数名 | 类型 | 必填 | 说明 | 5934| -------- | ----------------------------------------| ---- | ---------------| 5935| callback | AsyncCallback\<[X509CertRawData](#x509certrawdata9)\> | 是 | 回调函数，返回服务端的证书。失败返回错误码，错误信息。 | 5936 5937**错误码：** 5938 5939| 错误码ID | 错误信息 | 5940| ------- | ------------------------------ | 5941| 2303501 | SSL is null. | 5942| 2300002 | System internal error. | 5943 5944**示例：** 5945 5946```ts 5947import socket from "@ohos.net.socket"; 5948import { BusinessError } from '@ohos.base'; 5949let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5950tls.getRemoteCertificate((err: BusinessError, data: socket.X509CertRawData) => { 5951 if (err) { 5952 console.log("getRemoteCertificate callback error = " + err); 5953 } else { 5954 console.log("getRemoteCertificate callback = " + data); 5955 } 5956}); 5957``` 5958 5959### getRemoteCertificate<sup>9+</sup> 5960 5961getRemoteCertificate():Promise\<[X509CertRawData](#x509certrawdata9)\> 5962 5963在TLSSocket通信连接成功之后，获取服务端的数字证书，使用Promise方式作为异步方法。 5964 5965**系统能力**：SystemCapability.Communication.NetStack 5966 5967**返回值：** 5968 5969| 类型 | 说明 | 5970| -------------- | -------------------- | 5971| Promise\<[X509CertRawData](#x509certrawdata9)\> | 以Promise形式返回服务端的数字证书的结果。失败返回错误码，错误信息。 | 5972 5973**错误码：** 5974 5975| 错误码ID | 错误信息 | 5976| ------- | ------------------------------ | 5977| 2303501 | SSL is null. | 5978| 2300002 | System internal error. | 5979 5980**示例：** 5981 5982```ts 5983import socket from "@ohos.net.socket"; 5984import { BusinessError } from '@ohos.base'; 5985let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5986tls.getRemoteCertificate().then((data: socket.X509CertRawData) => { 5987 console.log(data); 5988}).catch((err: BusinessError) => { 5989 console.error("failed" + err); 5990}); 5991``` 5992 5993### getProtocol<sup>9+</sup> 5994 5995getProtocol(callback: AsyncCallback\<string\>): void 5996 5997在TLSSocket通信连接成功之后，获取通信的协议版本，使用callback方式作为异步方法。 5998 5999**系统能力**：SystemCapability.Communication.NetStack 6000 6001**参数：** 6002 6003| 参数名 | 类型 | 必填 | 说明 | 6004| -------- | ----------------------------------------| ---- | ---------------| 6005| callback | AsyncCallback\<string\> | 是 | 回调函数，返回通信的协议。失败返回错误码，错误信息。| 6006 6007**错误码：** 6008 6009| 错误码ID | 错误信息 | 6010| ------- | ----------------------------- | 6011| 2303501 | SSL is null. | 6012| 2303505 | Error occurred in the tls system call. | 6013| 2300002 | System internal error. | 6014 6015**示例：** 6016 6017```ts 6018import socket from "@ohos.net.socket"; 6019import { BusinessError } from '@ohos.base'; 6020let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6021tls.getProtocol((err: BusinessError, data: string) => { 6022 if (err) { 6023 console.log("getProtocol callback error = " + err); 6024 } else { 6025 console.log("getProtocol callback = " + data); 6026 } 6027}); 6028``` 6029 6030### getProtocol<sup>9+</sup> 6031 6032getProtocol():Promise\<string\> 6033 6034在TLSSocket通信连接成功之后，获取通信的协议版本，使用Promise方式作为异步方法。 6035 6036**系统能力**：SystemCapability.Communication.NetStack 6037 6038**返回值：** 6039 6040| 类型 | 说明 | 6041| -------------- | -------------------- | 6042| Promise\<string\> | 以Promise形式返回通信的协议。失败返回错误码，错误信息。 | 6043 6044**错误码：** 6045 6046| 错误码ID | 错误信息 | 6047| ------- | ------------------------------ | 6048| 2303501 | SSL is null. | 6049| 2303505 | Error occurred in the tls system call. | 6050| 2300002 | System internal error. | 6051 6052**示例：** 6053 6054```ts 6055import socket from "@ohos.net.socket"; 6056import { BusinessError } from '@ohos.base'; 6057let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6058tls.getProtocol().then((data: string) => { 6059 console.log(data); 6060}).catch((err: BusinessError) => { 6061 console.error("failed" + err); 6062}); 6063``` 6064 6065### getCipherSuite<sup>9+</sup> 6066 6067getCipherSuite(callback: AsyncCallback\<Array\<string\>\>): void 6068 6069在TLSSocket通信连接成功之后，获取通信双方协商后的加密套件，使用callback方式作为异步方法。 6070 6071**系统能力**：SystemCapability.Communication.NetStack 6072 6073**参数：** 6074 6075| 参数名 | 类型 | 必填 | 说明 | 6076| -------- | ----------------------------------------| ---- | ---------------| 6077| callback | AsyncCallback\<Array\<string\>\> | 是 | 回调函数，返回通信双方支持的加密套件。 失败返回错误码，错误信息。 | 6078 6079**错误码：** 6080 6081| 错误码ID | 错误信息 | 6082| ------- | ------------------------------ | 6083| 2303501 | SSL is null. | 6084| 2303502 | Error in tls reading. | 6085| 2303505 | Error occurred in the tls system call. | 6086| 2300002 | System internal error. | 6087 6088**示例：** 6089 6090```ts 6091import socket from "@ohos.net.socket"; 6092import { BusinessError } from '@ohos.base'; 6093let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6094tls.getCipherSuite((err: BusinessError, data: Array<string>) => { 6095 if (err) { 6096 console.log("getCipherSuite callback error = " + err); 6097 } else { 6098 console.log("getCipherSuite callback = " + data); 6099 } 6100}); 6101``` 6102 6103### getCipherSuite<sup>9+</sup> 6104 6105getCipherSuite(): Promise\<Array\<string\>\> 6106 6107在TLSSocket通信连接成功之后，获取通信双方协商后的加密套件，使用Promise方式作为异步方法。 6108 6109**系统能力**：SystemCapability.Communication.NetStack 6110 6111**返回值：** 6112 6113| 类型 | 说明 | 6114| ---------------------- | --------------------- | 6115| Promise\<Array\<string\>\> | 以Promise形式返回通信双方支持的加密套件。失败返回错误码，错误信息。 | 6116 6117**错误码：** 6118 6119| 错误码ID | 错误信息 | 6120| ------- | ------------------------------ | 6121| 2303501 | SSL is null. | 6122| 2303502 | Error in tls reading. | 6123| 2303505 | Error occurred in the tls system call. | 6124| 2300002 | System internal error. | 6125 6126**示例：** 6127 6128```ts 6129import socket from "@ohos.net.socket"; 6130import { BusinessError } from '@ohos.base'; 6131let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6132tls.getCipherSuite().then((data: Array<string>) => { 6133 console.log('getCipherSuite success:' + JSON.stringify(data)); 6134}).catch((err: BusinessError) => { 6135 console.error("failed" + err); 6136}); 6137``` 6138 6139### getSignatureAlgorithms<sup>9+</sup> 6140 6141getSignatureAlgorithms(callback: AsyncCallback\<Array\<string\>\>): void 6142 6143在TLSSocket通信连接成功之后，获取通信双方协商后签名算法，该接口只适配双向认证模式下，使用callback方式作为异步方法。 6144 6145**系统能力**：SystemCapability.Communication.NetStack 6146 6147**参数：** 6148 6149| 参数名 | 类型 | 必填 | 说明 | 6150| -------- | -------------------------------------| ---- | ---------------| 6151| callback | AsyncCallback\<Array\<string\>\> | 是 | 回调函数，返回双方支持的签名算法。 | 6152 6153**错误码：** 6154 6155| 错误码ID | 错误信息 | 6156| ------- | ------------------------------ | 6157| 2303501 | SSL is null. | 6158| 2300002 | System internal error. | 6159 6160**示例：** 6161 6162```ts 6163import socket from "@ohos.net.socket"; 6164import { BusinessError } from '@ohos.base'; 6165let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6166tls.getSignatureAlgorithms((err: BusinessError, data: Array<string>) => { 6167 if (err) { 6168 console.log("getSignatureAlgorithms callback error = " + err); 6169 } else { 6170 console.log("getSignatureAlgorithms callback = " + data); 6171 } 6172}); 6173``` 6174 6175### getSignatureAlgorithms<sup>9+</sup> 6176 6177getSignatureAlgorithms(): Promise\<Array\<string\>\> 6178 6179在TLSSocket通信连接成功之后，获取通信双方协商后的签名算法，该接口只适配双向认证模式下，使用Promise方式作为异步方法。 6180 6181**系统能力**：SystemCapability.Communication.NetStack 6182 6183**返回值：** 6184 6185| 类型 | 说明 | 6186| ---------------------- | -------------------- | 6187| Promise\<Array\<string\>\> | 以Promise形式返回获取到的双方支持的签名算法。 | 6188 6189**错误码：** 6190 6191| 错误码ID | 错误信息 | 6192| ------- | ------------------------------ | 6193| 2303501 | SSL is null. | 6194| 2300002 | System internal error. | 6195 6196**示例：** 6197 6198```ts 6199import socket from "@ohos.net.socket"; 6200import { BusinessError } from '@ohos.base'; 6201let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6202tls.getSignatureAlgorithms().then((data: Array<string>) => { 6203 console.log("getSignatureAlgorithms success" + data); 6204}).catch((err: BusinessError) => { 6205 console.error("failed" + err); 6206}); 6207``` 6208 6209### send<sup>9+</sup> 6210 6211send(data: string, callback: AsyncCallback\<void\>): void 6212 6213在TLSSocket通信连接成功之后，向服务端发送消息，使用callback方式作为异步方法。 6214 6215**系统能力**：SystemCapability.Communication.NetStack 6216 6217**参数：** 6218 6219| 参数名 | 类型 | 必填 | 说明 | 6220| -------- | -----------------------------| ---- | ---------------| 6221| data | string | 是 | 发送的数据内容。 | 6222| callback | AsyncCallback\<void\> | 是 | 回调函数,返回TLSSocket发送数据的结果。失败返回错误码，错误信息。 | 6223 6224**错误码：** 6225 6226| 错误码ID | 错误信息 | 6227| ------- | -------------------------------------------- | 6228| 401 | Parameter error. | 6229| 2303501 | SSL is null. | 6230| 2303503 | Error in tls writing. | 6231| 2303505 | Error occurred in the tls system call. | 6232| 2303506 | Error clearing tls connection. | 6233| 2300002 | System internal error. | 6234 6235**示例：** 6236 6237```ts 6238import socket from "@ohos.net.socket"; 6239import { BusinessError } from '@ohos.base'; 6240let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6241tls.send("xxxx", (err: BusinessError) => { 6242 if (err) { 6243 console.log("send callback error = " + err); 6244 } else { 6245 console.log("send success"); 6246 } 6247}); 6248``` 6249 6250### send<sup>9+</sup> 6251 6252send(data: string): Promise\<void\> 6253 6254在TLSSocket通信连接成功之后，向服务端发送消息，使用Promise方式作为异步方法。 6255 6256**系统能力**：SystemCapability.Communication.NetStack 6257 6258**参数：** 6259 6260| 参数名 | 类型 | 必填 | 说明 | 6261| -------- | -----------------------------| ---- | ---------------| 6262| data | string | 是 | 发送的数据内容。 | 6263 6264**错误码：** 6265 6266| 错误码ID | 错误信息 | 6267| ------- | -------------------------------------------- | 6268| 401 | Parameter error. | 6269| 2303501 | SSL is null. | 6270| 2303503 | Error in tls writing. | 6271| 2303505 | Error occurred in the tls system call. | 6272| 2303506 | Error clearing tls connection. | 6273| 2300002 | System internal error. | 6274 6275**返回值：** 6276 6277| 类型 | 说明 | 6278| -------------- | -------------------- | 6279| Promise\<void\> | 以Promise形式返回,返回TLSSocket发送数据的结果。失败返回错误码，错误信息。 | 6280 6281**示例：** 6282 6283```ts 6284import socket from "@ohos.net.socket"; 6285import { BusinessError } from '@ohos.base'; 6286let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6287tls.send("xxxx").then(() => { 6288 console.log("send success"); 6289}).catch((err: BusinessError) => { 6290 console.error("failed" + err); 6291}); 6292``` 6293 6294### close<sup>9+</sup> 6295 6296close(callback: AsyncCallback\<void\>): void 6297 6298在TLSSocket通信连接成功之后，断开连接，使用callback方式作为异步方法。 6299 6300**系统能力**：SystemCapability.Communication.NetStack 6301 6302**参数：** 6303 6304| 参数名 | 类型 | 必填 | 说明 | 6305| -------- | -----------------------------| ---- | ---------------| 6306| callback | AsyncCallback\<void\> | 是 | 回调函数,成功返回TLSSocket关闭连接的结果。 失败返回错误码，错误信息。 | 6307 6308**错误码：** 6309 6310| 错误码ID | 错误信息 | 6311| ------- | -------------------------------------------- | 6312| 401 | Parameter error. | 6313| 2303501 | SSL is null. | 6314| 2303505 | Error occurred in the tls system call. | 6315| 2303506 | Error clearing tls connection. | 6316| 2300002 | System internal error. | 6317 6318**示例：** 6319 6320```ts 6321import socket from "@ohos.net.socket"; 6322import { BusinessError } from '@ohos.base'; 6323let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6324tls.close((err: BusinessError) => { 6325 if (err) { 6326 console.log("close callback error = " + err); 6327 } else { 6328 console.log("close success"); 6329 } 6330}); 6331``` 6332 6333### close<sup>9+</sup> 6334 6335close(): Promise\<void\> 6336 6337在TLSSocket通信连接成功之后，断开连接，使用Promise方式作为异步方法。 6338 6339**系统能力**：SystemCapability.Communication.NetStack 6340 6341**返回值：** 6342 6343| 类型 | 说明 | 6344| -------------- | -------------------- | 6345| Promise\<void\> | 以Promise形式返回,返回TLSSocket关闭连接的结果。失败返回错误码，错误信息。 | 6346 6347**错误码：** 6348 6349| 错误码ID | 错误信息 | 6350| ------- | -------------------------------------------- | 6351| 401 | Parameter error. | 6352| 2303501 | SSL is null. | 6353| 2303505 | Error occurred in the tls system call. | 6354| 2303506 | Error clearing tls connection. | 6355| 2300002 | System internal error. | 6356 6357**示例：** 6358 6359```ts 6360import socket from "@ohos.net.socket"; 6361import { BusinessError } from '@ohos.base'; 6362let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6363tls.close().then(() => { 6364 console.log("close success"); 6365}).catch((err: BusinessError) => { 6366 console.error("failed" + err); 6367}); 6368``` 6369 6370## TLSConnectOptions<sup>9+</sup> 6371 6372TLS连接的操作。 6373 6374**系统能力**：SystemCapability.Communication.NetStack 6375 6376| 名称 | 类型 | 必填 | 说明 | 6377| -------------- | ------------------------------------- | --- |-------------- | 6378| address | [NetAddress](#netaddress) | 是 | 网关地址。 | 6379| secureOptions | [TLSSecureOptions](#tlssecureoptions9) | 是 | TLS安全相关操作。| 6380| ALPNProtocols | Array\<string\> | 否 | ALPN协议，支持["spdy/1", "http/1.1"]，默认为[]。 | 6381 6382## TLSSecureOptions<sup>9+</sup> 6383 6384TLS安全相关操作，其中ca证书为必选参数，其他参数为可选参数。当本地证书cert和私钥key不为空时，开启双向验证模式。cert和key其中一项为空时，开启单向验证模式。 6385 6386**系统能力**：SystemCapability.Communication.NetStack 6387 6388| 名称 | 类型 | 必填 | 说明 | 6389| --------------------- | ------------------------------------------------------ | --- |----------------------------------- | 6390| ca | string \| Array\<string\> | 是 | 服务端的ca证书，用于认证校验服务端的数字证书。| 6391| cert | string | 否 | 本地客户端的数字证书。 | 6392| key | string | 否 | 本地数字证书的私钥。 | 6393| password | string | 否 | 读取私钥的密码。 | 6394| protocols | [Protocol](#protocol9) \|Array\<[Protocol](#protocol9)\> | 否 | TLS的协议版本，默认为"TLSv1.2"。 | 6395| useRemoteCipherPrefer | boolean | 否 | 优先使用对等方的密码套件。 | 6396| signatureAlgorithms | string | 否 | 通信过程中的签名算法，默认为"" 。 | 6397| cipherSuite | string | 否 | 通信过程中的加密套件，默认为"" 。 | 6398 6399## Protocol<sup>9+</sup> 6400 6401TLS通信的协议版本。 6402 6403**系统能力**：SystemCapability.Communication.NetStack 6404 6405| 名称 | 值 | 说明 | 6406| --------- | --------- |------------------ | 6407| TLSv12 | "TLSv1.2" | 使用TLSv1.2协议通信。 | 6408| TLSv13 | "TLSv1.3" | 使用TLSv1.3协议通信。 | 6409 6410## X509CertRawData<sup>9+</sup> 6411 6412存储证书的数据。 6413 6414**系统能力**：SystemCapability.Communication.NetStack 6415 6416## socket.constructTLSSocketServerInstance<sup>10+</sup> 6417 6418constructTLSSocketServerInstance(): TLSSocketServer 6419 6420创建并返回一个TLSSocketServer对象。 6421 6422**系统能力**：SystemCapability.Communication.NetStack 6423 6424**返回值:** 6425 6426| 类型 | 说明 | 6427| ------------------------------------ | ---------------------------- | 6428| [TLSSocketServer](#tlssocketserver10) | 返回一个TLSSocketServer对象。 | 6429 6430**示例：** 6431 6432```ts 6433import socket from "@ohos.net.socket"; 6434import { BusinessError } from '@ohos.base'; 6435let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6436``` 6437 6438## TLSSocketServer<sup>10+</sup> 6439 6440TLSSocketServer连接。在调用TLSSocketServer的方法前，需要先通过[socket.constructTLSSocketServerInstance](#socketconstructtlssocketserverinstance10)创建TLSSocketServer对象。 6441 6442### listen<sup>10+</sup> 6443 6444listen(options: TLSConnectOptions, callback: AsyncCallback\<void\>): void 6445 6446绑定IP地址和端口，在TLSSocketServer上bind成功之后，监听客户端的连接，创建和初始化TLS会话，实现建立连接过程，加载证书秘钥并验证，使用callback方式作为异步方法。 6447 6448**需要权限**：ohos.permission.INTERNET 6449 6450**系统能力**：SystemCapability.Communication.NetStack 6451 6452**参数：** 6453 6454| 参数名 | 类型 | 必填 | 说明 | 6455| -------- | ---------------------------------------- | ---- | ------------------------------------------------ | 6456| options | [TLSConnectOptions](#tlsconnectoptions9) | 是 | TLSSocketServer连接所需要的参数。 | 6457| callback | AsyncCallback\<void\> | 是 | 回调函数，成功返回空，失败返回错误码，错误信息。 | 6458 6459**错误码：** 6460 6461| 错误码ID | 错误信息 | 6462| -------- | ------------------------------------------- | 6463| 401 | Parameter error. | 6464| 201 | Permission denied. | 6465| 2300002 | System internal error. | 6466| 2303109 | Bad file number. | 6467| 2303111 | Resource temporarily unavailable try again. | 6468| 2303198 | Address already in use. | 6469| 2303199 | Cannot assign requested address. | 6470| 2303501 | SSL is null. | 6471| 2303502 | Error in tls reading. | 6472| 2303503 | Error in tls writing | 6473| 2303505 | Error occurred in the tls system call. | 6474| 2303506 | Error clearing tls connection. | 6475 6476**示例：** 6477 6478```ts 6479import socket from "@ohos.net.socket"; 6480import { BusinessError } from '@ohos.base'; 6481let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6482 6483let tlsConnectOptions: socket.TLSConnectOptions = { 6484 address: { 6485 address: '192.168.xx.xxx', 6486 port: 8080 6487 }, 6488 secureOptions: { 6489 key: "xxxx", 6490 cert: "xxxx", 6491 ca: ["xxxx"], 6492 password: "xxxx", 6493 protocols: socket.Protocol.TLSv12, 6494 useRemoteCipherPrefer: true, 6495 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6496 cipherSuite: "AES256-SHA256" 6497 }, 6498 ALPNProtocols: ["spdy/1", "http/1.1"] 6499} 6500tlsServer.listen(tlsConnectOptions, (err: BusinessError) => { 6501 console.log("listen callback error" + err); 6502}); 6503``` 6504 6505### listen<sup>10+</sup> 6506 6507listen(options: TLSConnectOptions): Promise\<void\> 6508 6509绑定IP地址和端口，在TLSSocketServer上bind成功之后，监听客户端的连接，并创建和初始化TLS会话，实现建立连接过程，加载证书秘钥并验证，使用Promise方式作为异步方法。 6510 6511**需要权限**：ohos.permission.INTERNET 6512 6513**系统能力**：SystemCapability.Communication.NetStack 6514 6515**参数：** 6516 6517| 参数名 | 类型 | 必填 | 说明 | 6518| ------- | ---------------------------------------- | ---- | ------------------ | 6519| options | [TLSConnectOptions](#tlsconnectoptions9) | 是 | 连接所需要的参数。 | 6520 6521**返回值：** 6522 6523| 类型 | 说明 | 6524| --------------- | --------------------------------------------------------- | 6525| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码，错误信息。 | 6526 6527**错误码：** 6528 6529| 错误码ID | 错误信息 | 6530| -------- | ------------------------------------------- | 6531| 401 | Parameter error. | 6532| 201 | Permission denied. | 6533| 2300002 | System internal error. | 6534| 2303109 | Bad file number. | 6535| 2303111 | Resource temporarily unavailable try again. | 6536| 2303198 | Address already in use. | 6537| 2303199 | Cannot assign requested address. | 6538| 2303501 | SSL is null. | 6539| 2303502 | Error in tls reading. | 6540| 2303503 | Error in tls writing | 6541| 2303505 | Error occurred in the tls system call. | 6542| 2303506 | Error clearing tls connection. | 6543 6544**示例：** 6545 6546```ts 6547import socket from "@ohos.net.socket"; 6548import { BusinessError } from '@ohos.base'; 6549let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6550 6551let tlsConnectOptions: socket.TLSConnectOptions = { 6552 address: { 6553 address: '192.168.xx.xxx', 6554 port: 8080 6555 }, 6556 secureOptions: { 6557 key: "xxxx", 6558 cert: "xxxx", 6559 ca: ["xxxx"], 6560 password: "xxxx", 6561 protocols: socket.Protocol.TLSv12, 6562 useRemoteCipherPrefer: true, 6563 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6564 cipherSuite: "AES256-SHA256" 6565 }, 6566 ALPNProtocols: ["spdy/1", "http/1.1"] 6567} 6568tlsServer.listen(tlsConnectOptions).then(() => { 6569 console.log("listen callback success"); 6570}).catch((err: BusinessError) => { 6571 console.log("failed: " + JSON.stringify(err)); 6572}); 6573``` 6574 6575### getState<sup>10+</sup> 6576 6577getState(callback: AsyncCallback\<SocketStateBase\>): void 6578 6579在TLSSocketServer的listen成功之后，获取TLSSocketServer状态。使用callback方式作为异步方法。 6580 6581> **说明：** 6582> listen方法调用成功后，才可调用此方法。 6583 6584**系统能力**：SystemCapability.Communication.NetStack 6585 6586**参数：** 6587 6588| 参数名 | 类型 | 必填 | 说明 | 6589| -------- | ---------------------------------------------------- | ---- | ------------------------------------------------------------ | 6590| callback | AsyncCallback\<[SocketStateBase](#socketstatebase)> | 是 | 回调函数。成功返回TLSSocketServer状态，失败返回错误码，错误信息。 | 6591 6592**错误码：** 6593 6594| 错误码ID | 错误信息 | 6595| -------- | ------------------------------- | 6596| 401 | Parameter error. | 6597| 2303188 | Socket operation on non-socket. | 6598| 2300002 | System internal error. | 6599 6600**示例：** 6601 6602```ts 6603import socket from "@ohos.net.socket"; 6604import { BusinessError } from '@ohos.base'; 6605let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6606let tlsConnectOptions: socket.TLSConnectOptions = { 6607 address: { 6608 address: '192.168.xx.xxx', 6609 port: 8080 6610 }, 6611 secureOptions: { 6612 key: "xxxx", 6613 cert: "xxxx", 6614 ca: ["xxxx"], 6615 password: "xxxx", 6616 protocols: socket.Protocol.TLSv12, 6617 useRemoteCipherPrefer: true, 6618 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6619 cipherSuite: "AES256-SHA256" 6620 }, 6621 ALPNProtocols: ["spdy/1", "http/1.1"] 6622} 6623tlsServer.listen(tlsConnectOptions).then(() => { 6624 console.log("listen callback success"); 6625}).catch((err: BusinessError) => { 6626 console.log("failed: " + JSON.stringify(err)); 6627}); 6628tlsServer.getState((err: BusinessError, data: socket.SocketStateBase) => { 6629 if (err) { 6630 console.log('getState fail'); 6631 return; 6632 } 6633 console.log('getState success:' + JSON.stringify(data)); 6634}); 6635``` 6636 6637### getState<sup>10+</sup> 6638 6639getState(): Promise\<SocketStateBase\> 6640 6641在TLSSocketServer的listen成功之后，获取TLSSocketServer状态。使用Promise方式作为异步方法。 6642 6643> **说明：** 6644> listen方法调用成功后，才可调用此方法。 6645 6646**系统能力**：SystemCapability.Communication.NetStack 6647 6648**返回值：** 6649 6650| 类型 | 说明 | 6651| --------------------------------------------- | ----------------------------------------------------------- | 6652| Promise\<[SocketStateBase](#socketstatebase)> | 以Promise形式返回获取TLSSocketServer状态的结果。失败返回错误码，错误信息。 | 6653 6654**错误码：** 6655 6656| 错误码ID | 错误信息 | 6657| -------- | ------------------------------- | 6658| 2303188 | Socket operation on non-socket. | 6659| 2300002 | System internal error. | 6660 6661**示例：** 6662 6663```ts 6664import socket from "@ohos.net.socket"; 6665import { BusinessError } from '@ohos.base'; 6666let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6667let tlsConnectOptions: socket.TLSConnectOptions = { 6668 address: { 6669 address: '192.168.xx.xxx', 6670 port: 8080 6671 }, 6672 secureOptions: { 6673 key: "xxxx", 6674 cert: "xxxx", 6675 ca: ["xxxx"], 6676 password: "xxxx", 6677 protocols: socket.Protocol.TLSv12, 6678 useRemoteCipherPrefer: true, 6679 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6680 cipherSuite: "AES256-SHA256" 6681 }, 6682 ALPNProtocols: ["spdy/1", "http/1.1"] 6683} 6684tlsServer.listen(tlsConnectOptions).then(() => { 6685 console.log("listen callback success"); 6686}).catch((err: BusinessError) => { 6687 console.log("failed: " + JSON.stringify(err)); 6688}); 6689tlsServer.getState().then(() => { 6690 console.log('getState success'); 6691}).catch((err: BusinessError) => { 6692 console.log('getState fail'); 6693}); 6694``` 6695 6696### setExtraOptions<sup>10+</sup> 6697 6698setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void 6699 6700在TLSSocketServer的listen成功之后，设置TLSSocketServer连接的其他属性。使用callback方式作为异步方法。 6701 6702> **说明：** 6703> listen方法调用成功后，才可调用此方法。 6704 6705**系统能力**：SystemCapability.Communication.NetStack 6706 6707**参数：** 6708 6709| 参数名 | 类型 | 必填 | 说明 | 6710| -------- | ------------------------------------ | ---- | ------------------------------------------------ | 6711| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TLSSocketServer连接的其他属性。 | 6712| callback | AsyncCallback\<void\> | 是 | 回调函数。成功返回空，失败返回错误码，错误信息。 | 6713 6714**错误码：** 6715 6716| 错误码ID | 错误信息 | 6717| -------- | ------------------------------- | 6718| 401 | Parameter error. | 6719| 2303188 | Socket operation on non-socket. | 6720| 2300002 | System internal error. | 6721 6722**示例：** 6723 6724```ts 6725import socket from "@ohos.net.socket"; 6726import { BusinessError } from '@ohos.base'; 6727let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6728let tlsConnectOptions: socket.TLSConnectOptions = { 6729 address: { 6730 address: '192.168.xx.xxx', 6731 port: 8080 6732 }, 6733 secureOptions: { 6734 key: "xxxx", 6735 cert: "xxxx", 6736 ca: ["xxxx"], 6737 password: "xxxx", 6738 protocols: socket.Protocol.TLSv12, 6739 useRemoteCipherPrefer: true, 6740 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6741 cipherSuite: "AES256-SHA256" 6742 }, 6743 ALPNProtocols: ["spdy/1", "http/1.1"] 6744} 6745tlsServer.listen(tlsConnectOptions).then(() => { 6746 console.log("listen callback success"); 6747}).catch((err: BusinessError) => { 6748 console.log("failed: " + JSON.stringify(err)); 6749}); 6750 6751let tcpExtraOptions: socket.TCPExtraOptions = { 6752 keepAlive: true, 6753 OOBInline: true, 6754 TCPNoDelay: true, 6755 socketLinger: { on: true, linger: 10 }, 6756 receiveBufferSize: 1000, 6757 sendBufferSize: 1000, 6758 reuseAddress: true, 6759 socketTimeout: 3000 6760} 6761tlsServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => { 6762 if (err) { 6763 console.log('setExtraOptions fail'); 6764 return; 6765 } 6766 console.log('setExtraOptions success'); 6767}); 6768``` 6769 6770### setExtraOptions<sup>10+</sup> 6771 6772setExtraOptions(options: TCPExtraOptions): Promise\<void\> 6773 6774在TLSSocketServer的listen成功之后，设置TLSSocketServer连接的其他属性，使用Promise方式作为异步方法。 6775 6776> **说明：** 6777> listen方法调用成功后，才可调用此方法。 6778 6779**系统能力**：SystemCapability.Communication.NetStack 6780 6781**参数：** 6782 6783| 参数名 | 类型 | 必填 | 说明 | 6784| ------- | ------------------------------------ | ---- | ------------------------------- | 6785| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TLSSocketServer连接的其他属性。 | 6786 6787**返回值：** 6788 6789| 类型 | 说明 | 6790| -------------- | -------------------------------------------------------- | 6791| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码，错误信息。 | 6792 6793**错误码：** 6794 6795| 错误码ID | 错误信息 | 6796| -------- | ------------------------------- | 6797| 401 | Parameter error. | 6798| 2303188 | Socket operation on non-socket. | 6799| 2300002 | System internal error. | 6800 6801**示例：** 6802 6803```ts 6804import socket from "@ohos.net.socket"; 6805import { BusinessError } from '@ohos.base'; 6806let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6807let tlsConnectOptions: socket.TLSConnectOptions = { 6808 address: { 6809 address: '192.168.xx.xxx', 6810 port: 8080 6811 }, 6812 secureOptions: { 6813 key: "xxxx", 6814 cert: "xxxx", 6815 ca: ["xxxx"], 6816 password: "xxxx", 6817 protocols: socket.Protocol.TLSv12, 6818 useRemoteCipherPrefer: true, 6819 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6820 cipherSuite: "AES256-SHA256" 6821 }, 6822 ALPNProtocols: ["spdy/1", "http/1.1"] 6823} 6824tlsServer.listen(tlsConnectOptions).then(() => { 6825 console.log("listen callback success"); 6826}).catch((err: BusinessError) => { 6827 console.log("failed: " + JSON.stringify(err)); 6828}); 6829 6830let tcpExtraOptions: socket.TCPExtraOptions = { 6831 keepAlive: true, 6832 OOBInline: true, 6833 TCPNoDelay: true, 6834 socketLinger: { on: true, linger: 10 }, 6835 receiveBufferSize: 1000, 6836 sendBufferSize: 1000, 6837 reuseAddress: true, 6838 socketTimeout: 3000 6839} 6840tlsServer.setExtraOptions(tcpExtraOptions).then(() => { 6841 console.log('setExtraOptions success'); 6842}).catch((err: BusinessError) => { 6843 console.log('setExtraOptions fail'); 6844}); 6845``` 6846 6847### getCertificate<sup>10+</sup> 6848 6849getCertificate(callback: AsyncCallback\<[X509CertRawData](#x509certrawdata9)\>): void 6850 6851在TLSSocketServer通信连接成功之后，获取本地的数字证书，使用callback方式作为异步方法。 6852 6853> **说明：** 6854> listen方法调用成功后，才可调用此方法。 6855 6856**系统能力**：SystemCapability.Communication.NetStack 6857 6858**参数：** 6859 6860| 参数名 | 类型 | 必填 | 说明 | 6861| -------- | ----------------------------------------------------- | ---- | -------------------------------------------------------- | 6862| callback | AsyncCallback\<[X509CertRawData](#x509certrawdata9)\> | 是 | 回调函数，成功返回本地的证书，失败返回错误码，错误信息。 | 6863 6864**错误码：** 6865 6866| 错误码ID | 错误信息 | 6867| -------- | ---------------------- | 6868| 401 | Parameter error. | 6869| 2303501 | SSL is null. | 6870| 2303504 | Error looking up x509. | 6871| 2300002 | System internal error. | 6872 6873**示例：** 6874 6875```ts 6876import socket from "@ohos.net.socket"; 6877import { BusinessError } from '@ohos.base'; 6878import util from "@ohos.util"; 6879 6880let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6881let tlsConnectOptions: socket.TLSConnectOptions = { 6882 address: { 6883 address: '192.168.xx.xxx', 6884 port: 8080 6885 }, 6886 secureOptions: { 6887 key: "xxxx", 6888 cert: "xxxx", 6889 ca: ["xxxx"], 6890 password: "xxxx", 6891 protocols: socket.Protocol.TLSv12, 6892 useRemoteCipherPrefer: true, 6893 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6894 cipherSuite: "AES256-SHA256" 6895 }, 6896 ALPNProtocols: ["spdy/1", "http/1.1"] 6897} 6898tlsServer.listen(tlsConnectOptions).then(() => { 6899 console.log("listen callback success"); 6900}).catch((err: BusinessError) => { 6901 console.log("failed: " + JSON.stringify(err)); 6902}); 6903tlsServer.getCertificate((err: BusinessError, data: socket.X509CertRawData) => { 6904 if (err) { 6905 console.log("getCertificate callback error = " + err); 6906 } else { 6907 const decoder = util.TextDecoder.create(); 6908 const str = decoder.decodeWithStream(data.data); 6909 console.log("getCertificate callback: " + str); 6910 } 6911}); 6912``` 6913 6914### getCertificate<sup>10+</sup> 6915 6916getCertificate():Promise\<[X509CertRawData](#x509certrawdata9)\> 6917 6918在TLSSocketServer通信连接之后，获取本地的数字证书，使用Promise方式作为异步方法。 6919 6920> **说明：** 6921> listen方法调用成功后，才可调用此方法。 6922 6923**系统能力**：SystemCapability.Communication.NetStack 6924 6925**返回值：** 6926 6927| 类型 | 说明 | 6928| ----------------------------------------------- | ------------------------------------------------------------ | 6929| Promise\<[X509CertRawData](#x509certrawdata9)\> | 以Promise形式返回本地的数字证书的结果。失败返回错误码，错误信息。 | 6930 6931**错误码：** 6932 6933| 错误码ID | 错误信息 | 6934| -------- | ---------------------- | 6935| 2303501 | SSL is null. | 6936| 2303504 | Error looking up x509. | 6937| 2300002 | System internal error. | 6938 6939**示例：** 6940 6941```ts 6942import socket from "@ohos.net.socket"; 6943import { BusinessError } from '@ohos.base'; 6944import util from "@ohos.util"; 6945 6946let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6947let tlsConnectOptions: socket.TLSConnectOptions = { 6948 address: { 6949 address: '192.168.xx.xxx', 6950 port: 8080 6951 }, 6952 secureOptions: { 6953 key: "xxxx", 6954 cert: "xxxx", 6955 ca: ["xxxx"], 6956 password: "xxxx", 6957 protocols: socket.Protocol.TLSv12, 6958 useRemoteCipherPrefer: true, 6959 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6960 cipherSuite: "AES256-SHA256" 6961 }, 6962 ALPNProtocols: ["spdy/1", "http/1.1"] 6963} 6964tlsServer.listen(tlsConnectOptions).then(() => { 6965 console.log("listen callback success"); 6966}).catch((err: BusinessError) => { 6967 console.log("failed: " + JSON.stringify(err)); 6968}); 6969tlsServer.getCertificate().then((data: socket.X509CertRawData) => { 6970 const decoder = util.TextDecoder.create(); 6971 const str = decoder.decodeWithStream(data.data); 6972 console.log("getCertificate: " + str); 6973}).catch((err: BusinessError) => { 6974 console.error("failed" + err); 6975}); 6976``` 6977 6978### getProtocol<sup>10+</sup> 6979 6980getProtocol(callback: AsyncCallback\<string\>): void 6981 6982在TLSSocketServer通信连接成功之后，获取通信的协议版本，使用callback方式作为异步方法。 6983 6984> **说明：** 6985> listen方法调用成功后，才可调用此方法。 6986 6987**系统能力**：SystemCapability.Communication.NetStack 6988 6989**参数：** 6990 6991| 参数名 | 类型 | 必填 | 说明 | 6992| -------- | ----------------------- | ---- | ---------------------------------------------------- | 6993| callback | AsyncCallback\<string\> | 是 | 回调函数，返回通信的协议。失败返回错误码，错误信息。 | 6994 6995**错误码：** 6996 6997| 错误码ID | 错误信息 | 6998| -------- | -------------------------------------- | 6999| 401 | Parameter error. | 7000| 2303501 | SSL is null. | 7001| 2303505 | Error occurred in the tls system call. | 7002| 2300002 | System internal error. | 7003 7004**示例：** 7005 7006```ts 7007import socket from "@ohos.net.socket"; 7008import { BusinessError } from '@ohos.base'; 7009let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7010let tlsConnectOptions: socket.TLSConnectOptions = { 7011 address: { 7012 address: '192.168.xx.xxx', 7013 port: 8080 7014 }, 7015 secureOptions: { 7016 key: "xxxx", 7017 cert: "xxxx", 7018 ca: ["xxxx"], 7019 password: "xxxx", 7020 protocols: socket.Protocol.TLSv12, 7021 useRemoteCipherPrefer: true, 7022 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7023 cipherSuite: "AES256-SHA256" 7024 }, 7025 ALPNProtocols: ["spdy/1", "http/1.1"] 7026} 7027tlsServer.listen(tlsConnectOptions).then(() => { 7028 console.log("listen callback success"); 7029}).catch((err: BusinessError) => { 7030 console.log("failed: " + JSON.stringify(err)); 7031}); 7032tlsServer.getProtocol((err: BusinessError, data: string) => { 7033 if (err) { 7034 console.log("getProtocol callback error = " + err); 7035 } else { 7036 console.log("getProtocol callback = " + data); 7037 } 7038}); 7039``` 7040 7041### getProtocol<sup>10+</sup> 7042 7043getProtocol():Promise\<string\> 7044 7045在TLSSocketServer通信连接成功之后，获取通信的协议版本，使用Promise方式作为异步方法。 7046 7047> **说明：** 7048> listen方法调用成功后，才可调用此方法。 7049 7050**系统能力**：SystemCapability.Communication.NetStack 7051 7052**返回值：** 7053 7054| 类型 | 说明 | 7055| ----------------- | ------------------------------------------------------- | 7056| Promise\<string\> | 以Promise形式返回通信的协议。失败返回错误码，错误信息。 | 7057 7058**错误码：** 7059 7060| 错误码ID | 错误信息 | 7061| -------- | -------------------------------------- | 7062| 2303501 | SSL is null. | 7063| 2303505 | Error occurred in the tls system call. | 7064| 2300002 | System internal error. | 7065 7066**示例：** 7067 7068```ts 7069import socket from "@ohos.net.socket"; 7070import { BusinessError } from '@ohos.base'; 7071let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7072let tlsConnectOptions: socket.TLSConnectOptions = { 7073 address: { 7074 address: '192.168.xx.xxx', 7075 port: 8080 7076 }, 7077 secureOptions: { 7078 key: "xxxx", 7079 cert: "xxxx", 7080 ca: ["xxxx"], 7081 password: "xxxx", 7082 protocols: socket.Protocol.TLSv12, 7083 useRemoteCipherPrefer: true, 7084 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7085 cipherSuite: "AES256-SHA256" 7086 }, 7087 ALPNProtocols: ["spdy/1", "http/1.1"] 7088} 7089tlsServer.listen(tlsConnectOptions).then(() => { 7090 console.log("listen callback success"); 7091}).catch((err: BusinessError) => { 7092 console.log("failed: " + JSON.stringify(err)); 7093}); 7094tlsServer.getProtocol().then((data: string) => { 7095 console.log(data); 7096}).catch((err: BusinessError) => { 7097 console.error("failed" + err); 7098}); 7099``` 7100 7101### on('connect')<sup>10+</sup> 7102 7103on(type: 'connect', callback: Callback\<TLSSocketConnection\>): void 7104 7105订阅TLSSocketServer的连接事件。使用callback方式作为异步方法。 7106 7107> **说明：** 7108> listen方法调用成功后，才可调用此方法。 7109 7110**系统能力**：SystemCapability.Communication.NetStack 7111 7112**参数：** 7113 7114| 参数名 | 类型 | 必填 | 说明 | 7115| -------- | ------------------------------------------------------- | ---- | ------------------------------------- | 7116| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 7117| callback | Callback<[TLSSocketConnection](#tlssocketconnection10)> | 是 | 回调函数。 | 7118 7119**错误码：** 7120 7121| 错误码ID | 错误信息 | 7122| -------- | ---------------- | 7123| 401 | Parameter error. | 7124 7125**示例：** 7126 7127```ts 7128import socket from "@ohos.net.socket"; 7129import { BusinessError } from '@ohos.base'; 7130let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7131let tlsConnectOptions: socket.TLSConnectOptions = { 7132 address: { 7133 address: '192.168.xx.xxx', 7134 port: 8080 7135 }, 7136 secureOptions: { 7137 key: "xxxx", 7138 cert: "xxxx", 7139 ca: ["xxxx"], 7140 password: "xxxx", 7141 protocols: socket.Protocol.TLSv12, 7142 useRemoteCipherPrefer: true, 7143 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7144 cipherSuite: "AES256-SHA256" 7145 }, 7146 ALPNProtocols: ["spdy/1", "http/1.1"] 7147} 7148tlsServer.listen(tlsConnectOptions).then(() => { 7149 console.log("listen callback success"); 7150}).catch((err: BusinessError) => { 7151 console.log("failed: " + JSON.stringify(err)); 7152}); 7153tlsServer.on('connect', (data: socket.TLSSocketConnection) => { 7154 console.log(JSON.stringify(data)) 7155}); 7156``` 7157 7158### off('connect')<sup>10+</sup> 7159 7160off(type: 'connect', callback?: Callback\<TLSSocketConnection\>): void 7161 7162取消订阅TLSSocketServer的连接事件。使用callback方式作为异步方法。 7163 7164> **说明：** 7165> listen方法调用成功后，才可调用此方法。 7166> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 7167 7168**系统能力**：SystemCapability.Communication.NetStack 7169 7170**参数：** 7171 7172| 参数名 | 类型 | 必填 | 说明 | 7173| -------- | ------------------------------------------------------- | ---- | ------------------------------------- | 7174| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 7175| callback | Callback<[TLSSocketConnection](#tlssocketconnection10)> | 否 | 回调函数。 | 7176 7177**错误码：** 7178 7179| 错误码ID | 错误信息 | 7180| -------- | ---------------- | 7181| 401 | Parameter error. | 7182 7183**示例：** 7184 7185```ts 7186import socket from "@ohos.net.socket"; 7187import { BusinessError } from '@ohos.base'; 7188let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7189let tlsConnectOptions: socket.TLSConnectOptions = { 7190 address: { 7191 address: '192.168.xx.xxx', 7192 port: 8080 7193 }, 7194 secureOptions: { 7195 key: "xxxx", 7196 cert: "xxxx", 7197 ca: ["xxxx"], 7198 password: "xxxx", 7199 protocols: socket.Protocol.TLSv12, 7200 useRemoteCipherPrefer: true, 7201 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7202 cipherSuite: "AES256-SHA256" 7203 }, 7204 ALPNProtocols: ["spdy/1", "http/1.1"] 7205} 7206tlsServer.listen(tlsConnectOptions).then(() => { 7207 console.log("listen callback success"); 7208}).catch((err: BusinessError) => { 7209 console.log("failed: " + JSON.stringify(err)); 7210}); 7211 7212let callback = (data: socket.TLSSocketConnection) => { 7213 console.log('on connect message: ' + JSON.stringify(data)); 7214} 7215tlsServer.on('connect', callback); 7216// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 7217tlsServer.off('connect', callback); 7218tlsServer.off('connect'); 7219``` 7220 7221### on('error')<sup>10+</sup> 7222 7223on(type: 'error', callback: ErrorCallback): void 7224 7225订阅TLSSocketServer连接的error事件。使用callback方式作为异步方法。 7226 7227> **说明：** 7228> listen方法调用成功后，才可调用此方法。 7229 7230**系统能力**：SystemCapability.Communication.NetStack 7231 7232**参数：** 7233 7234| 参数名 | 类型 | 必填 | 说明 | 7235| -------- | ------------- | ---- | ------------------------------------ | 7236| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 7237| callback | ErrorCallback | 是 | 回调函数。 | 7238 7239**错误码：** 7240 7241| 错误码ID | 错误信息 | 7242| -------- | ---------------- | 7243| 401 | Parameter error. | 7244 7245**示例：** 7246 7247```ts 7248import socket from "@ohos.net.socket"; 7249import { BusinessError } from '@ohos.base'; 7250let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7251let tlsConnectOptions: socket.TLSConnectOptions = { 7252 address: { 7253 address: '192.168.xx.xxx', 7254 port: 8080 7255 }, 7256 secureOptions: { 7257 key: "xxxx", 7258 cert: "xxxx", 7259 ca: ["xxxx"], 7260 password: "xxxx", 7261 protocols: socket.Protocol.TLSv12, 7262 useRemoteCipherPrefer: true, 7263 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7264 cipherSuite: "AES256-SHA256" 7265 }, 7266 ALPNProtocols: ["spdy/1", "http/1.1"] 7267} 7268tlsServer.listen(tlsConnectOptions).then(() => { 7269 console.log("listen callback success"); 7270}).catch((err: BusinessError) => { 7271 console.log("failed: " + JSON.stringify(err)); 7272}); 7273tlsServer.on('error', (err: BusinessError) => { 7274 console.log("on error, err:" + JSON.stringify(err)) 7275}); 7276``` 7277 7278### off('error')<sup>10+</sup> 7279 7280off(type: 'error', callback?: ErrorCallback): void 7281 7282取消订阅TLSSocketServer连接的error事件。使用callback方式作为异步方法。 7283 7284> **说明：** 7285> listen方法调用成功后，才可调用此方法。 7286> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 7287 7288**系统能力**：SystemCapability.Communication.NetStack 7289 7290**参数：** 7291 7292| 参数名 | 类型 | 必填 | 说明 | 7293| -------- | ------------- | ---- | ------------------------------------ | 7294| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 7295| callback | ErrorCallback | 否 | 回调函数。 | 7296 7297**错误码：** 7298 7299| 错误码ID | 错误信息 | 7300| -------- | ---------------- | 7301| 401 | Parameter error. | 7302 7303**示例：** 7304 7305```ts 7306import socket from "@ohos.net.socket"; 7307import { BusinessError } from '@ohos.base'; 7308let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7309let tlsConnectOptions: socket.TLSConnectOptions = { 7310 address: { 7311 address: '192.168.xx.xxx', 7312 port: 8080 7313 }, 7314 secureOptions: { 7315 key: "xxxx", 7316 cert: "xxxx", 7317 ca: ["xxxx"], 7318 password: "xxxx", 7319 protocols: socket.Protocol.TLSv12, 7320 useRemoteCipherPrefer: true, 7321 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7322 cipherSuite: "AES256-SHA256" 7323 }, 7324 ALPNProtocols: ["spdy/1", "http/1.1"] 7325} 7326tlsServer.listen(tlsConnectOptions).then(() => { 7327 console.log("listen callback success"); 7328}).catch((err: BusinessError) => { 7329 console.log("failed: " + JSON.stringify(err)); 7330}); 7331 7332let callback = (err: BusinessError) => { 7333 console.log("on error, err:" + JSON.stringify(err)); 7334} 7335tlsServer.on('error', callback); 7336// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 7337tlsServer.off('error', callback); 7338tlsServer.off('error'); 7339``` 7340 7341## TLSSocketConnection<sup>10+</sup> 7342 7343TLSSocketConnection连接，即TLSSocket客户端与服务端的连接。在调用TLSSocketConnection的方法前，需要先获取TLSSocketConnection对象。 7344 7345> **说明：** 7346> 客户端与服务端成功建立连接后，才能通过返回的TLSSocketConnection对象调用相应的接口。 7347 7348**系统能力**：SystemCapability.Communication.NetStack 7349 7350### 属性 7351 7352| 名称 | 类型 | 必填 | 说明 | 7353| -------- | ------ | ---- | ------------------------------------- | 7354| clientId | number | 是 | 客户端与TLSSocketServer建立连接的id。 | 7355 7356### send<sup>10+</sup> 7357 7358send(data: string, callback: AsyncCallback\<void\>): void 7359 7360在TLSSocketServer通信连接成功之后，向客户端发送消息，使用callback方式作为异步方法。 7361 7362**系统能力**：SystemCapability.Communication.NetStack 7363 7364**参数：** 7365 7366| 参数名 | 类型 | 必填 | 说明 | 7367| -------- | --------------------- | ---- | ------------------------------------------------ | 7368| data | string | 是 | TLSSocketServer发送数据所需要的参数。 | 7369| callback | AsyncCallback\<void\> | 是 | 回调函数，成功返回空，失败返回错误码，错误信息。 | 7370 7371**错误码：** 7372 7373| 错误码ID | 错误信息 | 7374| -------- | -------------------------------------- | 7375| 401 | Parameter error. | 7376| 2303501 | SSL is null. | 7377| 2303503 | Error in tls writing. | 7378| 2303505 | Error occurred in the tls system call. | 7379| 2303506 | Error clearing tls connection. | 7380| 2300002 | System internal error. | 7381 7382**示例：** 7383 7384```ts 7385import socket from "@ohos.net.socket"; 7386import { BusinessError } from '@ohos.base'; 7387let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7388let tlsConnectOptions: socket.TLSConnectOptions = { 7389 address: { 7390 address: '192.168.xx.xxx', 7391 port: 8080 7392 }, 7393 secureOptions: { 7394 key: "xxxx", 7395 cert: "xxxx", 7396 ca: ["xxxx"], 7397 password: "xxxx", 7398 protocols: socket.Protocol.TLSv12, 7399 useRemoteCipherPrefer: true, 7400 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7401 cipherSuite: "AES256-SHA256" 7402 }, 7403 ALPNProtocols: ["spdy/1", "http/1.1"] 7404} 7405tlsServer.listen(tlsConnectOptions).then(() => { 7406 console.log("listen callback success"); 7407}).catch((err: BusinessError) => { 7408 console.log("failed" + err); 7409}); 7410 7411tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7412 client.send('Hello, client!', (err: BusinessError) => { 7413 if (err) { 7414 console.log('send fail'); 7415 return; 7416 } 7417 console.log('send success'); 7418 }); 7419}); 7420``` 7421 7422### send<sup>10+</sup> 7423 7424send(data: string): Promise\<void\> 7425 7426在TLSSocketServer通信连接成功之后，向服务端发送消息，使用Promise方式作为异步方法。 7427 7428**系统能力**：SystemCapability.Communication.NetStack 7429 7430**参数：** 7431 7432| 参数名 | 类型 | 必填 | 说明 | 7433| ------ | ------ | ---- | ------------------------------------- | 7434| data | string | 是 | TLSSocketServer发送数据所需要的参数。 | 7435 7436**返回值：** 7437 7438| 类型 | 说明 | 7439| --------------- | --------------------------------------------------------- | 7440| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码，错误信息。 | 7441 7442**错误码：** 7443 7444| 错误码ID | 错误信息 | 7445| -------- | -------------------------------------- | 7446| 401 | Parameter error. | 7447| 2303501 | SSL is null. | 7448| 2303503 | Error in tls writing. | 7449| 2303505 | Error occurred in the tls system call. | 7450| 2303506 | Error clearing tls connection. | 7451| 2300002 | System internal error. | 7452 7453**示例：** 7454 7455```ts 7456import socket from "@ohos.net.socket"; 7457import { BusinessError } from '@ohos.base'; 7458let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7459let tlsConnectOptions: socket.TLSConnectOptions = { 7460 address: { 7461 address: '192.168.xx.xxx', 7462 port: 8080 7463 }, 7464 secureOptions: { 7465 key: "xxxx", 7466 cert: "xxxx", 7467 ca: ["xxxx"], 7468 password: "xxxx", 7469 protocols: socket.Protocol.TLSv12, 7470 useRemoteCipherPrefer: true, 7471 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7472 cipherSuite: "AES256-SHA256" 7473 }, 7474 ALPNProtocols: ["spdy/1", "http/1.1"] 7475} 7476tlsServer.listen(tlsConnectOptions).then(() => { 7477 console.log("listen callback success"); 7478}).catch((err: BusinessError) => { 7479 console.log("failed" + err); 7480}); 7481 7482tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7483 client.send('Hello, client!').then(() => { 7484 console.log('send success'); 7485 }).catch((err: BusinessError) => { 7486 console.log('send fail'); 7487 }); 7488}); 7489``` 7490 7491### close<sup>10+</sup> 7492 7493close(callback: AsyncCallback\<void\>): void 7494 7495在与TLSSocketServer通信连接成功之后，断开连接，使用callback方式作为异步方法。 7496 7497**系统能力**：SystemCapability.Communication.NetStack 7498 7499**参数：** 7500 7501| 参数名 | 类型 | 必填 | 说明 | 7502| -------- | --------------------- | ---- | ------------------------------------------------ | 7503| callback | AsyncCallback\<void\> | 是 | 回调函数，成功返回空，失败返回错误码，错误信息。 | 7504 7505**错误码：** 7506 7507| 错误码ID | 错误信息 | 7508| -------- | -------------------------------------- | 7509| 401 | Parameter error. | 7510| 2303501 | SSL is null. | 7511| 2303505 | Error occurred in the tls system call. | 7512| 2303506 | Error clearing tls connection. | 7513| 2300002 | System internal error. | 7514 7515**示例：** 7516 7517```ts 7518import socket from "@ohos.net.socket"; 7519import { BusinessError } from '@ohos.base'; 7520let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7521let tlsConnectOptions: socket.TLSConnectOptions = { 7522 address: { 7523 address: '192.168.xx.xxx', 7524 port: 8080 7525 }, 7526 secureOptions: { 7527 key: "xxxx", 7528 cert: "xxxx", 7529 ca: ["xxxx"], 7530 password: "xxxx", 7531 protocols: socket.Protocol.TLSv12, 7532 useRemoteCipherPrefer: true, 7533 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7534 cipherSuite: "AES256-SHA256" 7535 }, 7536 ALPNProtocols: ["spdy/1", "http/1.1"] 7537} 7538tlsServer.listen(tlsConnectOptions).then(() => { 7539 console.log("listen callback success"); 7540}).catch((err: BusinessError) => { 7541 console.log("failed" + err); 7542}); 7543 7544tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7545 client.close((err: BusinessError) => { 7546 if (err) { 7547 console.log('close fail'); 7548 return; 7549 } 7550 console.log('close success'); 7551 }); 7552}); 7553``` 7554 7555### close<sup>10+</sup> 7556 7557close(): Promise\<void\> 7558 7559在与TLSSocketServer通信连接成功之后，断开连接，使用Promise方式作为异步方法。 7560 7561**系统能力**：SystemCapability.Communication.NetStack 7562 7563**返回值：** 7564 7565| 类型 | 说明 | 7566| --------------- | --------------------------------------------------------- | 7567| Promise\<void\> | 以Promise形式返回，成功返回空。失败返回错误码，错误信息。 | 7568 7569**错误码：** 7570 7571| 错误码ID | 错误信息 | 7572| -------- | -------------------------------------- | 7573| 2303501 | SSL is null. | 7574| 2303505 | Error occurred in the tls system call. | 7575| 2303506 | Error clearing tls connection. | 7576| 2300002 | System internal error. | 7577 7578**示例：** 7579 7580```ts 7581import socket from "@ohos.net.socket"; 7582import { BusinessError } from '@ohos.base'; 7583let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7584let tlsConnectOptions: socket.TLSConnectOptions = { 7585 address: { 7586 address: '192.168.xx.xxx', 7587 port: 8080 7588 }, 7589 secureOptions: { 7590 key: "xxxx", 7591 cert: "xxxx", 7592 ca: ["xxxx"], 7593 password: "xxxx", 7594 protocols: socket.Protocol.TLSv12, 7595 useRemoteCipherPrefer: true, 7596 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7597 cipherSuite: "AES256-SHA256" 7598 }, 7599 ALPNProtocols: ["spdy/1", "http/1.1"] 7600} 7601tlsServer.listen(tlsConnectOptions).then(() => { 7602 console.log("listen callback success"); 7603}).catch((err: BusinessError) => { 7604 console.log("failed" + err); 7605}); 7606tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7607 client.close().then(() => { 7608 console.log('close success'); 7609 }).catch((err: BusinessError) => { 7610 console.log('close fail'); 7611 }); 7612}); 7613``` 7614 7615### getRemoteAddress<sup>10+</sup> 7616 7617getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void 7618 7619在TLSSocketServer通信连接成功之后，获取对端Socket地址。使用callback方式作为异步方法。 7620 7621**系统能力**：SystemCapability.Communication.NetStack 7622 7623**参数：** 7624 7625| 参数名 | 类型 | 必填 | 说明 | 7626| -------- | ------------------------------------------- | ---- | ------------------------------------------------------------ | 7627| callback | AsyncCallback\<[NetAddress](#netaddress)\> | 是 | 回调函数。成功返回对端的socket地址，失败返回错误码，错误信息。 | 7628 7629**错误码：** 7630 7631| 错误码ID | 错误信息 | 7632| -------- | ------------------------------- | 7633| 401 | Parameter error. | 7634| 2303188 | Socket operation on non-socket. | 7635| 2300002 | System internal error. | 7636 7637**示例：** 7638 7639```ts 7640import socket from "@ohos.net.socket"; 7641import { BusinessError } from '@ohos.base'; 7642let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7643let tlsConnectOptions: socket.TLSConnectOptions = { 7644 address: { 7645 address: '192.168.xx.xxx', 7646 port: 8080 7647 }, 7648 secureOptions: { 7649 key: "xxxx", 7650 cert: "xxxx", 7651 ca: ["xxxx"], 7652 password: "xxxx", 7653 protocols: socket.Protocol.TLSv12, 7654 useRemoteCipherPrefer: true, 7655 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7656 cipherSuite: "AES256-SHA256" 7657 }, 7658 ALPNProtocols: ["spdy/1", "http/1.1"] 7659} 7660tlsServer.listen(tlsConnectOptions).then(() => { 7661 console.log("listen callback success"); 7662}).catch((err: BusinessError) => { 7663 console.log("failed" + err); 7664}); 7665tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7666 client.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => { 7667 if (err) { 7668 console.log('getRemoteAddress fail'); 7669 return; 7670 } 7671 console.log('getRemoteAddress success:' + JSON.stringify(data)); 7672 }); 7673}); 7674``` 7675 7676### getRemoteAddress<sup>10+</sup> 7677 7678getRemoteAddress(): Promise\<NetAddress\> 7679 7680在TLSSocketServer通信连接成功之后，获取对端Socket地址。使用Promise方式作为异步方法。 7681 7682**系统能力**：SystemCapability.Communication.NetStack 7683 7684**返回值：** 7685 7686| 类型 | 说明 | 7687| ----------------------------------- | ----------------------------------------------------------- | 7688| Promise\<[NetAddress](#netaddress)> | 以Promise形式返回获取对端socket地址的结果。失败返回错误码，错误信息。 | 7689 7690**错误码：** 7691 7692| 错误码ID | 错误信息 | 7693| -------- | ------------------------------- | 7694| 2303188 | Socket operation on non-socket. | 7695| 2300002 | System internal error. | 7696 7697**示例：** 7698 7699```ts 7700import socket from "@ohos.net.socket"; 7701import { BusinessError } from '@ohos.base'; 7702let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7703let tlsConnectOptions: socket.TLSConnectOptions = { 7704 address: { 7705 address: '192.168.xx.xxx', 7706 port: 8080 7707 }, 7708 secureOptions: { 7709 key: "xxxx", 7710 cert: "xxxx", 7711 ca: ["xxxx"], 7712 password: "xxxx", 7713 protocols: socket.Protocol.TLSv12, 7714 useRemoteCipherPrefer: true, 7715 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7716 cipherSuite: "AES256-SHA256" 7717 }, 7718 ALPNProtocols: ["spdy/1", "http/1.1"] 7719} 7720tlsServer.listen(tlsConnectOptions).then(() => { 7721 console.log("listen callback success"); 7722}).catch((err: BusinessError) => { 7723 console.log("failed" + err); 7724}); 7725tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7726 client.getRemoteAddress().then((data: socket.NetAddress) => { 7727 console.log('getRemoteAddress success:' + JSON.stringify(data)); 7728 }).catch((err: BusinessError) => { 7729 console.error("failed" + err); 7730 }); 7731}); 7732``` 7733 7734### getRemoteCertificate<sup>10+</sup> 7735 7736getRemoteCertificate(callback: AsyncCallback\<[X509CertRawData](#x509certrawdata9)\>): void 7737 7738在TLSSocketServer通信连接成功之后，获取对端的数字证书，该接口只适用于客户端向服务端发送证书时，使用callback方式作为异步方法。 7739 7740**系统能力**：SystemCapability.Communication.NetStack 7741 7742**参数：** 7743 7744| 参数名 | 类型 | 必填 | 说明 | 7745| -------- | ----------------------------------------------------- | ---- | ---------------------------------------------------- | 7746| callback | AsyncCallback\<[X509CertRawData](#x509certrawdata9)\> | 是 | 回调函数，返回对端的证书。失败返回错误码，错误信息。 | 7747 7748**错误码：** 7749 7750| 错误码ID | 错误信息 | 7751| -------- | ---------------------- | 7752| 401 | Parameter error. | 7753| 2303501 | SSL is null. | 7754| 2300002 | System internal error. | 7755 7756**示例：** 7757 7758```ts 7759import socket from "@ohos.net.socket"; 7760import { BusinessError } from '@ohos.base'; 7761import util from "@ohos.util"; 7762 7763let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7764let tlsConnectOptions: socket.TLSConnectOptions = { 7765 address: { 7766 address: '192.168.xx.xxx', 7767 port: 8080 7768 }, 7769 secureOptions: { 7770 key: "xxxx", 7771 cert: "xxxx", 7772 ca: ["xxxx"], 7773 password: "xxxx", 7774 protocols: socket.Protocol.TLSv12, 7775 useRemoteCipherPrefer: true, 7776 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7777 cipherSuite: "AES256-SHA256" 7778 }, 7779 ALPNProtocols: ["spdy/1", "http/1.1"] 7780} 7781tlsServer.listen(tlsConnectOptions).then(() => { 7782 console.log("listen callback success"); 7783}).catch((err: BusinessError) => { 7784 console.log("failed" + err); 7785}); 7786tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7787 client.getRemoteCertificate((err: BusinessError, data: socket.X509CertRawData) => { 7788 if (err) { 7789 console.log("getRemoteCertificate callback error: " + err); 7790 } else { 7791 const decoder = util.TextDecoder.create(); 7792 const str = decoder.decodeWithStream(data.data); 7793 console.log("getRemoteCertificate callback: " + str); 7794 } 7795 }); 7796}); 7797``` 7798 7799### getRemoteCertificate<sup>10+</sup> 7800 7801getRemoteCertificate():Promise\<[X509CertRawData](#x509certrawdata9)\> 7802 7803在TLSSocketServer通信连接成功之后，获取对端的数字证书，该接口只适用于客户端向服务端发送证书时，使用Promise方式作为异步方法。 7804 7805**系统能力**：SystemCapability.Communication.NetStack 7806 7807**返回值：** 7808 7809| 类型 | 说明 | 7810| ----------------------------------------------- | ------------------------------------------------------------ | 7811| Promise\<[X509CertRawData](#x509certrawdata9)\> | 以Promise形式返回对端的数字证书的结果。失败返回错误码，错误信息。 | 7812 7813**错误码：** 7814 7815| 错误码ID | 错误信息 | 7816| -------- | ---------------------- | 7817| 2303501 | SSL is null. | 7818| 2300002 | System internal error. | 7819 7820**示例：** 7821 7822```ts 7823import socket from "@ohos.net.socket"; 7824import { BusinessError } from '@ohos.base'; 7825import util from "@ohos.util"; 7826 7827let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7828let tlsConnectOptions: socket.TLSConnectOptions = { 7829 address: { 7830 address: '192.168.xx.xxx', 7831 port: 8080 7832 }, 7833 secureOptions: { 7834 key: "xxxx", 7835 cert: "xxxx", 7836 ca: ["xxxx"], 7837 password: "xxxx", 7838 protocols: socket.Protocol.TLSv12, 7839 useRemoteCipherPrefer: true, 7840 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7841 cipherSuite: "AES256-SHA256" 7842 }, 7843 ALPNProtocols: ["spdy/1", "http/1.1"] 7844} 7845tlsServer.listen(tlsConnectOptions).then(() => { 7846 console.log("listen callback success"); 7847}).catch((err: BusinessError) => { 7848 console.log("failed" + err); 7849}); 7850tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7851 client.getRemoteCertificate().then((data: socket.X509CertRawData) => { 7852 const decoder = util.TextDecoder.create(); 7853 const str = decoder.decodeWithStream(data.data); 7854 console.log("getRemoteCertificate success: " + str); 7855 }).catch((err: BusinessError) => { 7856 console.error("failed" + err); 7857 }); 7858}); 7859``` 7860 7861### getCipherSuite<sup>10+</sup> 7862 7863getCipherSuite(callback: AsyncCallback\<Array\<string\>\>): void 7864 7865在TLSSocketServer通信连接成功之后，获取通信双方协商后的加密套件，使用callback方式作为异步方法。 7866 7867**系统能力**：SystemCapability.Communication.NetStack 7868 7869**参数：** 7870 7871| 参数名 | 类型 | 必填 | 说明 | 7872| -------- | -------------------------------- | ---- | ------------------------------------------------------------ | 7873| callback | AsyncCallback\<Array\<string\>\> | 是 | 回调函数，返回通信双方支持的加密套件。 失败返回错误码，错误信息。 | 7874 7875**错误码：** 7876 7877| 错误码ID | 错误信息 | 7878| -------- | -------------------------------------- | 7879| 401 | Parameter error. | 7880| 2303501 | SSL is null. | 7881| 2303502 | Error in tls reading. | 7882| 2303505 | Error occurred in the tls system call. | 7883| 2300002 | System internal error. | 7884 7885**示例：** 7886 7887```ts 7888import socket from "@ohos.net.socket"; 7889import { BusinessError } from '@ohos.base'; 7890let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7891let tlsConnectOptions: socket.TLSConnectOptions = { 7892 address: { 7893 address: '192.168.xx.xxx', 7894 port: 8080 7895 }, 7896 secureOptions: { 7897 key: "xxxx", 7898 cert: "xxxx", 7899 ca: ["xxxx"], 7900 password: "xxxx", 7901 protocols: socket.Protocol.TLSv12, 7902 useRemoteCipherPrefer: true, 7903 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7904 cipherSuite: "AES256-SHA256" 7905 }, 7906 ALPNProtocols: ["spdy/1", "http/1.1"] 7907} 7908tlsServer.listen(tlsConnectOptions).then(() => { 7909 console.log("listen callback success"); 7910}).catch((err: BusinessError) => { 7911 console.log("failed" + err); 7912}); 7913tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7914 client.getCipherSuite((err: BusinessError, data: Array<string>) => { 7915 if (err) { 7916 console.log("getCipherSuite callback error = " + err); 7917 } else { 7918 console.log("getCipherSuite callback = " + data); 7919 } 7920 }); 7921}); 7922``` 7923 7924### getCipherSuite<sup>10+</sup> 7925 7926getCipherSuite(): Promise\<Array\<string\>\> 7927 7928在TLSSocketServer通信连接成功之后，获取通信双方协商后的加密套件，使用Promise方式作为异步方法。 7929 7930**系统能力**：SystemCapability.Communication.NetStack 7931 7932**返回值：** 7933 7934| 类型 | 说明 | 7935| -------------------------- | ------------------------------------------------------------ | 7936| Promise\<Array\<string\>\> | 以Promise形式返回通信双方支持的加密套件。失败返回错误码，错误信息。 | 7937 7938**错误码：** 7939 7940| 错误码ID | 错误信息 | 7941| -------- | -------------------------------------- | 7942| 2303501 | SSL is null. | 7943| 2303502 | Error in tls reading. | 7944| 2303505 | Error occurred in the tls system call. | 7945| 2300002 | System internal error. | 7946 7947**示例：** 7948 7949```ts 7950import socket from "@ohos.net.socket"; 7951import { BusinessError } from '@ohos.base'; 7952let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7953let tlsConnectOptions: socket.TLSConnectOptions = { 7954 address: { 7955 address: '192.168.xx.xxx', 7956 port: 8080 7957 }, 7958 secureOptions: { 7959 key: "xxxx", 7960 cert: "xxxx", 7961 ca: ["xxxx"], 7962 password: "xxxx", 7963 protocols: socket.Protocol.TLSv12, 7964 useRemoteCipherPrefer: true, 7965 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7966 cipherSuite: "AES256-SHA256" 7967 }, 7968 ALPNProtocols: ["spdy/1", "http/1.1"] 7969} 7970tlsServer.listen(tlsConnectOptions).then(() => { 7971 console.log("listen callback success"); 7972}).catch((err: BusinessError) => { 7973 console.log("failed" + err); 7974}); 7975tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 7976 client.getCipherSuite().then((data: Array<string>) => { 7977 console.log('getCipherSuite success:' + JSON.stringify(data)); 7978 }).catch((err: BusinessError) => { 7979 console.error("failed" + err); 7980 }); 7981}); 7982``` 7983 7984### getSignatureAlgorithms<sup>10+</sup> 7985 7986getSignatureAlgorithms(callback: AsyncCallback\<Array\<string\>\>): void 7987 7988在TLSSocketServer通信连接成功之后，获取通信双方协商后签名算法，使用callback方式作为异步方法。 7989 7990**系统能力**：SystemCapability.Communication.NetStack 7991 7992**参数：** 7993 7994| 参数名 | 类型 | 必填 | 说明 | 7995| -------- | -------------------------------- | ---- | ---------------------------------- | 7996| callback | AsyncCallback\<Array\<string\>\> | 是 | 回调函数，返回双方支持的签名算法。 | 7997 7998**错误码：** 7999 8000| 错误码ID | 错误信息 | 8001| -------- | ---------------------- | 8002| 401 | Parameter error. | 8003| 2303501 | SSL is null. | 8004| 2300002 | System internal error. | 8005 8006**示例：** 8007 8008```ts 8009import socket from "@ohos.net.socket"; 8010import { BusinessError } from '@ohos.base'; 8011let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8012let tlsConnectOptions: socket.TLSConnectOptions = { 8013 address: { 8014 address: '192.168.xx.xxx', 8015 port: 8080 8016 }, 8017 secureOptions: { 8018 key: "xxxx", 8019 cert: "xxxx", 8020 ca: ["xxxx"], 8021 password: "xxxx", 8022 protocols: socket.Protocol.TLSv12, 8023 useRemoteCipherPrefer: true, 8024 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8025 cipherSuite: "AES256-SHA256" 8026 }, 8027 ALPNProtocols: ["spdy/1", "http/1.1"] 8028} 8029tlsServer.listen(tlsConnectOptions).then(() => { 8030 console.log("listen callback success"); 8031}).catch((err: BusinessError) => { 8032 console.log("failed" + err); 8033}); 8034tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8035 client.getSignatureAlgorithms((err: BusinessError, data: Array<string>) => { 8036 if (err) { 8037 console.log("getSignatureAlgorithms callback error = " + err); 8038 } else { 8039 console.log("getSignatureAlgorithms callback = " + data); 8040 } 8041 }); 8042}); 8043``` 8044 8045### getSignatureAlgorithms<sup>10+</sup> 8046 8047getSignatureAlgorithms(): Promise\<Array\<string\>\> 8048 8049在TLSSocketServer通信连接成功之后，获取通信双方协商后的签名算法，使用Promise方式作为异步方法。 8050 8051**系统能力**：SystemCapability.Communication.NetStack 8052 8053**返回值：** 8054 8055| 类型 | 说明 | 8056| -------------------------- | --------------------------------------------- | 8057| Promise\<Array\<string\>\> | 以Promise形式返回获取到的双方支持的签名算法。 | 8058 8059**错误码：** 8060 8061| 错误码ID | 错误信息 | 8062| -------- | ---------------------- | 8063| 2303501 | SSL is null. | 8064| 2300002 | System internal error. | 8065 8066**示例：** 8067 8068```ts 8069import socket from "@ohos.net.socket"; 8070import { BusinessError } from '@ohos.base'; 8071let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8072let tlsConnectOptions: socket.TLSConnectOptions = { 8073 address: { 8074 address: '192.168.xx.xxx', 8075 port: 8080 8076 }, 8077 secureOptions: { 8078 key: "xxxx", 8079 cert: "xxxx", 8080 ca: ["xxxx"], 8081 password: "xxxx", 8082 protocols: socket.Protocol.TLSv12, 8083 useRemoteCipherPrefer: true, 8084 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8085 cipherSuite: "AES256-SHA256" 8086 }, 8087 ALPNProtocols: ["spdy/1", "http/1.1"] 8088} 8089tlsServer.listen(tlsConnectOptions).then(() => { 8090 console.log("listen callback success"); 8091}).catch((err: BusinessError) => { 8092 console.log("failed" + err); 8093}); 8094tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8095 client.getSignatureAlgorithms().then((data: Array<string>) => { 8096 console.log("getSignatureAlgorithms success" + data); 8097 }).catch((err: BusinessError) => { 8098 console.error("failed" + err); 8099 }); 8100}); 8101``` 8102 8103### on('message')<sup>10+</sup> 8104 8105on(type: 'message', callback: Callback\<SocketMessageInfo\>): void 8106 8107订阅TLSSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 8108 8109**系统能力**：SystemCapability.Communication.NetStack 8110 8111**参数：** 8112 8113| 参数名 | 类型 | 必填 | 说明 | 8114| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 8115| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 8116| callback | Callback<[SocketMessageInfo](#socketmessageinfo11)> | 是 | 回调函数。 | 8117 8118**错误码：** 8119 8120| 错误码ID | 错误信息 | 8121| -------- | ---------------- | 8122| 401 | Parameter error. | 8123 8124**示例：** 8125 8126```ts 8127import socket from "@ohos.net.socket"; 8128import { BusinessError } from '@ohos.base'; 8129let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8130let tlsConnectOptions: socket.TLSConnectOptions = { 8131 address: { 8132 address: '192.168.xx.xxx', 8133 port: 8080 8134 }, 8135 secureOptions: { 8136 key: "xxxx", 8137 cert: "xxxx", 8138 ca: ["xxxx"], 8139 password: "xxxx", 8140 protocols: socket.Protocol.TLSv12, 8141 useRemoteCipherPrefer: true, 8142 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8143 cipherSuite: "AES256-SHA256" 8144 }, 8145 ALPNProtocols: ["spdy/1", "http/1.1"] 8146} 8147tlsServer.listen(tlsConnectOptions).then(() => { 8148 console.log("listen callback success"); 8149}).catch((err: BusinessError) => { 8150 console.log("failed" + err); 8151}); 8152 8153tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8154 client.on('message', (value: socket.SocketMessageInfo) => { 8155 let messageView = ''; 8156 for (let i: number = 0; i < value.message.byteLength; i++) { 8157 let uint8Array = new Uint8Array(value.message) 8158 let messages = uint8Array[i] 8159 let message = String.fromCharCode(messages); 8160 messageView += message; 8161 } 8162 console.log('on message message: ' + JSON.stringify(messageView)); 8163 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 8164 }); 8165}); 8166``` 8167 8168### off('message')<sup>10+</sup> 8169 8170off(type: 'message', callback?: Callback\<SocketMessageInfo\>): void 8171 8172取消订阅TLSSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 8173 8174> **说明：** 8175> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 8176 8177**系统能力**：SystemCapability.Communication.NetStack 8178 8179**参数：** 8180 8181| 参数名 | 类型 | 必填 | 说明 | 8182| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 8183| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 8184| callback | Callback<[SocketMessageInfo](#socketmessageinfo11)> | 否 | 回调函数。 | 8185 8186**错误码：** 8187 8188| 错误码ID | 错误信息 | 8189| -------- | ---------------- | 8190| 401 | Parameter error. | 8191 8192**示例：** 8193 8194```ts 8195import socket from "@ohos.net.socket"; 8196import { BusinessError } from '@ohos.base'; 8197let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8198let tlsConnectOptions: socket.TLSConnectOptions = { 8199 address: { 8200 address: '192.168.xx.xxx', 8201 port: 8080 8202 }, 8203 secureOptions: { 8204 key: "xxxx", 8205 cert: "xxxx", 8206 ca: ["xxxx"], 8207 password: "xxxx", 8208 protocols: socket.Protocol.TLSv12, 8209 useRemoteCipherPrefer: true, 8210 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8211 cipherSuite: "AES256-SHA256" 8212 }, 8213 ALPNProtocols: ["spdy/1", "http/1.1"] 8214} 8215tlsServer.listen(tlsConnectOptions).then(() => { 8216 console.log("listen callback success"); 8217}).catch((err: BusinessError) => { 8218 console.log("failed" + err); 8219}); 8220 8221let callback = (value: socket.SocketMessageInfo) => { 8222 let messageView = ''; 8223 for (let i: number = 0; i < value.message.byteLength; i++) { 8224 let uint8Array = new Uint8Array(value.message) 8225 let messages = uint8Array[i] 8226 let message = String.fromCharCode(messages); 8227 messageView += message; 8228 } 8229 console.log('on message message: ' + JSON.stringify(messageView)); 8230 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 8231} 8232tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8233 client.on('message', callback); 8234 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 8235 client.off('message', callback); 8236 client.off('message'); 8237}); 8238``` 8239 8240### on('close')<sup>10+</sup> 8241 8242on(type: 'close', callback: Callback\<void\>): void 8243 8244订阅TLSSocketConnection的关闭事件。使用callback方式作为异步方法。 8245 8246**系统能力**：SystemCapability.Communication.NetStack 8247 8248**参数：** 8249 8250| 参数名 | 类型 | 必填 | 说明 | 8251| -------- | ---------------- | ---- | ----------------------------------- | 8252| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 8253| callback | Callback\<void\> | 是 | 回调函数。 | 8254 8255**错误码：** 8256 8257| 错误码ID | 错误信息 | 8258| -------- | ---------------- | 8259| 401 | Parameter error. | 8260 8261**示例：** 8262 8263```ts 8264import socket from "@ohos.net.socket"; 8265import { BusinessError } from '@ohos.base'; 8266let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8267let tlsConnectOptions: socket.TLSConnectOptions = { 8268 address: { 8269 address: '192.168.xx.xxx', 8270 port: 8080 8271 }, 8272 secureOptions: { 8273 key: "xxxx", 8274 cert: "xxxx", 8275 ca: ["xxxx"], 8276 password: "xxxx", 8277 protocols: socket.Protocol.TLSv12, 8278 useRemoteCipherPrefer: true, 8279 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8280 cipherSuite: "AES256-SHA256" 8281 }, 8282 ALPNProtocols: ["spdy/1", "http/1.1"] 8283} 8284tlsServer.listen(tlsConnectOptions).then(() => { 8285 console.log("listen callback success"); 8286}).catch((err: BusinessError) => { 8287 console.log("failed" + err); 8288}); 8289tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8290 client.on('close', () => { 8291 console.log("on close success") 8292 }); 8293}); 8294``` 8295 8296### off('close')<sup>10+</sup> 8297 8298off(type: 'close', callback?: Callback\<void\>): void 8299 8300取消订阅TLSSocketConnection的关闭事件。使用callback方式作为异步方法。 8301 8302> **说明：** 8303> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 8304 8305**系统能力**：SystemCapability.Communication.NetStack 8306 8307**参数：** 8308 8309| 参数名 | 类型 | 必填 | 说明 | 8310| -------- | ---------------- | ---- | ----------------------------------- | 8311| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 8312| callback | Callback\<void\> | 否 | 回调函数。 | 8313 8314**错误码：** 8315 8316| 错误码ID | 错误信息 | 8317| -------- | ---------------- | 8318| 401 | Parameter error. | 8319 8320**示例：** 8321 8322```ts 8323import socket from "@ohos.net.socket"; 8324import { BusinessError } from '@ohos.base'; 8325let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8326let tlsConnectOptions: socket.TLSConnectOptions = { 8327 address: { 8328 address: '192.168.xx.xxx', 8329 port: 8080 8330 }, 8331 secureOptions: { 8332 key: "xxxx", 8333 cert: "xxxx", 8334 ca: ["xxxx"], 8335 password: "xxxx", 8336 protocols: socket.Protocol.TLSv12, 8337 useRemoteCipherPrefer: true, 8338 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8339 cipherSuite: "AES256-SHA256" 8340 }, 8341 ALPNProtocols: ["spdy/1", "http/1.1"] 8342} 8343tlsServer.listen(tlsConnectOptions).then(() => { 8344 console.log("listen callback success"); 8345}).catch((err: BusinessError) => { 8346 console.log("failed" + err); 8347}); 8348 8349let callback = () => { 8350 console.log("on close success"); 8351} 8352tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8353 client.on('close', callback); 8354 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 8355 client.off('close', callback); 8356 client.off('close'); 8357}); 8358``` 8359 8360### on('error')<sup>10+</sup> 8361 8362on(type: 'error', callback: ErrorCallback): void 8363 8364订阅TLSSocketConnection连接的error事件。使用callback方式作为异步方法。 8365 8366**系统能力**：SystemCapability.Communication.NetStack 8367 8368**参数：** 8369 8370| 参数名 | 类型 | 必填 | 说明 | 8371| -------- | ------------- | ---- | ------------------------------------ | 8372| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 8373| callback | ErrorCallback | 是 | 回调函数。 | 8374 8375**错误码：** 8376 8377| 错误码ID | 错误信息 | 8378| -------- | ---------------- | 8379| 401 | Parameter error. | 8380 8381**示例：** 8382 8383```ts 8384import socket from "@ohos.net.socket"; 8385import { BusinessError } from '@ohos.base'; 8386let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8387let tlsConnectOptions: socket.TLSConnectOptions = { 8388 address: { 8389 address: '192.168.xx.xxx', 8390 port: 8080 8391 }, 8392 secureOptions: { 8393 key: "xxxx", 8394 cert: "xxxx", 8395 ca: ["xxxx"], 8396 password: "xxxx", 8397 protocols: socket.Protocol.TLSv12, 8398 useRemoteCipherPrefer: true, 8399 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8400 cipherSuite: "AES256-SHA256" 8401 }, 8402 ALPNProtocols: ["spdy/1", "http/1.1"] 8403} 8404tlsServer.listen(tlsConnectOptions).then(() => { 8405 console.log("listen callback success"); 8406}).catch((err: BusinessError) => { 8407 console.log("failed" + err); 8408}); 8409 8410tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8411 client.on('error', (err: BusinessError) => { 8412 console.log("on error, err:" + JSON.stringify(err)) 8413 }); 8414}); 8415``` 8416 8417### off('error')<sup>10+</sup> 8418 8419off(type: 'error', callback?: ErrorCallback): void 8420 8421取消订阅TLSSocketConnection连接的error事件。使用callback方式作为异步方法。 8422 8423> **说明：** 8424> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 8425 8426**系统能力**：SystemCapability.Communication.NetStack 8427 8428**参数：** 8429 8430| 参数名 | 类型 | 必填 | 说明 | 8431| -------- | ------------- | ---- | ------------------------------------ | 8432| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 8433| callback | ErrorCallback | 否 | 回调函数。 | 8434 8435**错误码：** 8436 8437| 错误码ID | 错误信息 | 8438| -------- | ---------------- | 8439| 401 | Parameter error. | 8440 8441**示例：** 8442 8443```ts 8444import socket from "@ohos.net.socket"; 8445import { BusinessError } from '@ohos.base'; 8446let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8447let tlsConnectOptions: socket.TLSConnectOptions = { 8448 address: { 8449 address: '192.168.xx.xxx', 8450 port: 8080 8451 }, 8452 secureOptions: { 8453 key: "xxxx", 8454 cert: "xxxx", 8455 ca: ["xxxx"], 8456 password: "xxxx", 8457 protocols: socket.Protocol.TLSv12, 8458 useRemoteCipherPrefer: true, 8459 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8460 cipherSuite: "AES256-SHA256" 8461 }, 8462 ALPNProtocols: ["spdy/1", "http/1.1"] 8463} 8464tlsServer.listen(tlsConnectOptions).then(() => { 8465 console.log("listen callback success"); 8466}).catch((err: BusinessError) => { 8467 console.log("failed" + err); 8468}); 8469 8470let callback = (err: BusinessError) => { 8471 console.log("on error, err:" + JSON.stringify(err)); 8472} 8473tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8474 client.on('error', callback); 8475 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 8476 client.off('error', callback); 8477 client.off('error'); 8478}); 8479``` 8480