1# @ohos.net.socket (Socket连接) 2 3本模块提供利用Socket进行数据传输的能力，支持TCPSocket、UDPSocket、WebSocket和TLSSocket。 4 5> **说明：** 6> 7> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 8> 本模块API使用时建议放在worker线程或者taskpool中做网络操作，否则可能会导致UI线程卡顿。 9 10## 导入模块 11 12```ts 13import { socket } from '@kit.NetworkKit'; 14``` 15 16## socket.constructUDPSocketInstance 17 18constructUDPSocketInstance(): UDPSocket 19 20创建一个UDPSocket对象。 21 22**系统能力**：SystemCapability.Communication.NetStack 23 24**返回值：** 25 26| 类型 | 说明 | 27| --------------------------------- | ---------------------- | 28| [UDPSocket](#udpsocket) | 返回一个UDPSocket对象。 | 29 30**示例：** 31 32```ts 33import { socket } from '@kit.NetworkKit'; 34let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 35``` 36 37## UDPSocket 38 39UDPSocket连接。在调用UDPSocket的方法前，需要先通过[socket.constructUDPSocketInstance](#socketconstructudpsocketinstance)创建UDPSocket对象。 40 41### bind 42 43bind(address: NetAddress, callback: AsyncCallback\<void\>): void 44 45绑定IP地址和端口，端口可以指定或由系统随机分配。使用callback方式作为异步方法。 46 47**需要权限**：ohos.permission.INTERNET 48 49**系统能力**：SystemCapability.Communication.NetStack 50 51**参数：** 52 53| 参数名 | 类型 | 必填 | 说明 | 54| -------- | ---------------------------------- | ---- | ------------------------------------------------------ | 55| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 56| callback | AsyncCallback\<void\> | 是 | 回调函数。成功返回空，失败返回错误码、错误信息。 | 57 58**错误码：** 59 60| 错误码ID | 错误信息 | 61| ------- | ----------------------- | 62| 401 | Parameter error. | 63| 201 | Permission denied. | 64 65**示例：** 66 67```ts 68import { socket } from '@kit.NetworkKit'; 69import { BusinessError } from '@kit.BasicServicesKit'; 70 71let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 72let bindAddr: socket.NetAddress = { 73 address: '192.168.xx.xxx', 74 port: 1234 75} 76udp.bind(bindAddr, (err: BusinessError) => { 77 if (err) { 78 console.log('bind fail'); 79 return; 80 } 81 console.log('bind success'); 82}); 83``` 84 85### bind 86 87bind(address: NetAddress): Promise\<void\> 88 89绑定IP地址和端口，端口可以指定或由系统随机分配。使用Promise方式作为异步方法。 90 91**需要权限**：ohos.permission.INTERNET 92 93**系统能力**：SystemCapability.Communication.NetStack 94 95**参数：** 96 97| 参数名 | 类型 | 必填 | 说明 | 98| ------- | ---------------------------------- | ---- | ------------------------------------------------------ | 99| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 100 101**错误码：** 102 103| 错误码ID | 错误信息 | 104| ------- | ----------------------- | 105| 401 | Parameter error. | 106| 201 | Permission denied. | 107 108**返回值：** 109 110| 类型 | 说明 | 111| -------------- | ----------------------------------------- | 112| Promise\<void\> | 以Promise形式异步返回UDPSocket绑定的结果。 | 113 114**示例：** 115 116```ts 117import { socket } from '@kit.NetworkKit'; 118import { BusinessError } from '@kit.BasicServicesKit'; 119 120let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 121let bindAddr: socket.NetAddress = { 122 address: '192.168.xx.xxx', 123 port: 8080 124} 125udp.bind(bindAddr).then(() => { 126 console.log('bind success'); 127}).catch((err: BusinessError) => { 128 console.log('bind fail'); 129}); 130``` 131 132### send 133 134send(options: UDPSendOptions, callback: AsyncCallback\<void\>): void 135 136通过UDPSocket连接发送数据。使用callback方式作为异步方法。 137 138发送数据前，需要先调用[UDPSocket.bind()](#bind)绑定IP地址和端口。该接口为耗时操作，请在Worker线程或taskpool线程调用该接口。 139 140**需要权限**：ohos.permission.INTERNET 141 142**系统能力**：SystemCapability.Communication.NetStack 143 144**参数：** 145 146| 参数名 | 类型 | 必填 | 说明 | 147| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 148| options | [UDPSendOptions](#udpsendoptions) | 是 | UDPSocket发送参数，参考[UDPSendOptions](#udpsendoptions)。 | 149| callback | AsyncCallback\<void\> | 是 | 回调函数。成功返回空，失败返回错误码、错误信息。 | 150 151**错误码：** 152 153| 错误码ID | 错误信息 | 154| ------- | ----------------------- | 155| 401 | Parameter error. | 156| 201 | Permission denied. | 157 158**示例：** 159 160```ts 161import { socket } from '@kit.NetworkKit'; 162import { BusinessError } from '@kit.BasicServicesKit'; 163 164let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 165let netAddress: socket.NetAddress = { 166 address: '192.168.xx.xxx', 167 port: 8080 168} 169let sendOptions: socket.UDPSendOptions = { 170 data: 'Hello, server!', 171 address: netAddress 172} 173udp.send(sendOptions, (err: BusinessError) => { 174 if (err) { 175 console.log('send fail'); 176 return; 177 } 178 console.log('send success'); 179}); 180``` 181 182### send 183 184send(options: UDPSendOptions): Promise\<void\> 185 186通过UDPSocket连接发送数据。使用Promise方式作为异步方法。 187 188发送数据前，需要先调用[UDPSocket.bind()](#bind)绑定IP地址和端口。该接口为耗时操作，请在Worker线程或taskpool线程调用该接口。 189 190**需要权限**：ohos.permission.INTERNET 191 192**系统能力**：SystemCapability.Communication.NetStack 193 194**参数：** 195 196| 参数名 | 类型 | 必填 | 说明 | 197| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 198| options | [UDPSendOptions](#udpsendoptions) | 是 | UDPSocket发送参数，参考[UDPSendOptions](#udpsendoptions)。 | 199 200**错误码：** 201 202| 错误码ID | 错误信息 | 203| ------- | ----------------------- | 204| 401 | Parameter error. | 205| 201 | Permission denied. | 206 207**返回值：** 208 209| 类型 | 说明 | 210| -------------- | --------------------------------------------- | 211| Promise\<void\> | 以Promise形式返回UDPSocket连接发送数据的结果。 | 212 213**示例：** 214 215```ts 216import { socket } from '@kit.NetworkKit'; 217import { BusinessError } from '@kit.BasicServicesKit'; 218 219let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 220let netAddress: socket.NetAddress = { 221 address: '192.168.xx.xxx', 222 port: 8080 223} 224let sendOptions: socket.UDPSendOptions = { 225 data: 'Hello, server!', 226 address: netAddress 227} 228udp.send(sendOptions).then(() => { 229 console.log('send success'); 230}).catch((err: BusinessError) => { 231 console.log('send fail'); 232}); 233``` 234 235### close 236 237close(callback: AsyncCallback\<void\>): void 238 239关闭UDPSocket连接。使用callback方式作为异步方法。 240 241**需要权限**：ohos.permission.INTERNET 242 243**系统能力**：SystemCapability.Communication.NetStack 244 245**参数：** 246 247| 参数名 | 类型 | 必填 | 说明 | 248| -------- | --------------------- | ---- | ---------- | 249| callback | AsyncCallback\<void\> | 是 | 回调函数。关闭UDPSocket连接后触发回调函数。 | 250 251**错误码：** 252 253| 错误码ID | 错误信息 | 254| ------- | ----------------------- | 255| 201 | Permission denied. | 256 257**示例：** 258 259```ts 260import { socket } from '@kit.NetworkKit'; 261import { BusinessError } from '@kit.BasicServicesKit'; 262 263let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 264udp.close((err: BusinessError) => { 265 if (err) { 266 console.log('close fail'); 267 return; 268 } 269 console.log('close success'); 270}) 271``` 272 273### close 274 275close(): Promise\<void\> 276 277关闭UDPSocket连接。使用Promise方式作为异步方法。 278 279**需要权限**：ohos.permission.INTERNET 280 281**系统能力**：SystemCapability.Communication.NetStack 282 283**错误码：** 284 285| 错误码ID | 错误信息 | 286| ------- | ----------------------- | 287| 201 | Permission denied. | 288 289**返回值：** 290 291| 类型 | 说明 | 292| -------------- | ----------------------------------------- | 293| Promise\<void\> | 以Promise形式返回关闭UDPSocket连接的结果。 | 294 295**示例：** 296 297```ts 298import { socket } from '@kit.NetworkKit'; 299import { BusinessError } from '@kit.BasicServicesKit'; 300 301let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 302udp.close().then(() => { 303 console.log('close success'); 304}).catch((err: BusinessError) => { 305 console.log('close fail'); 306}); 307``` 308 309### getState 310 311getState(callback: AsyncCallback\<SocketStateBase\>): void 312 313获取UDPSocket状态。使用callback方式作为异步方法。 314 315> **说明：** 316> bind方法调用成功后，才可调用此方法。 317 318**需要权限**：ohos.permission.INTERNET 319 320**系统能力**：SystemCapability.Communication.NetStack 321 322**参数：** 323 324| 参数名 | 类型 | 必填 | 说明 | 325| -------- | ------------------------------------------------------ | ---- | ---------- | 326| callback | AsyncCallback\<[SocketStateBase](#socketstatebase)\> | 是 | 回调函数。成功返回UDPSocket状态信息，失败返回错误码、错误信息。 | 327 328**错误码：** 329 330| 错误码ID | 错误信息 | 331| ------- | ----------------------- | 332| 201 | Permission denied. | 333 334**示例：** 335 336```ts 337import { socket } from '@kit.NetworkKit'; 338import { BusinessError } from '@kit.BasicServicesKit'; 339 340let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 341let bindAddr: socket.NetAddress = { 342 address: '192.168.xx.xxx', 343 port: 8080 344} 345udp.bind(bindAddr, (err: BusinessError) => { 346 if (err) { 347 console.log('bind fail'); 348 return; 349 } 350 console.log('bind success'); 351 udp.getState((err: BusinessError, data: socket.SocketStateBase) => { 352 if (err) { 353 console.log('getState fail'); 354 return; 355 } 356 console.log('getState success:' + JSON.stringify(data)); 357 }) 358}) 359``` 360 361### getState 362 363getState(): Promise\<SocketStateBase\> 364 365获取UDPSocket状态。使用Promise方式作为异步方法。 366 367> **说明：** 368> bind方法调用成功后，才可调用此方法。 369 370**需要权限**：ohos.permission.INTERNET 371 372**系统能力**：SystemCapability.Communication.NetStack 373 374**错误码：** 375 376| 错误码ID | 错误信息 | 377| ------- | ----------------------- | 378| 201 | Permission denied. | 379 380**返回值：** 381 382| 类型 | 说明 | 383| ----------------------------------------------- | ----------------------------------------- | 384| Promise\<[SocketStateBase](#socketstatebase)\> | 以Promise形式返回获取UDPSocket状态的结果。 | 385 386**示例：** 387 388```ts 389import { socket } from '@kit.NetworkKit'; 390import { BusinessError } from '@kit.BasicServicesKit'; 391 392let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 393let bindAddr: socket.NetAddress = { 394 address: '192.168.xx.xxx', 395 port: 8080 396} 397udp.bind(bindAddr, (err: BusinessError) => { 398 if (err) { 399 console.log('bind fail'); 400 return; 401 } 402 console.log('bind success'); 403 udp.getState().then((data: socket.SocketStateBase) => { 404 console.log('getState success:' + JSON.stringify(data)); 405 }).catch((err: BusinessError) => { 406 console.log('getState fail' + JSON.stringify(err)); 407 }); 408}); 409``` 410 411### setExtraOptions 412 413setExtraOptions(options: UDPExtraOptions, callback: AsyncCallback\<void\>): void 414 415设置UDPSocket连接的其他属性。使用callback方式作为异步方法。 416 417> **说明：** 418> bind方法调用成功后，才可调用此方法。 419 420**需要权限**：ohos.permission.INTERNET 421 422**系统能力**：SystemCapability.Communication.NetStack 423 424**参数：** 425 426| 参数名 | 类型 | 必填 | 说明 | 427| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 428| options | [UDPExtraOptions](#udpextraoptions) | 是 | UDPSocket连接的其他属性，参考[UDPExtraOptions](#udpextraoptions)。 | 429| callback | AsyncCallback\<void\> | 是 | 回调函数。成功返回空，失败返回错误码、错误信息。 | 430 431**错误码：** 432 433| 错误码ID | 错误信息 | 434| ------- | ----------------------- | 435| 401 | Parameter error. | 436| 201 | Permission denied. | 437 438**示例：** 439 440```ts 441import { socket } from '@kit.NetworkKit'; 442import { BusinessError } from '@kit.BasicServicesKit'; 443 444let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 445 446let bindAddr: socket.NetAddress = { 447 address: '192.168.xx.xxx', 448 port: 8080 449} 450udp.bind(bindAddr, (err: BusinessError) => { 451 if (err) { 452 console.log('bind fail'); 453 return; 454 } 455 console.log('bind success'); 456 let udpextraoptions: socket.UDPExtraOptions = { 457 receiveBufferSize: 1000, 458 sendBufferSize: 1000, 459 reuseAddress: false, 460 socketTimeout: 6000, 461 broadcast: true 462 } 463 udp.setExtraOptions(udpextraoptions, (err: BusinessError) => { 464 if (err) { 465 console.log('setExtraOptions fail'); 466 return; 467 } 468 console.log('setExtraOptions success'); 469 }) 470}) 471``` 472 473### setExtraOptions 474 475setExtraOptions(options: UDPExtraOptions): Promise\<void\> 476 477设置UDPSocket连接的其他属性。使用Promise方式作为异步方法。 478 479> **说明：** 480> bind方法调用成功后，才可调用此方法。 481 482**需要权限**：ohos.permission.INTERNET 483 484**系统能力**：SystemCapability.Communication.NetStack 485 486**参数：** 487 488| 参数名 | 类型 | 必填 | 说明 | 489| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 490| options | [UDPExtraOptions](#udpextraoptions) | 是 | UDPSocket连接的其他属性，参考[UDPExtraOptions](#udpextraoptions)。 | 491 492**返回值：** 493 494| 类型 | 说明 | 495| -------------- | --------------------------------------------------- | 496| Promise\<void\> | 以Promise形式返回设置UDPSocket连接的其他属性的结果。 | 497 498**错误码：** 499 500| 错误码ID | 错误信息 | 501| ------- | ----------------------- | 502| 401 | Parameter error. | 503| 201 | Permission denied. | 504 505**示例：** 506 507```ts 508import { socket } from '@kit.NetworkKit'; 509import { BusinessError } from '@kit.BasicServicesKit'; 510 511let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 512 513let bindAddr: socket.NetAddress = { 514 address: '192.168.xx.xxx', 515 port: 8080 516} 517udp.bind(bindAddr, (err: BusinessError) => { 518 if (err) { 519 console.log('bind fail'); 520 return; 521 } 522 console.log('bind success'); 523 let udpextraoptions: socket.UDPExtraOptions = { 524 receiveBufferSize: 1000, 525 sendBufferSize: 1000, 526 reuseAddress: false, 527 socketTimeout: 6000, 528 broadcast: true 529 } 530 udp.setExtraOptions(udpextraoptions).then(() => { 531 console.log('setExtraOptions success'); 532 }).catch((err: BusinessError) => { 533 console.log('setExtraOptions fail'); 534 }); 535}) 536``` 537 538### getLocalAddress<sup>12+</sup> 539 540getLocalAddress(): Promise\<NetAddress\> 541 542获取UDP连接的本地Socket地址。使用Promise方式作为异步方法。 543 544> **说明：** 545> bind方法调用成功后，才可调用此方法。 546 547**系统能力**：SystemCapability.Communication.NetStack 548 549**返回值：** 550 551| 类型 | 说明 | 552| -------------- | --------------------------------------------------- | 553| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取本地socket地址的结果。 | 554 555**错误码：** 556 557| 错误码ID | 错误信息 | 558| -------- | ------------------------------------------- | 559| 2300002 | System internal error. | 560| 2301009 | Bad file descriptor. | 561| 2303188 | Socket operation on non-socket. | 562 563**示例：** 564 565```ts 566import { socket } from '@kit.NetworkKit'; 567import { BusinessError } from '@kit.BasicServicesKit'; 568 569let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 570 571let bindAddr: socket.NetAddress = { 572 address: '192.168.xx.xxx', 573 port: 8080 574} 575udp.bind(bindAddr).then(() => { 576 console.info('bind success'); 577 udp.getLocalAddress().then((localAddress: socket.NetAddress) => { 578 console.info("UDP_Socket get SUCCESS! Address：" + JSON.stringify(localAddress)); 579 }).catch((err: BusinessError) => { 580 console.error("UDP_Socket get FAILED! Error: " + JSON.stringify(err)); 581 }) 582}).catch((err: BusinessError) => { 583 console.error('bind fail'); 584}); 585``` 586 587### on('message') 588 589on(type: 'message', callback: Callback\<SocketMessageInfo\>): void 590 591订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。 592 593**系统能力**：SystemCapability.Communication.NetStack 594 595**参数：** 596 597| 参数名 | 类型 | 必填 | 说明 | 598| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 599| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 600| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 是 | 回调函数。返回订阅某类事件后UDPSocket连接成功的状态信息。 | 601 602**示例：** 603 604```ts 605import { socket } from '@kit.NetworkKit'; 606import { BusinessError } from '@kit.BasicServicesKit'; 607 608let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 609 610let messageView = ''; 611udp.on('message', (value: socket.SocketMessageInfo) => { 612 for (let i: number = 0; i < value.message.byteLength; i++) { 613 let uint8Array = new Uint8Array(value.message) 614 let messages = uint8Array[i] 615 let message = String.fromCharCode(messages); 616 messageView += message; 617 } 618 console.log('on message message: ' + JSON.stringify(messageView)); 619 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 620}); 621``` 622 623### off('message') 624 625off(type: 'message', callback?: Callback\<SocketMessageInfo\>): void 626 627取消订阅UDPSocket连接的接收消息事件。使用callback方式作为异步方法。 628 629**系统能力**：SystemCapability.Communication.NetStack 630 631**参数：** 632 633| 参数名 | 类型 | 必填 | 说明 | 634| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 635| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 636| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 否 | 回调函数。返回取消订阅某类事件后UDPSocket连接的状态信息。 | 637 638**示例：** 639 640```ts 641import { socket } from '@kit.NetworkKit'; 642import { BusinessError } from '@kit.BasicServicesKit'; 643 644let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 645let messageView = ''; 646let callback = (value: socket.SocketMessageInfo) => { 647 for (let i: number = 0; i < value.message.byteLength; i++) { 648 let uint8Array = new Uint8Array(value.message) 649 let messages = uint8Array[i] 650 let message = String.fromCharCode(messages); 651 messageView += message; 652 } 653 console.log('on message message: ' + JSON.stringify(messageView)); 654 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 655} 656udp.on('message', callback); 657// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 658udp.off('message', callback); 659udp.off('message'); 660``` 661 662### on('listening' | 'close') 663 664on(type: 'listening' | 'close', callback: Callback\<void\>): void 665 666订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。 667 668**系统能力**：SystemCapability.Communication.NetStack 669 670**参数：** 671 672| 参数名 | 类型 | 必填 | 说明 | 673| -------- | ---------------- | ---- | ------------------------------------------------------------ | 674| type | string | 是 | 订阅的事件类型。<br />- 'listening'：数据包消息事件。<br />- 'close'：关闭事件。 | 675| callback | Callback\<void\> | 是 | 回调函数。UDPSocket连接的某类数据包消息事件或关闭事件发生变化后触发回调函数。 | 676 677**示例：** 678 679```ts 680import { socket } from '@kit.NetworkKit'; 681import { BusinessError } from '@kit.BasicServicesKit'; 682 683let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 684udp.on('listening', () => { 685 console.log("on listening success"); 686}); 687udp.on('close', () => { 688 console.log("on close success"); 689}); 690``` 691 692### off('listening' | 'close') 693 694off(type: 'listening' | 'close', callback?: Callback\<void\>): void 695 696取消订阅UDPSocket连接的数据包消息事件或关闭事件。使用callback方式作为异步方法。 697 698**系统能力**：SystemCapability.Communication.NetStack 699 700**参数：** 701 702| 参数名 | 类型 | 必填 | 说明 | 703| -------- | ---------------- | ---- | ------------------------------------------------------------ | 704| type | string | 是 | 订阅事件类型。<br />- 'listening'：数据包消息事件。<br />- 'close'：关闭事件。 | 705| callback | Callback\<void\> | 否 | 回调函数。取消订阅UDPSocket连接的数据包消息事件或关闭事件后触发回调函数。 | 706 707**示例：** 708 709```ts 710import { socket } from '@kit.NetworkKit'; 711import { BusinessError } from '@kit.BasicServicesKit'; 712 713let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 714let callback1 = () => { 715 console.log("on listening, success"); 716} 717udp.on('listening', callback1); 718// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 719udp.off('listening', callback1); 720udp.off('listening'); 721let callback2 = () => { 722 console.log("on close, success"); 723} 724udp.on('close', callback2); 725// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 726udp.off('close', callback2); 727udp.off('close'); 728``` 729 730### on('error') 731 732on(type: 'error', callback: ErrorCallback): void 733 734订阅UDPSocket连接的error事件。使用callback方式作为异步方法。 735 736**系统能力**：SystemCapability.Communication.NetStack 737 738**参数：** 739 740| 参数名 | 类型 | 必填 | 说明 | 741| -------- | ------------- | ---- | ------------------------------------ | 742| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 743| callback | ErrorCallback | 是 | 回调函数。UDPSocket连接发生error事件后触发回调函数。 | 744 745**示例：** 746 747```ts 748import { socket } from '@kit.NetworkKit'; 749import { BusinessError } from '@kit.BasicServicesKit'; 750 751let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 752udp.on('error', (err: BusinessError) => { 753 console.log("on error, err:" + JSON.stringify(err)) 754}); 755``` 756 757### off('error') 758 759off(type: 'error', callback?: ErrorCallback): void 760 761取消订阅UDPSocket连接的error事件。使用callback方式作为异步方法。 762 763**系统能力**：SystemCapability.Communication.NetStack 764 765**参数：** 766 767| 参数名 | 类型 | 必填 | 说明 | 768| -------- | ------------- | ---- | ------------------------------------ | 769| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 770| callback | ErrorCallback | 否 | 回调函数。UDPSocket连接发生error事件后。 | 771 772**示例：** 773 774```ts 775import { socket } from '@kit.NetworkKit'; 776import { BusinessError } from '@kit.BasicServicesKit'; 777 778let udp: socket.UDPSocket = socket.constructUDPSocketInstance(); 779let callback = (err: BusinessError) => { 780 console.log("on error, err:" + JSON.stringify(err)); 781} 782udp.on('error', callback); 783// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 784udp.off('error', callback); 785udp.off('error'); 786``` 787 788## NetAddress 789 790目标地址信息。 791 792**系统能力**：SystemCapability.Communication.NetStack 793 794| 名称 | 类型 | 必填 | 说明 | 795| ------- | ------ | ---- | ------------------------------------------------------------ | 796| address<sup>11+</sup> | string | 是 | 本地绑定的ip地址。 | 797| port | number | 否 | 端口号 ，范围0~65535。如果不指定系统随机分配端口。 | 798| family | number | 否 | 网络协议类型，可选类型：<br />- 1：IPv4<br />- 2：IPv6<br />默认为1。如果地址为IPV6类型，该字段必须被显式指定为2。 | 799## UDPSendOptions 800 801UDPSocket发送参数。 802 803**系统能力**：SystemCapability.Communication.NetStack 804 805| 名称 | 类型 | 必填 | 说明 | 806| ------- | ---------------------------------- | ---- | -------------- | 807| data | string \| ArrayBuffer | 是 | 发送的数据。 | 808| address | [NetAddress](#netaddress) | 是 | 目标地址信息。 | 809 810## UDPExtraOptions 811 812UDPSocket连接的其他属性。继承自[ExtraOptionsBase](#extraoptionsbase7)。 813 814**系统能力**：SystemCapability.Communication.NetStack 815 816| 名称 | 类型 | 必填 | 说明 | 817| ----------------- | ------- | ---- | -------------------------------- | 818| broadcast | boolean | 否 | 是否可以发送广播。默认为false。 | 819 820## SocketMessageInfo<sup>11+</sup> 821 822socket连接信息 823 824**系统能力**：SystemCapability.Communication.NetStack 825 826| 名称 | 类型 | 必填 | 说明 | 827| ---------- | ------ | ---- | ------------------------------------- | 828| message | ArrayBuffer | 是 | 接收的事件消息。 | 829| remoteInfo | [SocketRemoteInfo](#socketremoteinfo) | 是 | socket连接信息。 | 830 831## SocketStateBase 832 833Socket的状态信息。 834 835**系统能力**：SystemCapability.Communication.NetStack 836 837| 名称 | 类型 | 必填 | 说明 | 838| ----------- | ------- | ---- | ---------- | 839| isBound | boolean | 是 | 是否绑定。 | 840| isClose | boolean | 是 | 是否关闭。 | 841| isConnected | boolean | 是 | 是否连接。 | 842 843## SocketRemoteInfo 844 845Socket的连接信息。 846 847**系统能力**：SystemCapability.Communication.NetStack 848 849| 名称 | 类型 | 必填 | 说明 | 850| ------- | ------ | ---- | ------------------------------------------------------------ | 851| address | string | 是 | 本地绑定的ip地址。 | 852| family | 'IPv4' \| 'IPv6' | 是 | 网络协议类型，可选类型：<br />- IPv4<br />- IPv6<br />默认为IPv4。 | 853| port | number | 是 | 端口号，范围0~65535。 | 854| size | number | 是 | 服务器响应信息的字节长度。 | 855 856## UDP 错误码说明 857 858UDP 其余错误码映射形式为：2301000 + Linux内核错误码。 859 860错误码的详细介绍参见[Socket错误码](errorcode-net-socket.md) 861 862## socket.constructMulticastSocketInstance<sup>11+</sup> 863 864constructMulticastSocketInstance(): MulticastSocket 865 866创建一个MulticastSocket对象。 867 868**系统能力**：SystemCapability.Communication.NetStack 869 870**返回值：** 871 872| 类型 | 说明 | 873| ----------------------------------- | ----------------------------- | 874| [MulticastSocket](#multicastsocket11) | 返回一个MulticastSocket对象。 | 875 876**示例：** 877 878```ts 879import { socket } from '@kit.NetworkKit'; 880let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 881``` 882## MulticastSocket<sup>11+</sup> 883 884MulticastSocket连接。在调用MulticastSocket的方法前，需要先通过[socket.constructMulticastSocketInstance](#socketconstructmulticastsocketinstance11)创建MulticastSocket对象。 885 886### addMembership<sup>11+</sup> 887 888addMembership(multicastAddress: NetAddress, callback: AsyncCallback\<void\>): void; 889 890加入多播组。使用callback方法作为异步方法。 891 892> **说明：** 893> 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 894> 加入多播组后，既可以是发送端，也可以是接收端，相互之间以广播的形式传递数据，不区分客户端或服务端。 895 896**需要权限**：ohos.permission.INTERNET 897 898**系统能力**：SystemCapability.Communication.NetStack 899 900**参数：** 901 902| 参数名 | 类型 | 必填 | 说明 | 903| ----------------- | ----------------------------- | ---- | ----------------------------------------- | 904| multicastAddress | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 905| callback | AsyncCallback\<void\> | 是 | 回调函数。失败返回错误码、错误信息。 | 906 907**错误码：** 908 909| 错误码ID | 错误信息 | 910| ------- | ----------------------- | 911| 401 | Parameter error. | 912| 201 | Permission denied. | 913| 2301022 | Invalid argument. | 914| 2301088 | Not a socket. | 915| 2301098 | Address in use. | 916 917**示例：** 918 919```ts 920import { socket } from '@kit.NetworkKit'; 921 922let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 923let addr: socket.NetAddress = { 924 address: '239.255.0.1', 925 port: 8080 926} 927multicast.addMembership(addr, (err: Object) => { 928 if (err) { 929 console.log('add membership fail, err: ' + JSON.stringify(err)); 930 return; 931 } 932 console.log('add membership success'); 933}) 934``` 935 936### addMembership<sup>11+</sup> 937 938addMembership(multicastAddress: NetAddress): Promise\<void\>; 939 940加入多播组。使用Promise方法作为异步方法。。 941 942> **说明：** 943> 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 944> 加入多播组后，既可以是发送端，也可以是接收端，相互之间以广播的形式传递数据，不区分客户端或服务端。 945 946**需要权限**：ohos.permission.INTERNET 947 948**系统能力**：SystemCapability.Communication.NetStack 949 950**参数：** 951 952| 参数名 | 类型 | 必填 | 说明 | 953| ----------------- | ----------------------------- | ---- | -------------------------------------------- | 954| multicastAddress | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 955 956**返回值：** 957 958| 类型 | 说明 | 959| -------------- | ----------------------------------------------- | 960| Promise\<void\> | 以Promise形式返回MulticastSocket加入多播组的行为结果。 | 961 962**错误码：** 963 964| 错误码ID | 错误信息 | 965| ------- | ----------------------- | 966| 401 | Parameter error. | 967| 201 | Permission denied. | 968| 2301088 | Not a socket. | 969| 2301098 | Address in use. | 970 971**示例：** 972 973```ts 974import { socket } from '@kit.NetworkKit'; 975 976let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 977let addr: socket.NetAddress = { 978 address: '239.255.0.1', 979 port: 8080 980} 981multicast.addMembership(addr).then(() => { 982 console.log('addMembership success'); 983}).catch((err: Object) => { 984 console.log('addMembership fail'); 985}); 986``` 987 988### dropMembership<sup>11+</sup> 989 990dropMembership(multicastAddress: NetAddress, callback: AsyncCallback\<void\>): void; 991 992退出多播组。使用callback方法作为异步方法。 993 994> **说明：** 995> 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 996> 从已加入的多播组中退出，必须在加入多播组 [addMembership](#addmembership11) 之后退出才有效。 997 998**需要权限**：ohos.permission.INTERNET 999 1000**系统能力**：SystemCapability.Communication.NetStack 1001 1002**参数：** 1003 1004| 参数名 | 类型 | 必填 | 说明 | 1005| ----------------- | ----------------------------- | ---- | ------------------------------------------- | 1006| multicastAddress | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 1007| callback | AsyncCallback\<void\> | 是 | 回调函数。失败返回错误码、错误信息。| 1008 1009**错误码：** 1010 1011| 错误码ID | 错误信息 | 1012| ------- | ----------------------- | 1013| 401 | Parameter error. | 1014| 201 | Permission denied. | 1015| 2301088 | Not a socket. | 1016| 2301098 | Address in use. | 1017 1018**示例：** 1019 1020```ts 1021import { socket } from '@kit.NetworkKit'; 1022 1023let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1024let addr: socket.NetAddress = { 1025 address: '239.255.0.1', 1026 port: 8080 1027} 1028multicast.dropMembership(addr, (err: Object) => { 1029 if (err) { 1030 console.log('drop membership fail, err: ' + JSON.stringify(err)); 1031 return; 1032 } 1033 console.log('drop membership success'); 1034}) 1035``` 1036 1037### dropMembership<sup>11+</sup> 1038 1039dropMembership(multicastAddress: NetAddress): Promise\<void\>; 1040 1041退出多播组。使用Promise方法作为异步方法。。 1042 1043> **说明：** 1044> 多播使用的IP地址属于特定的范围（例如224.0.0.0到239.255.255.255）。 1045> 从已加入的多播组中退出，必须在加入多播组 [addMembership](#addmembership11) 之后退出才有效。 1046 1047**需要权限**：ohos.permission.INTERNET 1048 1049**系统能力**：SystemCapability.Communication.NetStack 1050 1051**参数：** 1052 1053| 参数名 | 类型 | 必填 | 说明 | 1054| ----------------- | ------------------------------------- | ---- | -------------------------------------------- | 1055| multicastAddress | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 1056 1057**返回值：** 1058 1059| 类型 | 说明 | 1060| -------------- | ----------------------------------------------- | 1061| Promise\<void\> | 以Promise形式返回MulticastSocket加入多播组的执行结果。 | 1062 1063**错误码：** 1064 1065| 错误码ID | 错误信息 | 1066| ------- | ----------------------- | 1067| 401 | Parameter error. | 1068| 201 | Permission denied. | 1069| 2301088 | Not a socket. | 1070| 2301098 | Address in use. | 1071 1072**示例：** 1073 1074```ts 1075import { socket } from '@kit.NetworkKit'; 1076 1077let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1078let addr: socket.NetAddress = { 1079 address: '239.255.0.1', 1080 port: 8080 1081} 1082multicast.dropMembership(addr).then(() => { 1083 console.log('drop membership success'); 1084}).catch((err: Object) => { 1085 console.log('drop membership fail'); 1086}); 1087``` 1088 1089### setMulticastTTL<sup>11+</sup> 1090 1091setMulticastTTL(ttl: number, callback: AsyncCallback\<void\>): void; 1092 1093设置多播通信时数据包在网络传输过程中路由器最大跳数。使用callback方法作为异步方法。 1094 1095> **说明：** 1096> 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 1097> 范围为 0～255，默认值为 1 。 1098> 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 1099> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1100 1101**系统能力**：SystemCapability.Communication.NetStack 1102 1103**参数：** 1104 1105| 参数名 | 类型 | 必填 | 说明 | 1106| ------------- | --------------------- | ---- | ----------------------------- | 1107| ttl | number | 是 | ttl设置数值，类型为数字number。 | 1108| callback | AsyncCallback\<void\> | 是 | 回调函数。失败返回错误码、错误信息。 | 1109 1110**错误码：** 1111 1112| 错误码ID | 错误信息 | 1113| ------- | ----------------------- | 1114| 401 | Parameter error. | 1115| 2301022 | Invalid argument. | 1116| 2301088 | Not a socket. | 1117 1118**示例：** 1119 1120```ts 1121import { socket } from '@kit.NetworkKit'; 1122 1123let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1124let ttl = 8 1125multicast.setMulticastTTL(ttl, (err: Object) => { 1126 if (err) { 1127 console.log('set ttl fail, err: ' + JSON.stringify(err)); 1128 return; 1129 } 1130 console.log('set ttl success'); 1131}) 1132``` 1133 1134### setMulticastTTL<sup>11+</sup> 1135 1136setMulticastTTL(ttl: number): Promise\<void\>; 1137 1138设置多播通信时数据包在网络传输过程中路由器最大跳数。使用Promise方法作为异步方法。。 1139 1140> **说明：** 1141> 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 1142> 范围为 0～255，默认值为 1 。 1143> 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 1144> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1145 1146**系统能力**：SystemCapability.Communication.NetStack 1147 1148**参数：** 1149 1150| 参数名 | 类型 | 必填 | 说明 | 1151| ------------- | ---------------------- | ---- | ------------------------------ | 1152| ttl | number | 是 | ttl设置数值，类型为数字Number。 | 1153 1154**返回值：** 1155 1156| 类型 | 说明 | 1157| -------------- | ---------------------------------------------- | 1158| Promise\<void\> | 以Promise形式返回MulticastSocket设置TTL数值的结果。 | 1159 1160**错误码：** 1161 1162| 错误码ID | 错误信息 | 1163| ------- | ----------------------- | 1164| 401 | Parameter error. | 1165| 2301022 | Invalid argument. | 1166| 2301088 | Not a socket. | 1167 1168**示例：** 1169 1170```ts 1171import { socket } from '@kit.NetworkKit'; 1172 1173let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1174multicast.setMulticastTTL(8).then(() => { 1175 console.log('set ttl success'); 1176}).catch((err: Object) => { 1177 console.log('set ttl failed'); 1178}); 1179``` 1180 1181### getMulticastTTL<sup>11+</sup> 1182 1183getMulticastTTL(callback: AsyncCallback\<number\>): void; 1184 1185获取数据包在网络传输过程中路由器最大跳数(TTL)的值。使用callback方法作为异步方法。 1186 1187> **说明：** 1188> 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 1189> 范围为 0～255，默认值为 1 。 1190> 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 1191> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1192 1193**系统能力**：SystemCapability.Communication.NetStack 1194 1195**参数：** 1196 1197| 参数名 | 类型 | 必填 | 说明 | 1198| ------------- | ----------------------- | ---- | --------------------------- | 1199| callback | AsyncCallback\<number\> | 是 | 回调函数。失败返回错误码、错误信息。 | 1200 1201**错误码：** 1202 1203| 错误码ID | 错误信息 | 1204| ------- | ----------------------- | 1205| 401 | Parameter error. | 1206| 2301088 | Not a socket. | 1207 1208**示例：** 1209 1210```ts 1211import { socket } from '@kit.NetworkKit'; 1212 1213let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1214multicast.getMulticastTTL((err: Object, value: Number) => { 1215 if (err) { 1216 console.log('set ttl fail, err: ' + JSON.stringify(err)); 1217 return; 1218 } 1219 console.log('set ttl success, value: ' + JSON.stringify(value)); 1220}) 1221``` 1222 1223### getMulticastTTL<sup>11+</sup> 1224 1225getMulticastTTL(): Promise\<number\>; 1226 1227获取数据包在网络传输过程中路由器最大跳数(TTL)的值。使用Promise方法作为异步方法。 1228 1229> **说明：** 1230> 用于限制数据包在网络中传输时能够经过的最大路由器跳数的字段，TTL (Time to live)。 1231> 范围为 0～255，默认值为 1 。 1232> 如果一个多播数据包的 TTL 值为 1，那么它只能被直接连接到发送者的主机接收。如果 TTL 被设置为一个较大的值，那么数据包就能够被传送到更远的网络范围内。 1233> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1234 1235**系统能力**：SystemCapability.Communication.NetStack 1236 1237**返回值：** 1238 1239| 类型 | 说明 | 1240| ---------------- | --------------------------- | 1241| Promise\<number\> | 以Promise形式返回当前TTL数值。 | 1242 1243**错误码：** 1244 1245| 错误码ID | 错误信息 | 1246| ------- | ----------------------- | 1247| 401 | Parameter error. | 1248| 2301088 | Not a socket. | 1249 1250**示例：** 1251 1252```ts 1253import { socket } from '@kit.NetworkKit'; 1254 1255let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1256multicast.getMulticastTTL().then((value: Number) => { 1257 console.log('ttl: ', JSON.stringify(value)); 1258}).catch((err: Object) => { 1259 console.log('set ttl failed'); 1260}); 1261``` 1262 1263### setLoopbackMode<sup>11+</sup> 1264 1265setLoopbackMode(flag: boolean, callback: AsyncCallback\<void\>): void; 1266 1267设置多播通信中的环回模式标志位。使用callback方法作为异步方法。 1268 1269> **说明：** 1270> 用于设置环回模式，开启或关闭两种状态，默认为开启状态。 1271> 如果一个多播通信中环回模式设置值为 true，那么它允许主机在本地循环接收自己发送的多播数据包。如果为 false，则主机不会接收到自己发送的多播数据包。 1272> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1273 1274**系统能力**：SystemCapability.Communication.NetStack 1275 1276**参数：** 1277 1278| 参数名 | 类型 | 必填 | 说明 | 1279| ------------- | --------------------- | ---- | ---------------------------- | 1280| flag | boolean | 是 | ttl设置数值，类型为boolen 。 | 1281| callback | AsyncCallback\<void\> | 是 | 回调函数。失败返回错误码、错误信息。 | 1282 1283**错误码：** 1284 1285| 错误码ID | 错误信息 | 1286| ------- | ----------------------- | 1287| 401 | Parameter error. | 1288| 2301088 | Not a socket. | 1289 1290**示例：** 1291 1292```ts 1293import { socket } from '@kit.NetworkKit'; 1294 1295let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1296multicast.setLoopbackMode(false, (err: Object) => { 1297 if (err) { 1298 console.log('set loopback mode fail, err: ' + JSON.stringify(err)); 1299 return; 1300 } 1301 console.log('set loopback mode success'); 1302}) 1303``` 1304 1305### setLoopbackMode<sup>11+</sup> 1306 1307setLoopbackMode(flag: boolean): Promise\<void\>; 1308 1309设置多播通信中的环回模式标志位。使用callback方法作为异步方法。 1310 1311> **说明：** 1312> 用于设置环回模式，开启或关闭两种状态，默认为开启状态。 1313> 如果一个多播通信中环回模式设置值为 true，那么它允许主机在本地循环接收自己发送的多播数据包。如果为 false，则主机不会接收到自己发送的多播数据包。 1314> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1315 1316**系统能力**：SystemCapability.Communication.NetStack 1317 1318**参数：** 1319 1320| 参数名 | 类型 | 必填 | 说明 | 1321| ------------- | ---------------------- | ---- | -------------------------------- | 1322| flag | boolean | 是 | 环回模式标志位，类型为数字boolean。| 1323 1324**返回值：** 1325 1326| 类型 | 说明 | 1327| -------------- | ---------------------------------------------- | 1328| Promise\<void\> | 以Promise形式返回MulticastSocket设置环回模式的结果。 | 1329 1330**错误码：** 1331 1332| 错误码ID | 错误信息 | 1333| ------- | ----------------------- | 1334| 401 | Parameter error. | 1335| 2301088 | Not a socket. | 1336 1337**示例：** 1338 1339```ts 1340import { socket } from '@kit.NetworkKit'; 1341 1342let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1343multicast.setLoopbackMode(false).then(() => { 1344 console.log('set loopback mode success'); 1345}).catch((err: Object) => { 1346 console.log('set loopback mode failed'); 1347}); 1348``` 1349 1350### getLoopbackMode<sup>11+</sup> 1351 1352getLoopbackMode(callback: AsyncCallback\<boolean\>): void; 1353 1354获取多播通信中的环回模式状态。使用Promise方法作为异步方法。 1355 1356> **说明：** 1357> 用于获取当前环回模式开启或关闭的状态。 1358> 如果获取的属性值为 true，表示环回模式是开启的状态，允许主机在本地循环接收自己发送的多播数据包。如果为 false，则表示环回模式是关闭的状态，主机不会接收到自己发送的多播数据包。 1359> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1360 1361**系统能力**：SystemCapability.Communication.NetStack 1362 1363**参数：** 1364 1365| 参数名 | 类型 | 必填 | 说明 | 1366| ------------- | ----------------------- | ---- | --------------------------- | 1367| callback | AsyncCallback\<number\> | 是 | 回调函数。失败返回错误码、错误信息。 | 1368 1369**错误码：** 1370 1371| 错误码ID | 错误信息 | 1372| ------- | ----------------------- | 1373| 401 | Parameter error. | 1374| 2301088 | Not a socket. | 1375 1376**示例：** 1377 1378```ts 1379import { socket } from '@kit.NetworkKit'; 1380 1381let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1382multicast.getLoopbackMode((err: Object, value: Boolean) => { 1383 if (err) { 1384 console.log('get loopback mode fail, err: ' + JSON.stringify(err)); 1385 return; 1386 } 1387 console.log('get loopback mode success, value: ' + JSON.stringify(value)); 1388}) 1389``` 1390 1391### getLoopbackMode<sup>11+</sup> 1392 1393getLoopbackMode(): Promise\<boolean\>; 1394 1395获取多播通信中的环回模式状态。使用Promise方法作为异步方法。 1396 1397> **说明：** 1398> 用于获取当前环回模式开启或关闭的状态。 1399> 如果获取的属性值为 true，表示环回模式是开启的状态，允许主机在本地循环接收自己发送的多播数据包。如果为 false，则表示环回模式是关闭的状态，主机不会接收到自己发送的多播数据包。 1400> 在调用 [addMembership](#addmembership11) 之后，调用此接口才有效。 1401 1402**系统能力**：SystemCapability.Communication.NetStack 1403 1404**返回值：** 1405 1406| 类型 | 说明 | 1407| ---------------- | --------------------------- | 1408| Promise\<boolean\> | 以Promise形式返回当前TTL数值。 | 1409 1410**错误码：** 1411 1412| 错误码ID | 错误信息 | 1413| ------- | ----------------------- | 1414| 401 | Parameter error. | 1415| 2301088 | Not a socket. | 1416 1417**示例：** 1418 1419```ts 1420import { socket } from '@kit.NetworkKit'; 1421 1422let multicast: socket.MulticastSocket = socket.constructMulticastSocketInstance(); 1423multicast.getLoopbackMode().then((value: Boolean) => { 1424 console.log('loopback mode: ', JSON.stringify(value)); 1425}).catch((err: Object) => { 1426 console.log('get loopback mode failed'); 1427}); 1428``` 1429 1430## socket.constructTCPSocketInstance<sup>7+</sup> 1431 1432constructTCPSocketInstance(): TCPSocket 1433 1434创建一个TCPSocket对象。 1435 1436**系统能力**：SystemCapability.Communication.NetStack 1437 1438**返回值：** 1439 1440| 类型 | 说明 | 1441| --------------------------------- | ---------------------- | 1442| [TCPSocket](#tcpsocket) | 返回一个TCPSocket对象。 | 1443 1444**示例：** 1445 1446```ts 1447import { socket } from '@kit.NetworkKit'; 1448let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1449``` 1450 1451## TCPSocket 1452 1453TCPSocket连接。在调用TCPSocket的方法前，需要先通过[socket.constructTCPSocketInstance](#socketconstructtcpsocketinstance7)创建TCPSocket对象。 1454 1455### bind 1456 1457bind(address: NetAddress, callback: AsyncCallback\<void\>): void 1458 1459绑定IP地址和端口，端口可以指定为0由系统随机分配或指定为其它非0端口。使用callback方法作为异步方法。 1460 1461> **说明：** 1462> bind方法如果因为端口冲突而执行失败，则会由系统随机分配端口号。 1463> TCP客户端可先调用该接口(tcp.bind)显式绑定IP地址和端口号，再调用tcp.connect完成与服务端的连接；也可直接调用tcp.connect由系统自动绑定IP地址和端口号，完成与服务端的连接。 1464> bind的IP为'localhost'或'127.0.0.1'时，只允许本地回环接口的连接，即服务端和客户端运行在同一台机器上。 1465 1466**需要权限**：ohos.permission.INTERNET 1467 1468**系统能力**：SystemCapability.Communication.NetStack 1469 1470**参数：** 1471 1472| 参数名 | 类型 | 必填 | 说明 | 1473| -------- | ---------------------------------- | ---- | ------------------------------------------------------ | 1474| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 1475| callback | AsyncCallback\<void\> | 是 | 回调函数。失败返回错误、错误信息。 | 1476 1477**错误码：** 1478 1479| 错误码ID | 错误信息 | 1480| ------- | ----------------------- | 1481| 401 | Parameter error. | 1482| 201 | Permission denied. | 1483 1484**示例：** 1485 1486```ts 1487import { socket } from '@kit.NetworkKit'; 1488import { BusinessError } from '@kit.BasicServicesKit'; 1489 1490let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1491let bindAddr: socket.NetAddress = { 1492 address: '192.168.xx.xxx', 1493 port: 8080 1494} 1495tcp.bind(bindAddr, (err: BusinessError) => { 1496 if (err) { 1497 console.log('bind fail'); 1498 return; 1499 } 1500 console.log('bind success'); 1501}) 1502``` 1503 1504### bind 1505 1506bind(address: NetAddress): Promise\<void\> 1507 1508绑定IP地址和端口，端口可以指定为0由系统随机分配或指定为其它非0端口。使用Promise方法作为异步方法。 1509 1510> **说明：** 1511> bind方法如果因为端口冲突而执行失败，则会由系统随机分配端口号。 1512> TCP客户端可先调用该接口(tcp.bind)显式绑定IP地址和端口号，再调用tcp.connect完成与服务端的连接；也可直接调用tcp.connect由系统自动绑定IP地址和端口号，完成与服务端的连接。 1513> bind的IP为'localhost'或'127.0.0.1'时，只允许本地回环接口的连接，即服务端和客户端运行在同一台机器上。 1514 1515**需要权限**：ohos.permission.INTERNET 1516 1517**系统能力**：SystemCapability.Communication.NetStack 1518 1519**参数：** 1520 1521| 参数名 | 类型 | 必填 | 说明 | 1522| ------- | ---------------------------------- | ---- | ------------------------------------------------------ | 1523| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 1524 1525**返回值：** 1526 1527| 类型 | 说明 | 1528| --------------- | ------------------------------------------------------- | 1529| Promise\<void\> | 以Promise形式返回TCPSocket绑定本机的IP地址和端口的结果。 | 1530 1531**错误码：** 1532 1533| 错误码ID | 错误信息 | 1534| ------- | ----------------------- | 1535| 401 | Parameter error. | 1536| 201 | Permission denied. | 1537 1538**示例：** 1539 1540```ts 1541import { socket } from '@kit.NetworkKit'; 1542import { BusinessError } from '@kit.BasicServicesKit'; 1543 1544let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1545let bindAddr: socket.NetAddress = { 1546 address: '192.168.xx.xxx', 1547 port: 8080 1548} 1549tcp.bind(bindAddr).then(() => { 1550 console.log('bind success'); 1551}).catch((err: BusinessError) => { 1552 console.log('bind fail'); 1553}); 1554``` 1555 1556### connect 1557 1558connect(options: TCPConnectOptions, callback: AsyncCallback\<void\>): void 1559 1560连接到指定的IP地址和端口。使用callback方法作为异步方法。 1561 1562> **说明：** 1563> 在没有执行tcp.bind的情况下，也可以直接调用该接口完成与TCP服务端的连接 1564 1565**需要权限**：ohos.permission.INTERNET 1566 1567**系统能力**：SystemCapability.Communication.NetStack 1568 1569**参数：** 1570 1571| 参数名 | 类型 | 必填 | 说明 | 1572| -------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 1573| options | [TCPConnectOptions](#tcpconnectoptions) | 是 | TCPSocket连接的参数，参考[TCPConnectOptions](#tcpconnectoptions)。 | 1574| callback | AsyncCallback\<void\> | 是 | 回调函数。失败返回错误码、错误信息。 | 1575 1576**错误码：** 1577 1578| 错误码ID | 错误信息 | 1579| ------- | ----------------------- | 1580| 401 | Parameter error. | 1581| 201 | Permission denied. | 1582 1583**示例：** 1584 1585```ts 1586import { socket } from '@kit.NetworkKit'; 1587import { BusinessError } from '@kit.BasicServicesKit'; 1588 1589let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1590let netAddress: socket.NetAddress = { 1591 address: '192.168.xx.xxx', 1592 port: 8080 1593} 1594let tcpconnectoptions: socket.TCPConnectOptions = { 1595 address: netAddress, 1596 timeout: 6000 1597} 1598tcp.connect(tcpconnectoptions, (err: BusinessError) => { 1599 if (err) { 1600 console.log('connect fail'); 1601 return; 1602 } 1603 console.log('connect success'); 1604}) 1605``` 1606 1607### connect 1608 1609connect(options: TCPConnectOptions): Promise\<void\> 1610 1611连接到指定的IP地址和端口。使用promise方法作为异步方法。 1612 1613> **说明：** 1614> 在没有执行tcp.bind的情况下，也可以直接调用该接口完成与TCP服务端的连接。 1615 1616**需要权限**：ohos.permission.INTERNET 1617 1618**系统能力**：SystemCapability.Communication.NetStack 1619 1620**参数：** 1621 1622| 参数名 | 类型 | 必填 | 说明 | 1623| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 1624| options | [TCPConnectOptions](#tcpconnectoptions) | 是 | TCPSocket连接的参数，参考[TCPConnectOptions](#tcpconnectoptions)。 | 1625 1626**返回值：** 1627 1628| 类型 | 说明 | 1629| -------------- | --------------------------------------------------------- | 1630| Promise\<void\> | 以Promise形式返回TCPSocket连接到指定的IP地址和端口的结果。 | 1631 1632**错误码：** 1633 1634| 错误码ID | 错误信息 | 1635| ------- | ----------------------- | 1636| 401 | Parameter error. | 1637| 201 | Permission denied. | 1638 1639**示例：** 1640 1641```ts 1642import { socket } from '@kit.NetworkKit'; 1643import { BusinessError } from '@kit.BasicServicesKit'; 1644 1645let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1646let netAddress: socket.NetAddress = { 1647 address: '192.168.xx.xxx', 1648 port: 8080 1649} 1650let tcpconnectoptions: socket.TCPConnectOptions = { 1651 address: netAddress, 1652 timeout: 6000 1653} 1654tcp.connect(tcpconnectoptions).then(() => { 1655 console.log('connect success') 1656}).catch((err: BusinessError) => { 1657 console.log('connect fail'); 1658}); 1659``` 1660 1661### send 1662 1663send(options: TCPSendOptions, callback: AsyncCallback\<void\>): void 1664 1665通过TCPSocket连接发送数据。使用callback方式作为异步方法。 1666 1667> **说明：** 1668> connect方法调用成功后，才可调用此方法。该接口为耗时操作，请在Worker线程或taskpool线程调用该接口。 1669 1670**需要权限**：ohos.permission.INTERNET 1671 1672**系统能力**：SystemCapability.Communication.NetStack 1673 1674**参数：** 1675 1676| 参数名 | 类型 | 必填 | 说明 | 1677| -------- | --------------------------------------- | ---- | ------------------------------------------------------------ | 1678| options | [TCPSendOptions](#tcpsendoptions) | 是 | TCPSocket发送请求的参数，参考[TCPSendOptions](#tcpsendoptions)。 | 1679| callback | AsyncCallback\<void\> | 是 | 回调函数。失败返回错误码、错误信息。 | 1680 1681**错误码：** 1682 1683| 错误码ID | 错误信息 | 1684| ------- | ----------------------- | 1685| 401 | Parameter error. | 1686| 201 | Permission denied. | 1687 1688**示例：** 1689 1690```ts 1691import { socket } from '@kit.NetworkKit'; 1692import { BusinessError } from '@kit.BasicServicesKit'; 1693 1694let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1695let netAddress: socket.NetAddress = { 1696 address: '192.168.xx.xxx', 1697 port: 8080 1698} 1699let tcpconnectoptions: socket.TCPConnectOptions = { 1700 address: netAddress, 1701 timeout: 6000 1702} 1703tcp.connect(tcpconnectoptions, () => { 1704 console.log('connect success'); 1705 let tcpSendOptions: socket.TCPSendOptions = { 1706 data: 'Hello, server!' 1707 } 1708 tcp.send(tcpSendOptions, (err: BusinessError) => { 1709 if (err) { 1710 console.log('send fail'); 1711 return; 1712 } 1713 console.log('send success'); 1714 }) 1715}) 1716``` 1717 1718### send 1719 1720send(options: TCPSendOptions): Promise\<void\> 1721 1722通过TCPSocket连接发送数据。使用Promise方式作为异步方法。 1723 1724> **说明：** 1725> connect方法调用成功后，才可调用此方法。该接口为耗时操作，请在Worker线程或taskpool线程调用该接口。 1726 1727**需要权限**：ohos.permission.INTERNET 1728 1729**系统能力**：SystemCapability.Communication.NetStack 1730 1731**参数：** 1732 1733| 参数名 | 类型 | 必填 | 说明 | 1734| ------- | --------------------------------------- | ---- | ------------------------------------------------------------ | 1735| options | [TCPSendOptions](#tcpsendoptions) | 是 | TCPSocket发送请求的参数，参考[TCPSendOptions](#tcpsendoptions)。 | 1736 1737**返回值：** 1738 1739| 类型 | 说明 | 1740| -------------- | ------------------------------------------------- | 1741| Promise\<void\> | 以Promise形式返回通过TCPSocket连接发送数据的结果。 | 1742 1743**错误码：** 1744 1745| 错误码ID | 错误信息 | 1746| ------- | ----------------------- | 1747| 401 | Parameter error. | 1748| 201 | Permission denied. | 1749 1750**示例：** 1751 1752```ts 1753import { socket } from '@kit.NetworkKit'; 1754import { BusinessError } from '@kit.BasicServicesKit'; 1755 1756let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1757let netAddress: socket.NetAddress = { 1758 address: '192.168.xx.xxx', 1759 port: 8080 1760} 1761let tcpconnectoptions: socket.TCPConnectOptions = { 1762 address: netAddress, 1763 timeout: 6000 1764} 1765tcp.connect(tcpconnectoptions, () => { 1766 console.log('connect success'); 1767 let tcpSendOptions: socket.TCPSendOptions = { 1768 data: 'Hello, server!' 1769 } 1770 tcp.send(tcpSendOptions).then(() => { 1771 console.log('send success'); 1772 }).catch((err: BusinessError) => { 1773 console.log('send fail'); 1774 }); 1775}) 1776``` 1777 1778### close 1779 1780close(callback: AsyncCallback\<void\>): void 1781 1782关闭TCPSocket连接。使用callback方式作为异步方法。 1783 1784**需要权限**：ohos.permission.INTERNET 1785 1786**系统能力**：SystemCapability.Communication.NetStack 1787 1788**参数：** 1789 1790| 参数名 | 类型 | 必填 | 说明 | 1791| -------- | --------------------- | ---- | ---------- | 1792| callback | AsyncCallback\<void\> | 是 | 回调函数。失败返回错误码、错误信息。 | 1793 1794**错误码：** 1795 1796| 错误码ID | 错误信息 | 1797| ------- | ----------------------- | 1798| 201 | Permission denied. | 1799 1800**示例：** 1801 1802```ts 1803import { socket } from '@kit.NetworkKit'; 1804import { BusinessError } from '@kit.BasicServicesKit'; 1805 1806let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1807 1808tcp.close((err: BusinessError) => { 1809 if (err) { 1810 console.log('close fail'); 1811 return; 1812 } 1813 console.log('close success'); 1814}) 1815``` 1816 1817### close 1818 1819close(): Promise\<void\> 1820 1821关闭TCPSocket连接。使用Promise方式作为异步方法。 1822 1823**需要权限**：ohos.permission.INTERNET 1824 1825**系统能力**：SystemCapability.Communication.NetStack 1826 1827**返回值：** 1828 1829| 类型 | 说明 | 1830| -------------- | ----------------------------------------- | 1831| Promise\<void\> | 以Promise形式返回关闭TCPSocket连接的结果。 | 1832 1833**错误码：** 1834 1835| 错误码ID | 错误信息 | 1836| ------- | ----------------------- | 1837| 201 | Permission denied. | 1838 1839**示例：** 1840 1841```ts 1842import { socket } from '@kit.NetworkKit'; 1843 1844let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1845 1846tcp.close().then(() => { 1847 console.log('close success'); 1848}).catch((err: BusinessError) => { 1849 console.log('close fail'); 1850}); 1851``` 1852 1853### getRemoteAddress 1854 1855getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void 1856 1857获取对端Socket地址。使用callback方式作为异步方法。 1858 1859> **说明：** 1860> connect方法调用成功后，才可调用此方法。 1861 1862**需要权限**：ohos.permission.INTERNET 1863 1864**系统能力**：SystemCapability.Communication.NetStack 1865 1866**参数：** 1867 1868| 参数名 | 类型 | 必填 | 说明 | 1869| -------- | ------------------------------------------------- | ---- | ---------- | 1870| callback | AsyncCallback\<[NetAddress](#netaddress)\> | 是 | 回调函数。成功时返回对端Socket地址，失败时返回错误码、错误信息。 | 1871 1872**错误码：** 1873 1874| 错误码ID | 错误信息 | 1875| ------- | ----------------------- | 1876| 201 | Permission denied. | 1877 1878**示例：** 1879 1880```ts 1881import { socket } from '@kit.NetworkKit'; 1882import { BusinessError } from '@kit.BasicServicesKit'; 1883 1884let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1885let netAddress: socket.NetAddress = { 1886 address: '192.168.xx.xxx', 1887 port: 8080 1888} 1889let tcpconnectoptions: socket.TCPConnectOptions = { 1890 address: netAddress, 1891 timeout: 6000 1892} 1893tcp.connect(tcpconnectoptions, () => { 1894 console.log('connect success'); 1895 tcp.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => { 1896 if (err) { 1897 console.log('getRemoteAddressfail'); 1898 return; 1899 } 1900 console.log('getRemoteAddresssuccess:' + JSON.stringify(data)); 1901 }) 1902}); 1903``` 1904 1905### getRemoteAddress 1906 1907getRemoteAddress(): Promise\<NetAddress\> 1908 1909获取对端Socket地址。使用Promise方式作为异步方法。 1910 1911> **说明：** 1912> connect方法调用成功后，才可调用此方法。 1913 1914**需要权限**：ohos.permission.INTERNET 1915 1916**系统能力**：SystemCapability.Communication.NetStack 1917 1918**返回值：** 1919 1920| 类型 | 说明 | 1921| ------------------------------------------ | ------------------------------------------ | 1922| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取对端socket地址的结果。 | 1923 1924**错误码：** 1925 1926| 错误码ID | 错误信息 | 1927| ------- | ----------------------- | 1928| 201 | Permission denied. | 1929 1930**示例：** 1931 1932```ts 1933import { socket } from '@kit.NetworkKit'; 1934import { BusinessError } from '@kit.BasicServicesKit'; 1935 1936let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1937let netAddress: socket.NetAddress = { 1938 address: '192.168.xx.xxx', 1939 port: 8080 1940} 1941let tcpconnectoptions: socket.TCPConnectOptions = { 1942 address: netAddress, 1943 timeout: 6000 1944} 1945tcp.connect(tcpconnectoptions).then(() => { 1946 console.log('connect success'); 1947 tcp.getRemoteAddress().then(() => { 1948 console.log('getRemoteAddress success'); 1949 }).catch((err: BusinessError) => { 1950 console.log('getRemoteAddressfail'); 1951 }); 1952}).catch((err: BusinessError) => { 1953 console.log('connect fail'); 1954}); 1955``` 1956 1957### getState 1958 1959getState(callback: AsyncCallback\<SocketStateBase\>): void 1960 1961获取TCPSocket状态。使用callback方式作为异步方法。 1962 1963> **说明：** 1964> bind或connect方法调用成功后，才可调用此方法。 1965 1966**需要权限**：ohos.permission.INTERNET 1967 1968**系统能力**：SystemCapability.Communication.NetStack 1969 1970**参数：** 1971 1972| 参数名 | 类型 | 必填 | 说明 | 1973| -------- | ------------------------------------------------------ | ---- | ---------- | 1974| callback | AsyncCallback\<[SocketStateBase](#socketstatebase)\> | 是 | 回调函数。成功时获取TCPSocket状态，失败时返回错误码、错误信息。 | 1975 1976**错误码：** 1977 1978| 错误码ID | 错误信息 | 1979| ------- | ----------------------- | 1980| 201 | Permission denied. | 1981 1982**示例：** 1983 1984```ts 1985import { socket } from '@kit.NetworkKit'; 1986import { BusinessError } from '@kit.BasicServicesKit'; 1987 1988let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 1989let netAddress: socket.NetAddress = { 1990 address: '192.168.xx.xxx', 1991 port: 8080 1992} 1993let tcpconnectoptions: socket.TCPConnectOptions = { 1994 address: netAddress, 1995 timeout: 6000 1996} 1997tcp.connect(tcpconnectoptions, () => { 1998 console.log('connect success'); 1999 tcp.getState((err: BusinessError, data: socket.SocketStateBase) => { 2000 if (err) { 2001 console.log('getState fail'); 2002 return; 2003 } 2004 console.log('getState success:' + JSON.stringify(data)); 2005 }); 2006}); 2007``` 2008 2009### getState 2010 2011getState(): Promise\<SocketStateBase\> 2012 2013获取TCPSocket状态。使用Promise方式作为异步方法。 2014 2015> **说明：** 2016> bind或connect方法调用成功后，才可调用此方法。 2017 2018**需要权限**：ohos.permission.INTERNET 2019 2020**系统能力**：SystemCapability.Communication.NetStack 2021 2022**返回值：** 2023 2024| 类型 | 说明 | 2025| ----------------------------------------------- | ----------------------------------------- | 2026| Promise\<[SocketStateBase](#socketstatebase)\> | 以Promise形式返回获取TCPSocket状态的结果。 | 2027 2028**错误码：** 2029 2030| 错误码ID | 错误信息 | 2031| ------- | ----------------------- | 2032| 201 | Permission denied. | 2033 2034**示例：** 2035 2036```ts 2037import { socket } from '@kit.NetworkKit'; 2038import { BusinessError } from '@kit.BasicServicesKit'; 2039 2040let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2041let netAddress: socket.NetAddress = { 2042 address: '192.168.xx.xxx', 2043 port: 8080 2044} 2045let tcpconnectoptions: socket.TCPConnectOptions = { 2046 address: netAddress, 2047 timeout: 6000 2048} 2049tcp.connect(tcpconnectoptions).then(() => { 2050 console.log('connect success'); 2051 tcp.getState().then(() => { 2052 console.log('getState success'); 2053 }).catch((err: BusinessError) => { 2054 console.log('getState fail'); 2055 }); 2056}).catch((err: BusinessError) => { 2057 console.log('connect fail'); 2058}); 2059``` 2060 2061### getSocketFd<sup>10+</sup> 2062 2063getSocketFd(callback: AsyncCallback\<number\>): void 2064 2065获取TCPSocket的文件描述符。使用callback方式作为异步方法。 2066 2067> **说明：** 2068> bind或connect方法调用成功后，才可调用此方法。 2069 2070**系统能力**：SystemCapability.Communication.NetStack 2071 2072**参数：** 2073 2074| 参数名 | 类型 | 必填 | 说明 | 2075| -------- | ------------------------------------------------------ | ---- | ---------- | 2076| callback | AsyncCallback\<number\> | 是 | 回调函数，当成功时，返回socket的文件描述符，失败时，返回undefined。 | 2077 2078**示例：** 2079 2080```ts 2081import { socket } from '@kit.NetworkKit'; 2082import { BusinessError } from '@kit.BasicServicesKit'; 2083 2084let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2085let bindAddr: socket.NetAddress = { 2086 address: '0.0.0.0' 2087} 2088tcp.bind(bindAddr) 2089let netAddress: socket.NetAddress = { 2090 address: '192.168.xx.xxx', 2091 port: 8080 2092} 2093let tcpconnectoptions: socket.TCPConnectOptions = { 2094 address: netAddress, 2095 timeout: 6000 2096} 2097tcp.connect(tcpconnectoptions) 2098tcp.getSocketFd((err: BusinessError, data: number) => { 2099 console.info("getSocketFd failed: " + err); 2100 console.info("tunenlfd: " + data); 2101}) 2102``` 2103### getSocketFd<sup>10+</sup> 2104 2105getSocketFd(): Promise\<number\> 2106 2107获取TCPSocket的文件描述符。使用Promise方式作为异步方法。 2108 2109> **说明：** 2110> bind或connect方法调用成功后，才可调用此方法。 2111 2112**系统能力**：SystemCapability.Communication.NetStack 2113 2114**返回值：** 2115 2116| 类型 | 说明 | 2117| ----------------------------------------------- | ----------------------------------------- | 2118| Promise\<number\> | 以Promise形式返回socket的文件描述符。 | 2119 2120**示例：** 2121 2122```ts 2123import { socket } from '@kit.NetworkKit'; 2124import { BusinessError } from '@kit.BasicServicesKit'; 2125 2126let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2127let bindAddr: socket.NetAddress = { 2128 address: '0.0.0.0' 2129} 2130tcp.bind(bindAddr) 2131let netAddress: socket.NetAddress = { 2132 address: '192.168.xx.xxx', 2133 port: 8080 2134} 2135let tcpconnectoptions: socket.TCPConnectOptions = { 2136 address: netAddress, 2137 timeout: 6000 2138} 2139tcp.connect(tcpconnectoptions) 2140tcp.getSocketFd().then((data: number) => { 2141 console.info("tunenlfd: " + data); 2142}) 2143``` 2144 2145### setExtraOptions 2146 2147setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void 2148 2149设置TCPSocket连接的其他属性。使用callback方式作为异步方法。 2150 2151> **说明：** 2152> bind或connect方法调用成功后，才可调用此方法。 2153 2154**需要权限**：ohos.permission.INTERNET 2155 2156**系统能力**：SystemCapability.Communication.NetStack 2157 2158**参数：** 2159 2160| 参数名 | 类型 | 必填 | 说明 | 2161| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 2162| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 | 2163| callback | AsyncCallback\<void\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 2164 2165**错误码：** 2166 2167| 错误码ID | 错误信息 | 2168| ------- | ----------------------- | 2169| 401 | Parameter error. | 2170| 201 | Permission denied. | 2171 2172**示例：** 2173 2174```ts 2175import { socket } from '@kit.NetworkKit'; 2176import { BusinessError } from '@kit.BasicServicesKit'; 2177 2178let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2179let netAddress: socket.NetAddress = { 2180 address: '192.168.xx.xxx', 2181 port: 8080 2182} 2183let tcpconnectoptions: socket.TCPConnectOptions = { 2184 address: netAddress, 2185 timeout: 6000 2186} 2187 2188interface SocketLinger { 2189 on: boolean; 2190 linger: number; 2191} 2192 2193tcp.connect(tcpconnectoptions, () => { 2194 console.log('connect success'); 2195 let tcpExtraOptions: socket.TCPExtraOptions = { 2196 keepAlive: true, 2197 OOBInline: true, 2198 TCPNoDelay: true, 2199 socketLinger: { on: true, linger: 10 } as SocketLinger, 2200 receiveBufferSize: 1000, 2201 sendBufferSize: 1000, 2202 reuseAddress: true, 2203 socketTimeout: 3000 2204 } 2205 tcp.setExtraOptions(tcpExtraOptions, (err: BusinessError) => { 2206 if (err) { 2207 console.log('setExtraOptions fail'); 2208 return; 2209 } 2210 console.log('setExtraOptions success'); 2211 }); 2212}); 2213``` 2214 2215### setExtraOptions 2216 2217setExtraOptions(options: TCPExtraOptions): Promise\<void\> 2218 2219设置TCPSocket连接的其他属性，使用Promise方式作为异步方法。 2220 2221> **说明：** 2222> bind或connect方法调用成功后，才可调用此方法。 2223 2224**需要权限**：ohos.permission.INTERNET 2225 2226**系统能力**：SystemCapability.Communication.NetStack 2227 2228**参数：** 2229 2230| 参数名 | 类型 | 必填 | 说明 | 2231| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 2232| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 | 2233 2234**返回值：** 2235 2236| 类型 | 说明 | 2237| -------------- | --------------------------------------------------- | 2238| Promise\<void\> | 以Promise形式返回设置TCPSocket连接的其他属性的结果。 | 2239 2240**错误码：** 2241 2242| 错误码ID | 错误信息 | 2243| ------- | ----------------------- | 2244| 401 | Parameter error. | 2245| 201 | Permission denied. | 2246 2247**示例：** 2248 2249```ts 2250import { socket } from '@kit.NetworkKit'; 2251import { BusinessError } from '@kit.BasicServicesKit'; 2252 2253let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2254let netAddress: socket.NetAddress = { 2255 address: '192.168.xx.xxx', 2256 port: 8080 2257} 2258let tcpconnectoptions: socket.TCPConnectOptions = { 2259 address: netAddress, 2260 timeout: 6000 2261} 2262 2263interface SocketLinger { 2264 on: boolean; 2265 linger: number; 2266} 2267 2268tcp.connect(tcpconnectoptions, () => { 2269 console.log('connect success'); 2270 let tcpExtraOptions: socket.TCPExtraOptions = { 2271 keepAlive: true, 2272 OOBInline: true, 2273 TCPNoDelay: true, 2274 socketLinger: { on: true, linger: 10 } as SocketLinger, 2275 receiveBufferSize: 1000, 2276 sendBufferSize: 1000, 2277 reuseAddress: true, 2278 socketTimeout: 3000 2279 } 2280 tcp.setExtraOptions(tcpExtraOptions).then(() => { 2281 console.log('setExtraOptions success'); 2282 }).catch((err: BusinessError) => { 2283 console.log('setExtraOptions fail'); 2284 }); 2285}); 2286``` 2287 2288### getLocalAddress<sup>12+</sup> 2289 2290getLocalAddress(): Promise\<NetAddress\> 2291 2292获取TCPSocket的本地Socket地址。使用Promise方式作为异步方法。 2293 2294> **说明：** 2295> bind方法调用成功后，才可调用此方法。 2296 2297**系统能力**：SystemCapability.Communication.NetStack 2298 2299**返回值：** 2300 2301| 类型 | 说明 | 2302| -------------- | --------------------------------------------------- | 2303| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取本地socket地址的结果。 | 2304 2305**错误码：** 2306 2307| 错误码ID | 错误信息 | 2308| -------- | ------------------------------------------- | 2309| 2300002 | System internal error. | 2310| 2301009 | Bad file descriptor. | 2311| 2303188 | Socket operation on non-socket. | 2312 2313**示例：** 2314 2315```ts 2316import { socket } from '@kit.NetworkKit'; 2317import { BusinessError } from '@kit.BasicServicesKit'; 2318 2319let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2320let bindAddr: socket.NetAddress = { 2321 address: '192.168.xx.xxx', 2322 family: 1, 2323 port: 8080 2324} 2325tcp.bind(bindAddr).then(() => { 2326 tcp.getLocalAddress().then((localAddress: socket.NetAddress) => { 2327 console.info("SUCCESS! Address:" + JSON.stringify(localAddress)); 2328 }).catch((err: BusinessError) => { 2329 console.error("FAILED! Error:" + JSON.stringify(err)); 2330 }) 2331}).catch((err: BusinessError) => { 2332 console.error('bind fail'); 2333}); 2334``` 2335 2336### on('message') 2337 2338on(type: 'message', callback: Callback<SocketMessageInfo\>): void 2339 2340订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。 2341 2342**系统能力**：SystemCapability.Communication.NetStack 2343 2344**参数：** 2345 2346| 参数名 | 类型 | 必填 | 说明 | 2347| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 2348| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 2349| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 是 | 回调函数。返回TCPSocket连接信息。 | 2350 2351**示例：** 2352 2353```ts 2354import { socket } from '@kit.NetworkKit'; 2355import { BusinessError } from '@kit.BasicServicesKit'; 2356 2357let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2358let messageView = ''; 2359tcp.on('message', (value: socket.SocketMessageInfo) => { 2360 for (let i: number = 0; i < value.message.byteLength; i++) { 2361 let uint8Array = new Uint8Array(value.message) 2362 let messages = uint8Array[i] 2363 let message = String.fromCharCode(messages); 2364 messageView += message; 2365 } 2366 console.log('on message message: ' + JSON.stringify(messageView)); 2367 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 2368}); 2369``` 2370 2371### off('message') 2372 2373off(type: 'message', callback?: Callback<SocketMessageInfo\>): void 2374 2375取消订阅TCPSocket连接的接收消息事件。使用callback方式作为异步方法。 2376 2377**系统能力**：SystemCapability.Communication.NetStack 2378 2379**参数：** 2380 2381| 参数名 | 类型 | 必填 | 说明 | 2382| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 2383| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 2384| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 否 | 回调函数。取消订阅TCPSocket连接的接收消息事件时触发回调函数。 | 2385 2386**示例：** 2387 2388```ts 2389import { socket } from '@kit.NetworkKit'; 2390import { BusinessError } from '@kit.BasicServicesKit'; 2391 2392let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2393let messageView = ''; 2394let callback = (value: socket.SocketMessageInfo) => { 2395 for (let i: number = 0; i < value.message.byteLength; i++) { 2396 let uint8Array = new Uint8Array(value.message) 2397 let messages = uint8Array[i] 2398 let message = String.fromCharCode(messages); 2399 messageView += message; 2400 } 2401 console.log('on message message: ' + JSON.stringify(messageView)); 2402 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 2403} 2404tcp.on('message', callback); 2405// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2406tcp.off('message', callback); 2407tcp.off('message'); 2408``` 2409 2410### on('connect' | 'close') 2411 2412on(type: 'connect' | 'close', callback: Callback\<void\>): void 2413 2414订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。 2415 2416**系统能力**：SystemCapability.Communication.NetStack 2417 2418**参数：** 2419 2420| 参数名 | 类型 | 必填 | 说明 | 2421| -------- | ---------------- | ---- | ------------------------------------------------------------ | 2422| type | string | 是 | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 | 2423| callback | Callback\<void\> | 是 | 回调函数。TCPSocket的连接事件或关闭事件触发时调用回调函数。 | 2424 2425**示例：** 2426 2427```ts 2428import { socket } from '@kit.NetworkKit'; 2429import { BusinessError } from '@kit.BasicServicesKit'; 2430 2431let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2432tcp.on('connect', () => { 2433 console.log("on connect success") 2434}); 2435tcp.on('close', () => { 2436 console.log("on close success") 2437}); 2438``` 2439 2440### off('connect' | 'close') 2441 2442off(type: 'connect' | 'close', callback?: Callback\<void\>): void 2443 2444取消订阅TCPSocket的连接事件或关闭事件。使用callback方式作为异步方法。 2445 2446**系统能力**：SystemCapability.Communication.NetStack 2447 2448**参数：** 2449 2450| 参数名 | 类型 | 必填 | 说明 | 2451| -------- | ---------------- | ---- | ------------------------------------------------------------ | 2452| type | string | 是 | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 | 2453| callback | Callback\<void\> | 否 | 回调函数。TCPSocket的连接事件或关闭事件触发时调用回调函数。 | 2454 2455**示例：** 2456 2457```ts 2458import { socket } from '@kit.NetworkKit'; 2459import { BusinessError } from '@kit.BasicServicesKit'; 2460 2461let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2462let callback1 = () => { 2463 console.log("on connect success"); 2464} 2465tcp.on('connect', callback1); 2466// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2467tcp.off('connect', callback1); 2468tcp.off('connect'); 2469let callback2 = () => { 2470 console.log("on close success"); 2471} 2472tcp.on('close', callback2); 2473// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2474tcp.off('close', callback2); 2475tcp.off('close'); 2476``` 2477 2478### on('error') 2479 2480on(type: 'error', callback: ErrorCallback): void 2481 2482订阅TCPSocket连接的error事件。使用callback方式作为异步方法。 2483 2484**系统能力**：SystemCapability.Communication.NetStack 2485 2486**参数：** 2487 2488| 参数名 | 类型 | 必填 | 说明 | 2489| -------- | ------------- | ---- | ------------------------------------ | 2490| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 2491| callback | ErrorCallback | 是 | 回调函数。TCPSocket连接订阅的某类error事件触发时调用回调函数。 | 2492 2493**示例：** 2494 2495```ts 2496import { socket } from '@kit.NetworkKit'; 2497import { BusinessError } from '@kit.BasicServicesKit'; 2498 2499let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2500tcp.on('error', (err: BusinessError) => { 2501 console.log("on error, err:" + JSON.stringify(err)) 2502}); 2503``` 2504 2505### off('error') 2506 2507off(type: 'error', callback?: ErrorCallback): void 2508 2509取消订阅TCPSocket连接的error事件。使用callback方式作为异步方法。 2510 2511**系统能力**：SystemCapability.Communication.NetStack 2512 2513**参数：** 2514 2515| 参数名 | 类型 | 必填 | 说明 | 2516| -------- | ------------- | ---- | ------------------------------------ | 2517| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 2518| callback | ErrorCallback | 否 | 回调函数。TCPSocket连接取消订阅的某类error事件触发时调用回调函数。 | 2519 2520**示例：** 2521 2522```ts 2523import { socket } from '@kit.NetworkKit'; 2524import { BusinessError } from '@kit.BasicServicesKit'; 2525 2526let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 2527let callback = (err: BusinessError) => { 2528 console.log("on error, err:" + JSON.stringify(err)); 2529} 2530tcp.on('error', callback); 2531// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 2532tcp.off('error', callback); 2533tcp.off('error'); 2534``` 2535 2536## TCPConnectOptions 2537 2538TCPSocket连接的参数。 2539 2540**系统能力**：SystemCapability.Communication.NetStack 2541 2542| 名称 | 类型 | 必填 | 说明 | 2543| ------- | ---------------------------------- | ---- | -------------------------- | 2544| address | [NetAddress](#netaddress) | 是 | 绑定的地址以及端口。 | 2545| timeout | number | 否 | 超时时间，单位毫秒（ms）。 | 2546 2547## TCPSendOptions 2548 2549TCPSocket发送请求的参数。 2550 2551**系统能力**：SystemCapability.Communication.NetStack 2552 2553| 名称 | 类型 | 必填 | 说明 | 2554| -------- | ------ | ---- | ------------------------------------------------------------ | 2555| data | string\| ArrayBuffer | 是 | 发送的数据。 | 2556| encoding | string | 否 | 字符编码(UTF-8，UTF-16BE，UTF-16LE，UTF-16，US-AECII，ISO-8859-1)，默认为UTF-8。 | 2557 2558## TCPExtraOptions 2559 2560TCPSocket连接的其他属性。继承自[ExtraOptionsBase](#extraoptionsbase7)。 2561 2562**系统能力**：SystemCapability.Communication.NetStack 2563 2564| 名称 | 类型 | 必填 | 说明 | 2565| ----------------- | ------- | ---- | ------------------------------------------------------------ | 2566| keepAlive | boolean | 否 | 是否保持连接。默认为false。 | 2567| OOBInline | boolean | 否 | 是否为OOB内联。默认为false。 | 2568| TCPNoDelay | boolean | 否 | TCPSocket连接是否无时延。默认为false。 | 2569| socketLinger | \{on:boolean, linger:number\} | 否 | socket是否继续逗留。<br />- on：是否逗留（true：逗留；false：不逗留）。<br />- linger：逗留时长，单位毫秒（ms），取值范围为0~65535。<br />当入参on设置为true时，才需要设置。 | 2570 2571## socket.constructTCPSocketServerInstance<sup>10+</sup> 2572 2573constructTCPSocketServerInstance(): TCPSocketServer 2574 2575创建一个TCPSocketServer对象。 2576 2577**系统能力**：SystemCapability.Communication.NetStack 2578 2579**返回值：** 2580 2581| 类型 | 说明 | 2582| ---------------------------------- | ---------------------------- | 2583| [TCPSocketServer](#tcpsocketserver10) | 返回一个TCPSocketServer对象。 | 2584 2585**示例：** 2586 2587```ts 2588import { socket } from '@kit.NetworkKit'; 2589let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2590``` 2591 2592## TCPSocketServer<sup>10+</sup> 2593 2594TCPSocketServer连接。在调用TCPSocketServer的方法前，需要先通过[socket.constructTCPSocketServerInstance](#socketconstructtcpsocketserverinstance10)创建TCPSocketServer对象。 2595 2596### listen<sup>10+</sup> 2597 2598listen(address: NetAddress, callback: AsyncCallback\<void\>): void 2599 2600绑定IP地址和端口，端口可以指定或由系统随机分配。监听并接受与此套接字建立的TCPSocket连接。该接口使用多线程并发处理客户端的数据。使用callback方法作为异步方法。 2601 2602> **说明：** 2603> 服务端使用该方法完成bind，listen，accept操作，bind方法失败会由系统随机分配端口号。 2604 2605**需要权限**：ohos.permission.INTERNET 2606 2607**系统能力**：SystemCapability.Communication.NetStack 2608 2609**参数：** 2610 2611| 参数名 | 类型 | 必填 | 说明 | 2612| -------- | ------------------------- | ---- | --------------------------------------------- | 2613| address | [NetAddress](#netaddress) | 是 | 目标地址信息。 | 2614| callback | AsyncCallback\<void\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 2615 2616**错误码：** 2617 2618| 错误码ID | 错误信息 | 2619| -------- | ------------------------------------------- | 2620| 401 | Parameter error. | 2621| 201 | Permission denied. | 2622| 2300002 | System internal error. | 2623| 2303109 | Bad file number. | 2624| 2303111 | Resource temporarily unavailable. Try again.| 2625| 2303198 | Address already in use. | 2626| 2303199 | Cannot assign requested address. | 2627 2628**示例：** 2629 2630```ts 2631import { socket } from '@kit.NetworkKit'; 2632import { BusinessError } from '@kit.BasicServicesKit'; 2633 2634let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2635let listenAddr: socket.NetAddress = { 2636 address: '192.168.xx.xxx', 2637 port: 8080, 2638 family: 1 2639} 2640tcpServer.listen(listenAddr, (err: BusinessError) => { 2641 if (err) { 2642 console.log("listen fail"); 2643 return; 2644 } 2645 console.log("listen success"); 2646}) 2647``` 2648 2649### listen<sup>10+</sup> 2650 2651listen(address: NetAddress): Promise\<void\> 2652 2653绑定IP地址和端口，端口可以指定或由系统随机分配。监听并接受与此套接字建立的TCPSocket连接。该接口使用多线程并发处理客户端的数据。使用Promise方法作为异步方法。 2654 2655> **说明：** 2656> 服务端使用该方法完成bind，listen，accept操作，bind方法失败会由系统随机分配端口号。 2657 2658**需要权限**：ohos.permission.INTERNET 2659 2660**系统能力**：SystemCapability.Communication.NetStack 2661 2662**参数：** 2663 2664| 参数名 | 类型 | 必填 | 说明 | 2665| ------- | ------------------------- | ---- | --------------------------------------------- | 2666| address | [NetAddress](#netaddress) | 是 | 目标地址信息。 | 2667 2668**返回值：** 2669 2670| 类型 | 说明 | 2671| -------------- | ----------------------------------------------------------- | 2672| Promise\<void\> | 以Promise形式返回, 成功返回空，失败返回错误码错误信息。| 2673 2674**错误码：** 2675 2676| 错误码ID | 错误信息 | 2677| -------- | ------------------------------------------- | 2678| 401 | Parameter error. | 2679| 201 | Permission denied. | 2680| 2300002 | System internal error. | 2681| 2303109 | Bad file number. | 2682| 2303111 | Resource temporarily unavailable. Try again.| 2683| 2303198 | Address already in use. | 2684| 2303199 | Cannot assign requested address. | 2685 2686**示例：** 2687 2688```ts 2689import { socket } from '@kit.NetworkKit'; 2690import { BusinessError } from '@kit.BasicServicesKit'; 2691 2692let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2693let listenAddr: socket.NetAddress = { 2694 address: '192.168.xx.xxx', 2695 port: 8080, 2696 family: 1 2697} 2698tcpServer.listen(listenAddr).then(() => { 2699 console.log('listen success'); 2700}).catch((err: BusinessError) => { 2701 console.log('listen fail'); 2702}); 2703``` 2704 2705### getState<sup>10+</sup> 2706 2707getState(callback: AsyncCallback\<SocketStateBase\>): void 2708 2709获取TCPSocketServer状态。使用callback方式作为异步方法。 2710 2711> **说明：** 2712> listen方法调用成功后，才可调用此方法。 2713 2714**需要权限**：ohos.permission.INTERNET 2715 2716**系统能力**：SystemCapability.Communication.NetStack 2717 2718**参数：** 2719 2720| 参数名 | 类型 | 必填 | 说明 | 2721| -------- | -------------------------------------------------- | ---- | ---------- | 2722| callback | AsyncCallback\<[SocketStateBase](#socketstatebase)\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 2723 2724**错误码：** 2725 2726| 错误码ID | 错误信息 | 2727| -------- | ------------------------------- | 2728| 401 | Parameter error. | 2729| 201 | Permission denied. | 2730| 2300002 | System internal error. | 2731| 2303188 | Socket operation on non-socket. | 2732 2733**示例：** 2734 2735```ts 2736import { socket } from '@kit.NetworkKit'; 2737import { BusinessError } from '@kit.BasicServicesKit'; 2738 2739let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2740let listenAddr: socket.NetAddress = { 2741 address: '192.168.xx.xxx', 2742 port: 8080, 2743 family: 1 2744} 2745tcpServer.listen(listenAddr, (err: BusinessError) => { 2746 if (err) { 2747 console.log("listen fail"); 2748 return; 2749 } 2750 console.log("listen success"); 2751}) 2752tcpServer.getState((err: BusinessError, data: socket.SocketStateBase) => { 2753 if (err) { 2754 console.log('getState fail'); 2755 return; 2756 } 2757 console.log('getState success:' + JSON.stringify(data)); 2758}) 2759``` 2760 2761### getState<sup>10+</sup> 2762 2763getState(): Promise\<SocketStateBase\> 2764 2765获取TCPSocketServer状态。使用Promise方式作为异步方法。 2766 2767> **说明：** 2768> listen方法调用成功后，才可调用此方法。 2769 2770**需要权限**：ohos.permission.INTERNET 2771 2772**系统能力**：SystemCapability.Communication.NetStack 2773 2774**返回值：** 2775 2776| 类型 | 说明 | 2777| ------------------------------------------- | ----------------------------------------- | 2778| Promise\<[SocketStateBase](#socketstatebase)\> | 以Promise形式返回获取TCPSocket状态的结果。 | 2779 2780**错误码：** 2781 2782| 错误码ID | 错误信息 | 2783| -------- | ------------------------------- | 2784| 201 | Permission denied. | 2785| 2300002 | System internal error. | 2786| 2303188 | Socket operation on non-socket. | 2787 2788**示例：** 2789 2790```ts 2791import { socket } from '@kit.NetworkKit'; 2792import { BusinessError } from '@kit.BasicServicesKit'; 2793 2794let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2795let listenAddr: socket.NetAddress = { 2796 address: '192.168.xx.xxx', 2797 port: 8080, 2798 family: 1 2799} 2800tcpServer.listen(listenAddr, (err: BusinessError) => { 2801 if (err) { 2802 console.log("listen fail"); 2803 return; 2804 } 2805 console.log("listen success"); 2806}) 2807tcpServer.getState().then((data: socket.SocketStateBase) => { 2808 console.log('getState success' + JSON.stringify(data)); 2809}).catch((err: BusinessError) => { 2810 console.log('getState fail'); 2811}); 2812``` 2813 2814### setExtraOptions<sup>10+</sup> 2815 2816setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void 2817 2818设置TCPSocketServer连接的其他属性。使用callback方式作为异步方法。 2819 2820> **说明：** 2821> listen方法调用成功后，才可调用此方法。 2822 2823**需要权限**：ohos.permission.INTERNET 2824 2825**系统能力**：SystemCapability.Communication.NetStack 2826 2827**参数：** 2828 2829| 参数名 | 类型 | 必填 | 说明 | 2830| -------- | ----------------------------------- | ---- | ------------------------------------------------------------ | 2831| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocketServer连接的其他属性。 | 2832| callback | AsyncCallback\<void\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 2833 2834**错误码：** 2835 2836| 错误码ID | 错误信息 | 2837| -------- | ------------------------------- | 2838| 401 | Parameter error. | 2839| 201 | Permission denied. | 2840| 2300002 | System internal error. | 2841| 2303188 | Socket operation on non-socket. | 2842 2843**示例：** 2844 2845```ts 2846import { socket } from '@kit.NetworkKit'; 2847import { BusinessError } from '@kit.BasicServicesKit'; 2848 2849let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2850let listenAddr: socket.NetAddress = { 2851 address: '192.168.xx.xxx', 2852 port: 8080, 2853 family: 1 2854} 2855tcpServer.listen(listenAddr, (err: BusinessError) => { 2856 if (err) { 2857 console.log("listen fail"); 2858 return; 2859 } 2860 console.log("listen success"); 2861}) 2862 2863interface SocketLinger { 2864 on: boolean; 2865 linger: number; 2866} 2867 2868let tcpExtraOptions: socket.TCPExtraOptions = { 2869 keepAlive: true, 2870 OOBInline: true, 2871 TCPNoDelay: true, 2872 socketLinger: { on: true, linger: 10 } as SocketLinger, 2873 receiveBufferSize: 1000, 2874 sendBufferSize: 1000, 2875 reuseAddress: true, 2876 socketTimeout: 3000 2877} 2878tcpServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => { 2879 if (err) { 2880 console.log('setExtraOptions fail'); 2881 return; 2882 } 2883 console.log('setExtraOptions success'); 2884}); 2885``` 2886 2887### setExtraOptions<sup>10+</sup> 2888 2889setExtraOptions(options: TCPExtraOptions): Promise\<void\> 2890 2891设置TCPSocketServer连接的其他属性，使用Promise方式作为异步方法。 2892 2893> **说明：** 2894> listen方法调用成功后，才可调用此方法。 2895 2896**需要权限**：ohos.permission.INTERNET 2897 2898**系统能力**：SystemCapability.Communication.NetStack 2899 2900**参数：** 2901 2902| 参数名 | 类型 | 必填 | 说明 | 2903| ------- | ----------------------------------- | ---- | ------------------------------------------------------------ | 2904| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocketServer连接的其他属性。 | 2905 2906**返回值：** 2907 2908| 类型 | 说明 | 2909| -------------- | --------------------------------------------------------- | 2910| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 2911 2912**错误码：** 2913 2914| 错误码ID | 错误信息 | 2915| -------- | ------------------------------- | 2916| 401 | Parameter error. | 2917| 201 | Permission denied. | 2918| 2300002 | System internal error. | 2919| 2303188 | Socket operation on non-socket. | 2920 2921**示例：** 2922 2923```ts 2924import { socket } from '@kit.NetworkKit'; 2925import { BusinessError } from '@kit.BasicServicesKit'; 2926 2927let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2928let listenAddr: socket.NetAddress = { 2929 address: '192.168.xx.xxx', 2930 port: 8080, 2931 family: 1 2932} 2933 2934interface SocketLinger { 2935 on: boolean; 2936 linger: number; 2937} 2938 2939tcpServer.listen(listenAddr, (err: BusinessError) => { 2940 if (err) { 2941 console.log("listen fail"); 2942 return; 2943 } 2944 console.log("listen success"); 2945}) 2946 2947let tcpExtraOptions: socket.TCPExtraOptions = { 2948 keepAlive: true, 2949 OOBInline: true, 2950 TCPNoDelay: true, 2951 socketLinger: { on: true, linger: 10 } as SocketLinger, 2952 receiveBufferSize: 1000, 2953 sendBufferSize: 1000, 2954 reuseAddress: true, 2955 socketTimeout: 3000 2956} 2957tcpServer.setExtraOptions(tcpExtraOptions).then(() => { 2958 console.log('setExtraOptions success'); 2959}).catch((err: BusinessError) => { 2960 console.log('setExtraOptions fail'); 2961}); 2962``` 2963 2964### getLocalAddress<sup>12+</sup> 2965 2966getLocalAddress(): Promise\<NetAddress\> 2967 2968获取TCPSocketServer的本地Socket地址。使用Promise方式作为异步方法。 2969 2970> **说明：** 2971> listen方法调用成功后，才可调用此方法。 2972 2973**系统能力**：SystemCapability.Communication.NetStack 2974 2975**返回值：** 2976 2977| 类型 | 说明 | 2978| -------------- | --------------------------------------------------- | 2979| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取本地socket地址的结果。 | 2980 2981**错误码：** 2982 2983| 错误码ID | 错误信息 | 2984| -------- | ------------------------------------------- | 2985| 2300002 | System internal error. | 2986| 2301009 | Bad file descriptor. | 2987| 2303188 | Socket operation on non-socket. | 2988 2989**示例：** 2990 2991```ts 2992import { socket } from '@kit.NetworkKit'; 2993import { BusinessError } from '@kit.BasicServicesKit'; 2994 2995let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 2996let listenAddr: socket.NetAddress = { 2997 address: '192.168.xx.xxx', 2998 port: 8080, 2999 family: 1 3000} 3001tcpServer.listen(listenAddr).then(() => { 3002 tcpServer.getLocalAddress().then((localAddress: socket.NetAddress) => { 3003 console.info("SUCCESS! Address:" + JSON.stringify(localAddress)); 3004 }).catch((err: BusinessError) => { 3005 console.error("FerrorAILED! Error:" + JSON.stringify(err)); 3006 }) 3007}).catch((err: BusinessError) => { 3008 console.error('listen fail'); 3009}); 3010``` 3011 3012### on('connect')<sup>10+</sup> 3013 3014on(type: 'connect', callback: Callback\<TCPSocketConnection\>): void 3015 3016订阅TCPSocketServer的连接事件。使用callback方式作为异步方法。 3017 3018> **说明：** 3019> listen方法调用成功后，才可调用此方法。 3020 3021**系统能力**：SystemCapability.Communication.NetStack 3022 3023**参数：** 3024 3025| 参数名 | 类型 | 必填 | 说明 | 3026| -------- | ------------------------------- | ---- | ------------------------------------- | 3027| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 3028| callback | Callback\<[TCPSocketConnection](#tcpsocketconnection10)\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 3029 3030**错误码：** 3031 3032| 错误码ID | 错误信息 | 3033| -------- | ---------------- | 3034| 401 | Parameter error. | 3035 3036**示例：** 3037 3038```ts 3039import { socket } from '@kit.NetworkKit'; 3040 3041let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3042 3043let listenAddr: socket.NetAddress = { 3044 address: '192.168.xx.xxx', 3045 port: 8080, 3046 family: 1 3047} 3048tcpServer.listen(listenAddr, (err: BusinessError) => { 3049 if (err) { 3050 console.log("listen fail"); 3051 return; 3052 } 3053 console.log("listen success"); 3054 tcpServer.on('connect', (data: socket.TCPSocketConnection) => { 3055 console.log(JSON.stringify(data)) 3056 }); 3057}) 3058``` 3059 3060### off('connect')<sup>10+</sup> 3061 3062off(type: 'connect', callback?: Callback\<TCPSocketConnection\>): void 3063 3064取消订阅TCPSocketServer的连接事件。使用callback方式作为异步方法。 3065 3066**系统能力**：SystemCapability.Communication.NetStack 3067 3068**参数：** 3069 3070| 参数名 | 类型 | 必填 | 说明 | 3071| -------- | ------------------------------- | ---- | ------------------------------------- | 3072| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 3073| callback | Callback\<[TCPSocketConnection](#tcpsocketconnection10)\> | 否 | 回调函数。失败时返回错误码、错误信息。 | 3074 3075**错误码：** 3076 3077| 错误码ID | 错误信息 | 3078| -------- | ---------------- | 3079| 401 | Parameter error. | 3080 3081**示例：** 3082 3083```ts 3084import { socket } from '@kit.NetworkKit'; 3085 3086let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3087 3088let listenAddr: socket.NetAddress = { 3089 address: '192.168.xx.xxx', 3090 port: 8080, 3091 family: 1 3092} 3093tcpServer.listen(listenAddr, (err: BusinessError) => { 3094 if (err) { 3095 console.log("listen fail"); 3096 return; 3097 } 3098 console.log("listen success"); 3099 let callback = (data: socket.TCPSocketConnection) => { 3100 console.log('on connect message: ' + JSON.stringify(data)); 3101 } 3102 tcpServer.on('connect', callback); 3103 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3104 tcpServer.off('connect', callback); 3105 tcpServer.off('connect'); 3106}) 3107``` 3108 3109### on('error')<sup>10+</sup> 3110 3111on(type: 'error', callback: ErrorCallback): void 3112 3113订阅TCPSocketServer连接的error事件。使用callback方式作为异步方法。 3114 3115> **说明：** 3116> listen方法调用成功后，才可调用此方法。 3117 3118**系统能力**：SystemCapability.Communication.NetStack 3119 3120**参数：** 3121 3122| 参数名 | 类型 | 必填 | 说明 | 3123| -------- | ------------- | ---- | ------------------------------------ | 3124| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 3125| callback | ErrorCallback | 是 | 回调函数。失败时返回错误码、错误信息。| 3126 3127**错误码：** 3128 3129| 错误码ID | 错误信息 | 3130| -------- | ---------------- | 3131| 401 | Parameter error. | 3132 3133**示例：** 3134 3135```ts 3136import { socket } from '@kit.NetworkKit'; 3137import { BusinessError } from '@kit.BasicServicesKit'; 3138 3139let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3140 3141let listenAddr: socket.NetAddress = { 3142 address: '192.168.xx.xxx', 3143 port: 8080, 3144 family: 1 3145} 3146tcpServer.listen(listenAddr, (err: BusinessError) => { 3147 if (err) { 3148 console.log("listen fail"); 3149 return; 3150 } 3151 console.log("listen success"); 3152 tcpServer.on('error', (err: BusinessError) => { 3153 console.log("on error, err:" + JSON.stringify(err)) 3154 }); 3155}) 3156``` 3157 3158### off('error')<sup>10+</sup> 3159 3160off(type: 'error', callback?: ErrorCallback): void 3161 3162取消订阅TCPSocketServer连接的error事件。使用callback方式作为异步方法。 3163 3164**系统能力**：SystemCapability.Communication.NetStack 3165 3166**参数：** 3167 3168| 参数名 | 类型 | 必填 | 说明 | 3169| -------- | ------------- | ---- | ------------------------------------ | 3170| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 3171| callback | ErrorCallback | 否 | 回调函数。失败时返回错误码、错误信息。 | 3172 3173**错误码：** 3174 3175| 错误码ID | 错误信息 | 3176| -------- | ---------------- | 3177| 401 | Parameter error. | 3178 3179**示例：** 3180 3181```ts 3182import { socket } from '@kit.NetworkKit'; 3183import { BusinessError } from '@kit.BasicServicesKit'; 3184 3185let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3186 3187let listenAddr: socket.NetAddress = { 3188 address: '192.168.xx.xxx', 3189 port: 8080, 3190 family: 1 3191} 3192tcpServer.listen(listenAddr, (err: BusinessError) => { 3193 if (err) { 3194 console.log("listen fail"); 3195 return; 3196 } 3197 console.log("listen success"); 3198 let callback = (err: BusinessError) => { 3199 console.log("on error, err:" + JSON.stringify(err)); 3200 } 3201 tcpServer.on('error', callback); 3202 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3203 tcpServer.off('error', callback); 3204 tcpServer.off('error'); 3205}) 3206``` 3207 3208## TCPSocketConnection<sup>10+</sup> 3209 3210TCPSocketConnection连接，即TCPSocket客户端与服务端的连接。在调用TCPSocketConnection的方法前，需要先获取TCPSocketConnection对象。 3211 3212> **说明：** 3213> 客户端与服务端成功建立连接后，才能通过返回的TCPSocketConnection对象调用相应的接口。 3214 3215**系统能力**：SystemCapability.Communication.NetStack 3216 3217### 属性 3218 3219| 名称 | 类型 | 必填 | 说明 | 3220| -------- | ------ | ---- | ----------------------------------------- | 3221| clientId | number | 是 | 客户端与TCPSocketServer建立连接的id。 | 3222 3223### send<sup>10+</sup> 3224 3225send(options: TCPSendOptions, callback: AsyncCallback\<void\>): void 3226 3227通过TCPSocketConnection连接发送数据。使用callback方式作为异步方法。 3228 3229> **说明：** 3230> 与客户端建立连接后，才可调用此方法。 3231 3232**需要权限**：ohos.permission.INTERNET 3233 3234**系统能力**：SystemCapability.Communication.NetStack 3235 3236**参数：** 3237 3238| 参数名 | 类型 | 必填 | 说明 | 3239| -------- | --------------------------------- | ---- | ------------------------------------------------------------ | 3240| options | [TCPSendOptions](#tcpsendoptions) | 是 | TCPSocketConnection发送请求的参数。 | 3241| callback | AsyncCallback\<void\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 3242 3243**错误码：** 3244 3245| 错误码ID | 错误信息 | 3246| -------- | ---------------------- | 3247| 401 | Parameter error. | 3248| 201 | Permission denied. | 3249| 2300002 | System internal error. | 3250 3251**示例：** 3252 3253```ts 3254import { socket } from '@kit.NetworkKit'; 3255 3256let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3257 3258tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3259 let tcpSendOption: socket.TCPSendOptions = { 3260 data: 'Hello, client!' 3261 } 3262 client.send(tcpSendOption, () => { 3263 console.log('send success'); 3264 }); 3265}); 3266``` 3267 3268### send<sup>10+</sup> 3269 3270send(options: TCPSendOptions): Promise\<void\> 3271 3272通过TCPSocketConnection连接发送数据。使用Promise方式作为异步方法。 3273 3274> **说明：** 3275> 与客户端建立连接后，才可调用此方法。 3276 3277**需要权限**：ohos.permission.INTERNET 3278 3279**系统能力**：SystemCapability.Communication.NetStack 3280 3281**参数：** 3282 3283| 参数名 | 类型 | 必填 | 说明 | 3284| ------- | --------------------------------- | ---- | ------------------------------------------------------------ | 3285| options | [TCPSendOptions](#tcpsendoptions) | 是 | TCPSocketConnection发送请求的参数。 | 3286 3287**返回值：** 3288 3289| 类型 | 说明 | 3290| -------------- | ----------------------------------------------------------- | 3291| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 3292 3293**错误码：** 3294 3295| 错误码ID | 错误信息 | 3296| -------- | ---------------------- | 3297| 401 | Parameter error. | 3298| 201 | Permission denied. | 3299| 2300002 | System internal error. | 3300 3301**示例：** 3302 3303```ts 3304import { socket } from '@kit.NetworkKit'; 3305import { BusinessError } from '@kit.BasicServicesKit'; 3306 3307let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3308 3309tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3310 let tcpSendOption: socket.TCPSendOptions = { 3311 data: 'Hello, client!' 3312 } 3313 client.send(tcpSendOption).then(() => { 3314 console.log('send success'); 3315 }).catch((err: BusinessError) => { 3316 console.log('send fail'); 3317 }); 3318}); 3319``` 3320 3321### close<sup>10+</sup> 3322 3323close(callback: AsyncCallback\<void\>): void 3324 3325关闭一个与TCPSocket建立的连接。使用callback方式作为异步方法。 3326 3327**需要权限**：ohos.permission.INTERNET 3328 3329**系统能力**：SystemCapability.Communication.NetStack 3330 3331**参数：** 3332 3333| 参数名 | 类型 | 必填 | 说明 | 3334| -------- | --------------------- | ---- | ---------- | 3335| callback | AsyncCallback\<void\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 3336 3337**错误码：** 3338 3339| 错误码ID | 错误信息 | 3340| -------- | ---------------------- | 3341| 401 | Parameter error. | 3342| 201 | Permission denied. | 3343| 2300002 | System internal error. | 3344 3345**示例：** 3346 3347```ts 3348import { socket } from '@kit.NetworkKit'; 3349import { BusinessError } from '@kit.BasicServicesKit'; 3350 3351let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3352 3353tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3354 client.close((err: BusinessError) => { 3355 if (err) { 3356 console.log('close fail'); 3357 return; 3358 } 3359 console.log('close success'); 3360 }); 3361}); 3362``` 3363 3364### close<sup>10+</sup> 3365 3366close(): Promise\<void\> 3367 3368关闭一个与TCPSocket建立的连接。使用Promise方式作为异步方法。 3369 3370**需要权限**：ohos.permission.INTERNET 3371 3372**系统能力**：SystemCapability.Communication.NetStack 3373 3374**返回值：** 3375 3376| 类型 | 说明 | 3377| -------------- | ------------------------------------------- | 3378| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 3379 3380**错误码：** 3381 3382| 错误码ID | 错误信息 | 3383| -------- | ---------------------- | 3384| 201 | Permission denied. | 3385| 2300002 | System internal error. | 3386 3387**示例：** 3388 3389```ts 3390import { socket } from '@kit.NetworkKit'; 3391 3392let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3393tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3394 client.close().then(() => { 3395 console.log('close success'); 3396 }).catch((err: BusinessError) => { 3397 console.log('close fail'); 3398 }); 3399}); 3400``` 3401 3402### getRemoteAddress<sup>10+</sup> 3403 3404getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void 3405 3406获取对端Socket地址。使用callback方式作为异步方法。 3407 3408> **说明：** 3409> 与客户端建立连接后，才可调用此方法。 3410 3411**需要权限**：ohos.permission.INTERNET 3412 3413**系统能力**：SystemCapability.Communication.NetStack 3414 3415**参数：** 3416 3417| 参数名 | 类型 | 必填 | 说明 | 3418| -------- | ---------------------------------------- | ---- | ---------- | 3419| callback | AsyncCallback\<[NetAddress](#netaddress)\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 3420 3421**错误码：** 3422 3423| 错误码ID | 错误信息 | 3424| -------- | ------------------------------- | 3425| 401 | Parameter error. | 3426| 201 | Permission denied. | 3427| 2300002 | System internal error. | 3428| 2303188 | Socket operation on non-socket. | 3429 3430**示例：** 3431 3432```ts 3433import { socket } from '@kit.NetworkKit'; 3434import { BusinessError } from '@kit.BasicServicesKit'; 3435 3436let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3437tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3438 client.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => { 3439 if (err) { 3440 console.log('getRemoteAddress fail'); 3441 return; 3442 } 3443 console.log('getRemoteAddress success:' + JSON.stringify(data)); 3444 }); 3445}); 3446``` 3447 3448### getRemoteAddress<sup>10+</sup> 3449 3450getRemoteAddress(): Promise\<NetAddress\> 3451 3452获取对端Socket地址。使用Promise方式作为异步方法。 3453 3454> **说明：** 3455> 与客户端建立连接后，才可调用此方法。 3456 3457**需要权限**：ohos.permission.INTERNET 3458 3459**系统能力**：SystemCapability.Communication.NetStack 3460 3461**返回值：** 3462 3463| 类型 | 说明 | 3464| --------------------------------- | ------------------------------------------ | 3465| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取对端socket地址的结果。 | 3466 3467**错误码：** 3468 3469| 错误码ID | 错误信息 | 3470| -------- | ------------------------------- | 3471| 201 | Permission denied. | 3472| 2300002 | System internal error. | 3473| 2303188 | Socket operation on non-socket. | 3474 3475**示例：** 3476 3477```ts 3478import { socket } from '@kit.NetworkKit'; 3479import { BusinessError } from '@kit.BasicServicesKit'; 3480 3481let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3482tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3483 client.getRemoteAddress().then(() => { 3484 console.log('getRemoteAddress success'); 3485 }).catch((err: BusinessError) => { 3486 console.log('getRemoteAddress fail'); 3487 }); 3488}); 3489``` 3490 3491### getLocalAddress<sup>12+</sup> 3492 3493getLocalAddress(): Promise\<NetAddress\> 3494 3495获取TCPSocketConnection连接的本地Socket地址。使用Promise方式作为异步方法。 3496 3497**系统能力**：SystemCapability.Communication.NetStack 3498 3499**返回值：** 3500 3501| 类型 | 说明 | 3502| -------------- | --------------------------------------------------- | 3503| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取本地socket地址的结果。 | 3504 3505**错误码：** 3506 3507| 错误码ID | 错误信息 | 3508| -------- | ------------------------------------------- | 3509| 2300002 | System internal error. | 3510| 2301009 | Bad file descriptor. | 3511| 2303188 | Socket operation on non-socket. | 3512 3513**示例：** 3514 3515```ts 3516import { socket } from '@kit.NetworkKit'; 3517import { BusinessError } from '@kit.BasicServicesKit'; 3518 3519let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3520let listenAddr: socket.NetAddress = { 3521 address: "192.168.xx.xx", 3522 port: 8080, 3523 family: 1 3524} 3525tcpServer.listen(listenAddr, (err: BusinessError) => { 3526 let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 3527 let netAddress: socket.NetAddress = { 3528 address: "192.168.xx.xx", 3529 port: 8080 3530 } 3531 let options: socket.TCPConnectOptions = { 3532 address: netAddress, 3533 timeout: 6000 3534 } 3535 tcp.connect(options, (err: BusinessError) => { 3536 if (err) { 3537 console.error('connect fail'); 3538 return; 3539 } 3540 console.info('connect success!'); 3541 }) 3542 tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3543 client.getLocalAddress().then((localAddress: socket.NetAddress) => { 3544 console.info("Family IP Port: " + JSON.stringify(localAddress)); 3545 }).catch((err: BusinessError) => { 3546 console.error('Error:' + JSON.stringify(err)); 3547 }); 3548 }) 3549}) 3550``` 3551 3552### on('message')<sup>10+</sup> 3553 3554on(type: 'message', callback: Callback<SocketMessageInfo\>): void 3555 3556订阅TCPSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 3557 3558**系统能力**：SystemCapability.Communication.NetStack 3559 3560**参数：** 3561 3562| 参数名 | 类型 | 必填 | 说明 | 3563| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 3564| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 3565| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 3566 3567**错误码：** 3568 3569| 错误码ID | 错误信息 | 3570| -------- | ---------------- | 3571| 401 | Parameter error. | 3572 3573**示例：** 3574 3575```ts 3576import { socket } from '@kit.NetworkKit'; 3577import { BusinessError } from '@kit.BasicServicesKit'; 3578 3579let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3580 3581tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3582 client.on('message', (value: socket.SocketMessageInfo) => { 3583 let messageView = ''; 3584 for (let i: number = 0; i < value.message.byteLength; i++) { 3585 let uint8Array = new Uint8Array(value.message) 3586 let messages = uint8Array[i] 3587 let message = String.fromCharCode(messages); 3588 messageView += message; 3589 } 3590 console.log('on message message: ' + JSON.stringify(messageView)); 3591 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 3592 }); 3593}); 3594``` 3595 3596### off('message')<sup>10+</sup> 3597 3598off(type: 'message', callback?: Callback<SocketMessageInfo\>): void 3599 3600取消订阅TCPSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 3601 3602**系统能力**：SystemCapability.Communication.NetStack 3603 3604**参数：** 3605 3606| 参数名 | 类型 | 必填 | 说明 | 3607| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 3608| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 3609| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 否 | 回调函数。失败时返回错误码、错误信息。 | 3610 3611**错误码：** 3612 3613| 错误码ID | 错误信息 | 3614| -------- | ---------------- | 3615| 401 | Parameter error. | 3616 3617**示例：** 3618 3619```ts 3620import { socket } from '@kit.NetworkKit'; 3621import { BusinessError } from '@kit.BasicServicesKit'; 3622 3623let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3624let callback = (value: socket.SocketMessageInfo) => { 3625 let messageView = ''; 3626 for (let i: number = 0; i < value.message.byteLength; i++) { 3627 let uint8Array = new Uint8Array(value.message) 3628 let messages = uint8Array[i] 3629 let message = String.fromCharCode(messages); 3630 messageView += message; 3631 } 3632 console.log('on message message: ' + JSON.stringify(messageView)); 3633 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 3634} 3635tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3636 client.on('message', callback); 3637 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3638 client.off('message', callback); 3639 client.off('message'); 3640}); 3641``` 3642 3643### on('close')<sup>10+</sup> 3644 3645on(type: 'close', callback: Callback\<void\>): void 3646 3647订阅TCPSocketConnection的关闭事件。使用callback方式作为异步方法。 3648 3649**系统能力**：SystemCapability.Communication.NetStack 3650 3651**参数：** 3652 3653| 参数名 | 类型 | 必填 | 说明 | 3654| -------- | ---------------- | ---- | ----------------------------------- | 3655| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 3656| callback | Callback\<void\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 3657 3658**错误码：** 3659 3660| 错误码ID | 错误信息 | 3661| -------- | ---------------- | 3662| 401 | Parameter error. | 3663 3664**示例：** 3665 3666```ts 3667import { socket } from '@kit.NetworkKit'; 3668import { BusinessError } from '@kit.BasicServicesKit'; 3669 3670let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3671tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3672 client.on('close', () => { 3673 console.log("on close success") 3674 }); 3675}); 3676``` 3677 3678### off('close')<sup>10+</sup> 3679 3680off(type: 'close', callback?: Callback\<void\>): void 3681 3682取消订阅TCPSocketConnection的关闭事件。使用callback方式作为异步方法。 3683 3684**系统能力**：SystemCapability.Communication.NetStack 3685 3686**参数：** 3687 3688| 参数名 | 类型 | 必填 | 说明 | 3689| -------- | ---------------- | ---- | ----------------------------------- | 3690| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 3691| callback | Callback\<void\> | 否 | 回调函数。失败时返回错误码、错误信息。 | 3692 3693**错误码：** 3694 3695| 错误码ID | 错误信息 | 3696| -------- | ---------------- | 3697| 401 | Parameter error. | 3698 3699**示例：** 3700 3701```ts 3702import { socket } from '@kit.NetworkKit'; 3703 3704let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3705let callback = () => { 3706 console.log("on close success"); 3707} 3708tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3709 client.on('close', callback); 3710 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3711 client.off('close', callback); 3712 client.off('close'); 3713}); 3714``` 3715 3716### on('error')<sup>10+</sup> 3717 3718on(type: 'error', callback: ErrorCallback): void 3719 3720订阅TCPSocketConnection连接的error事件。使用callback方式作为异步方法。 3721 3722**系统能力**：SystemCapability.Communication.NetStack 3723 3724**参数：** 3725 3726| 参数名 | 类型 | 必填 | 说明 | 3727| -------- | ------------- | ---- | ------------------------------------ | 3728| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 3729| callback | ErrorCallback | 是 | 回调函数。失败时返回错误码、错误信息。 | 3730 3731**错误码：** 3732 3733| 错误码ID | 错误信息 | 3734| -------- | ---------------- | 3735| 401 | Parameter error. | 3736 3737**示例：** 3738 3739```ts 3740import { socket } from '@kit.NetworkKit'; 3741import { BusinessError } from '@kit.BasicServicesKit'; 3742 3743let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3744tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3745 client.on('error', (err: BusinessError) => { 3746 console.log("on error, err:" + JSON.stringify(err)) 3747 }); 3748}); 3749``` 3750 3751### off('error')<sup>10+</sup> 3752 3753off(type: 'error', callback?: ErrorCallback): void 3754 3755取消订阅TCPSocketConnection连接的error事件。使用callback方式作为异步方法。 3756 3757**系统能力**：SystemCapability.Communication.NetStack 3758 3759**参数：** 3760 3761| 参数名 | 类型 | 必填 | 说明 | 3762| -------- | ------------- | ---- | ------------------------------------ | 3763| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 3764| callback | ErrorCallback | 否 | 回调函数。失败时返回错误码、错误信息。 | 3765 3766**错误码：** 3767 3768| 错误码ID | 错误信息 | 3769| -------- | ---------------- | 3770| 401 | Parameter error. | 3771 3772**示例：** 3773 3774```ts 3775import { socket } from '@kit.NetworkKit'; 3776import { BusinessError } from '@kit.BasicServicesKit'; 3777 3778let callback = (err: BusinessError) => { 3779 console.log("on error, err:" + JSON.stringify(err)); 3780} 3781let tcpServer: socket.TCPSocketServer = socket.constructTCPSocketServerInstance(); 3782tcpServer.on('connect', (client: socket.TCPSocketConnection) => { 3783 client.on('error', callback); 3784 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 3785 client.off('error', callback); 3786 client.off('error'); 3787}); 3788``` 3789 3790## TCP 错误码说明 3791 3792TCP 其余错误码映射形式为：2301000 + Linux内核错误码。 3793 3794错误码的详细介绍参见[Socket错误码](errorcode-net-socket.md) 3795 3796## socket.constructLocalSocketInstance<sup>11+</sup> 3797 3798constructLocalSocketInstance(): LocalSocket 3799 3800创建一个LocalSocket对象。 3801 3802**系统能力**：SystemCapability.Communication.NetStack 3803 3804**返回值：** 3805 3806| 类型 | 说明 | 3807| :--------------------------------- | :---------------------- | 3808| [LocalSocket](#localsocket11) | 返回一个LocalSocket对象。 | 3809 3810**示例：** 3811 3812```ts 3813import { socket } from '@kit.NetworkKit'; 3814let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 3815``` 3816 3817## LocalSocket<sup>11+</sup> 3818 3819LocalSocket连接。在调用LocalSocket的方法前，需要先通过[socket.constructLocalSocketInstance](#socketconstructlocalsocketinstance11)创建LocalSocket对象。 3820 3821### bind<sup>11+</sup> 3822 3823bind(address: LocalAddress): Promise\<void\>; 3824 3825绑定本地套接字文件的路径。使用promise方法作为异步方法。 3826 3827> **说明：** 3828> bind方法可以使客户端确保有个明确的本地套接字路径，显式的绑定一个本地套接字文件。 3829> bind方法在本地套接字通信中非必须。 3830 3831**系统能力**：SystemCapability.Communication.NetStack 3832 3833**参数：** 3834 3835| 参数名 | 类型 | 必填 | 说明 | 3836| -------- | ---------------------------------- | ---- | ------------------------------------------------------ | 3837| address | [LocalAddress](#localaddress11) | 是 | 目标地址信息，参考[LocalAddress](#localaddress11)。 | 3838 3839**错误码：** 3840 3841| 错误码ID | 错误信息 | 3842| ------- | -------------------------- | 3843| 401 | Parameter error. | 3844| 2301013 | Insufficient permissions. | 3845| 2301022 | Invalid argument. | 3846| 2301098 | Address already in use. | 3847 3848**示例：** 3849 3850```ts 3851import { socket } from '@kit.NetworkKit'; 3852 3853let client: socket.LocalSocket = socket.constructLocalSocketInstance() 3854let sandboxPath: string = getContext().filesDir + '/testSocket' 3855let address : socket.LocalAddress = { 3856 address: sandboxPath 3857} 3858client.bind(address).then(() => { 3859 console.log('bind success') 3860}).catch((err: Object) => { 3861 console.error('failed to bind: ' + JSON.stringify(err)) 3862}) 3863``` 3864 3865### connect<sup>11+</sup> 3866 3867connect(options: LocalConnectOptions): Promise\<void\> 3868 3869连接到指定的套接字文件。使用promise方法作为异步方法。 3870 3871> **说明：** 3872> 在没有执行localsocket.bind的情况下，也可以直接调用该接口完成与LocalSocket服务端的连接。 3873 3874**系统能力**：SystemCapability.Communication.NetStack 3875 3876**参数：** 3877 3878| 参数名 | 类型 | 必填 | 说明 | 3879| ------- | ---------------------------------------- | ---- | ------------------------------------------------------------ | 3880| options | [LocalConnectOptions](#localconnectoptions11) | 是 | LocalSocket连接的参数，参考[LocalConnectOptions](#localconnectoptions11)。 | 3881 3882**返回值：** 3883 3884| 类型 | 说明 | 3885| :-------------- | :---------------------------------------- | 3886| Promise\<void\> | 以Promise形式返回LocalSocket连接服务端的结果。 | 3887 3888**错误码：** 3889 3890| 错误码ID | 错误信息 | 3891| ------- | ----------------------- | 3892| 401 | Parameter error. | 3893| 2301013 | Insufficient permissions. | 3894| 2301022 | Invalid argument. | 3895| 2301111 | Connection refused. | 3896| 2301099 | Cannot assign requested address. | 3897 3898**示例：** 3899 3900```ts 3901import { socket } from '@kit.NetworkKit'; 3902 3903let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 3904let sandboxPath: string = getContext().filesDir + '/testSocket' 3905let localAddress : socket.LocalAddress = { 3906 address: sandboxPath 3907} 3908let connectOpt: socket.LocalConnectOptions = { 3909 address: localAddress, 3910 timeout: 6000 3911} 3912client.connect(connectOpt).then(() => { 3913 console.log('connect success') 3914}).catch((err: Object) => { 3915 console.error('connect fail: ' + JSON.stringify(err)); 3916}); 3917``` 3918 3919### send<sup>11+</sup> 3920 3921send(options: LocalSendOptions): Promise\<void\> 3922 3923通过LocalSocket连接发送数据。使用Promise方式作为异步方法。 3924 3925> **说明：** 3926> connect方法调用成功后，才可调用此方法。 3927 3928**系统能力**：SystemCapability.Communication.NetStack 3929 3930**参数：** 3931 3932| 参数名 | 类型 | 必填 | 说明 | 3933| ------- | --------------------------------------- | ---- | ------------------------------------------------------------ | 3934| options | [LocalSendOptions](#localsendoptions11) | 是 | LocalSocket发送请求的参数，参考[LocalSendOptions](#localsendoptions11)。 | 3935 3936**返回值：** 3937 3938| 类型 | 说明 | 3939| :-------------- | :------------------------------------------ | 3940| Promise\<void\> | 以Promise形式返回通过LocalSocket发送数据的结果。 | 3941 3942**错误码：** 3943 3944| 错误码ID | 错误信息 | 3945| ------- | ----------------------- | 3946| 401 | Parameter error. | 3947| 2301011 | Operation would block. | 3948 3949**示例：** 3950 3951```ts 3952import { socket } from '@kit.NetworkKit'; 3953 3954let client: socket.LocalSocket = socket.constructLocalSocketInstance() 3955let sandboxPath: string = getContext().filesDir + '/testSocket' 3956let localAddress : socket.LocalAddress = { 3957 address: sandboxPath 3958} 3959let connectOpt: socket.LocalConnectOptions = { 3960 address: localAddress, 3961 timeout: 6000 3962} 3963client.connect(connectOpt).then(() => { 3964 console.log('connect success') 3965}).catch((err: Object) => { 3966 console.error('connect failed: ' + JSON.stringify(err)) 3967}) 3968let sendOpt: socket.LocalSendOptions = { 3969 data: 'Hello world!' 3970} 3971client.send(sendOpt).then(() => { 3972 console.log('send success') 3973}).catch((err: Object) => { 3974 console.error('send fail: ' + JSON.stringify(err)) 3975}) 3976``` 3977 3978### close<sup>11+</sup> 3979 3980close(): Promise\<void\> 3981 3982关闭LocalSocket连接。使用Promise方式作为异步方法。 3983 3984**系统能力**：SystemCapability.Communication.NetStack 3985 3986**返回值：** 3987 3988| 类型 | 说明 | 3989| :-------------- | :----------------------------------------- | 3990| Promise\<void\> | 以Promise形式返回关闭LocalSocket连接的结果。 | 3991 3992**错误码：** 3993 3994| 错误码ID | 错误信息 | 3995| ------- | ----------------------- | 3996| 2301009 | Bad file descriptor. | 3997 3998**示例：** 3999 4000```ts 4001import { socket } from '@kit.NetworkKit'; 4002 4003let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4004 4005client.close().then(() => { 4006 console.log('close success'); 4007}).catch((err: Object) => { 4008 console.error('close fail: ' + JSON.stringify(err)); 4009}); 4010``` 4011 4012### getState<sup>11+</sup> 4013 4014getState(): Promise\<SocketStateBase\> 4015 4016获取LocalSocket状态。使用Promise方式作为异步方法。 4017 4018> **说明：** 4019> bind或connect方法调用成功后，才可调用此方法。 4020 4021**系统能力**：SystemCapability.Communication.NetStack 4022 4023**返回值：** 4024 4025| 类型 | 说明 | 4026| :------------------------------------------- | :--------------------------------------- | 4027| Promise\<[SocketStateBase](#socketstatebase)\> | 以Promise形式返回获取LocalSocket状态的结果。 | 4028 4029**示例：** 4030 4031```ts 4032import { socket } from '@kit.NetworkKit'; 4033 4034let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4035let sandboxPath: string = getContext().filesDir + '/testSocket' 4036let localAddress : socket.LocalAddress = { 4037 address: sandboxPath 4038} 4039let connectOpt: socket.LocalConnectOptions = { 4040 address: localAddress, 4041 timeout: 6000 4042} 4043client.connect(connectOpt).then(() => { 4044 console.log('connect success'); 4045 client.getState().then(() => { 4046 console.log('getState success'); 4047 }).catch((err: Object) => { 4048 console.error('getState fail: ' + JSON.stringify(err)) 4049 }); 4050}).catch((err: Object) => { 4051 console.error('connect fail: ' + JSON.stringify(err)); 4052}); 4053``` 4054 4055### getSocketFd<sup>11+</sup> 4056 4057getSocketFd(): Promise\<number\> 4058 4059获取LocalSocket的文件描述符。使用Promise方式作为异步方法。 4060 4061> **说明：** 4062> bind或connect方法调用成功后，才可调用此方法。 4063> 获取由系统内核分配的唯一文件描述符，用于标识当前使用的套接字。 4064 4065**系统能力**：SystemCapability.Communication.NetStack 4066 4067**返回值：** 4068 4069| 类型 | 说明 | 4070| :---------------- | :-------------------------------- | 4071| Promise\<number\> | 以Promise形式返回socket的文件描述符。 | 4072 4073**示例：** 4074 4075```ts 4076import { socket } from '@kit.NetworkKit'; 4077 4078let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4079let sandboxPath: string = getContext().filesDir + '/testSocket' 4080let localAddress : socket.LocalAddress = { 4081 address: sandboxPath 4082} 4083let connectOpt: socket.LocalConnectOptions = { 4084 address: localAddress, 4085 timeout: 6000 4086} 4087client.connect(connectOpt).then(() => { 4088 console.log('connect ok') 4089}).catch((err: Object) => { 4090 console.error('connect fail: ' + JSON.stringify(err)) 4091}) 4092client.getSocketFd().then((data: number) => { 4093 console.info("fd: " + data); 4094}).catch((err: Object) => { 4095 console.error("getSocketFd faile: " + JSON.stringify(err)); 4096}) 4097``` 4098 4099### setExtraOptions<sup>11+</sup> 4100 4101setExtraOptions(options: ExtraOptionsBase): Promise\<void\> 4102 4103设置LocalSocket的套接字属性，使用Promise方式作为异步方法。 4104 4105> **说明：** 4106> bind或connect方法调用成功后，才可调用此方法。 4107 4108**系统能力**：SystemCapability.Communication.NetStack 4109 4110**参数：** 4111 4112| 参数名 | 类型 | 必填 | 说明 | 4113| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 4114| options | [ExtraOptionsBase](#extraoptionsbase7) | 是 | LocalSocket连接的其他属性，参考[ExtraOptionsBase](#extraoptionsbase7)。 | 4115 4116**返回值：** 4117 4118| 类型 | 说明 | 4119| :-------------- | :-------------------------------------------- | 4120| Promise\<void\> | 以Promise形式返回设置LocalSocket套接字属性的结果。 | 4121 4122**错误码：** 4123 4124| 错误码ID | 错误信息 | 4125| ------- | ----------------------- | 4126| 401 | Parameter error. | 4127| 2301009 | Bad file descriptor. | 4128 4129**示例：** 4130 4131```ts 4132import { socket } from '@kit.NetworkKit'; 4133 4134let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4135let sandboxPath: string = getContext().filesDir + '/testSocket' 4136let localAddress : socket.LocalAddress = { 4137 address: sandboxPath 4138} 4139let connectOpt: socket.LocalConnectOptions = { 4140 address: localAddress, 4141 timeout: 6000 4142} 4143client.connect(connectOpt).then(() => { 4144 console.log('connect success'); 4145 let options: socket.ExtraOptionsBase = { 4146 receiveBufferSize: 8000, 4147 sendBufferSize: 8000, 4148 socketTimeout: 3000 4149 } 4150 client.setExtraOptions(options).then(() => { 4151 console.log('setExtraOptions success'); 4152 }).catch((err: Object) => { 4153 console.error('setExtraOptions fail: ' + JSON.stringify(err)); 4154 }); 4155}).catch((err: Object) => { 4156 console.error('connect fail: ' + JSON.stringify(err)); 4157}); 4158``` 4159 4160### getExtraOptions<sup>11+</sup> 4161 4162getExtraOptions(): Promise\<ExtraOptionsBase\>; 4163 4164获取LocalSocket的套接字属性，使用Promise方式作为异步方法。 4165 4166> **说明：** 4167> bind或connect方法调用成功后，才可调用此方法。 4168 4169**系统能力**：SystemCapability.Communication.NetStack 4170 4171**返回值：** 4172 4173| 类型 | 说明 | 4174| :-------------------------- | :---------------------------------------- | 4175| Promise\<[ExtraOptionsBase](#extraoptionsbase7)\> | 以Promise形式返回设置LocalSocket套接字的属性。 | 4176 4177**错误码：** 4178 4179| 错误码ID | 错误信息 | 4180| ------- | ----------------------- | 4181| 2301009 | Bad file descriptor. | 4182 4183**示例：** 4184 4185```ts 4186import { socket } from '@kit.NetworkKit'; 4187 4188let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4189let sandboxPath: string = getContext().filesDir + '/testSocket' 4190let localAddress : socket.LocalAddress = { 4191 address: sandboxPath 4192} 4193let connectOpt: socket.LocalConnectOptions = { 4194 address: localAddress, 4195 timeout: 6000 4196} 4197client.connect(connectOpt).then(() => { 4198 console.log('connect success'); 4199 client.getExtraOptions().then((options : socket.ExtraOptionsBase) => { 4200 console.log('options: ' + JSON.stringify(options)); 4201 }).catch((err: Object) => { 4202 console.error('setExtraOptions fail: ' + JSON.stringify(err)); 4203 }); 4204}).catch((err: Object) => { 4205 console.error('connect fail: ' + JSON.stringify(err)); 4206}); 4207``` 4208 4209### getLocalAddress<sup>12+</sup> 4210 4211getLocalAddress(): Promise\<string\> 4212 4213获取LocalSocket的本地Socket地址。使用Promise方式作为异步方法。 4214 4215> **说明：** 4216> bind方法调用成功后，才可调用此方法。 4217 4218**系统能力**：SystemCapability.Communication.NetStack 4219 4220**返回值：** 4221 4222| 类型 | 说明 | 4223| -------------- | --------------------------------------------------- | 4224| Promise\<string\> | 以Promise形式返回获取本地socket地址的结果。 | 4225 4226**错误码：** 4227 4228| 错误码ID | 错误信息 | 4229| -------- | ------------------------------------------- | 4230| 2300002 | System internal error. | 4231| 2301009 | Bad file descriptor. | 4232| 2303188 | Socket operation on non-socket. | 4233 4234**示例：** 4235 4236```ts 4237let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4238let sandboxPath: string = getContext().filesDir + '/testSocket'; 4239let address : socket.LocalAddress = { 4240 address: sandboxPath 4241} 4242client.bind(address).then(() => { 4243 console.error('bind success'); 4244 client.getLocalAddress().then((localPath: string) => { 4245 console.info("SUCCESS " + JSON.stringify(localPath)); 4246 }).catch((err: BusinessError) => { 4247 console.error("FAIL " + JSON.stringify(err)); 4248 }) 4249}).catch((err: Object) => { 4250 console.info('failed to bind: ' + JSON.stringify(err)); 4251}) 4252``` 4253 4254### on('message')<sup>11+</sup> 4255 4256on(type: 'message', callback: Callback\<LocalSocketMessageInfo\>): void 4257 4258订阅LocalSocket连接的接收消息事件。使用callback方式作为异步方法。 4259 4260**系统能力**：SystemCapability.Communication.NetStack 4261 4262**参数：** 4263 4264| 参数名 | 类型 | 必填 | 说明 | 4265| -------- | ----------------------------------------------- | ---- | ----------------------------------- | 4266| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 4267| callback | Callback\<[LocalSocketMessageInfo](#localsocketmessageinfo11)\> | 是 | 以callback的形式异步返回接收的消息。| 4268 4269**错误码：** 4270 4271| 错误码ID | 错误信息 | 4272| ------- | ----------------------- | 4273| 401 | Parameter error. | 4274 4275**示例：** 4276 4277```ts 4278import { socket } from '@kit.NetworkKit'; 4279 4280let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4281client.on('message', (value: socket.LocalSocketMessageInfo) => { 4282 const uintArray = new Uint8Array(value.message) 4283 let messageView = ''; 4284 for (let i = 0; i < uintArray.length; i++) { 4285 messageView += String.fromCharCode(uintArray[i]); 4286 } 4287 console.log('total: ' + JSON.stringify(value)); 4288 console.log('message infomation: ' + messageView); 4289}); 4290``` 4291 4292### off('message')<sup>11+</sup> 4293 4294off(type: 'message', callback?: Callback\<LocalSocketMessageInfo\>): void 4295 4296取消订阅LocalSocket连接的接收消息事件。使用callback方式作为异步方法。 4297 4298**系统能力**：SystemCapability.Communication.NetStack 4299 4300**参数：** 4301 4302| 参数名 | 类型 | 必填 | 说明 | 4303| -------- | ------------------------------------------------ | ---- | ----------------------------------- | 4304| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 4305| callback | Callback\<[LocalSocketMessageInfo](#localsocketmessageinfo11)\> | 否 | 指定传入on中的callback取消一个订阅。| 4306 4307**错误码：** 4308 4309| 错误码ID | 错误信息 | 4310| ------- | ----------------------- | 4311| 401 | Parameter error. | 4312 4313**示例：** 4314 4315```ts 4316import { socket } from '@kit.NetworkKit'; 4317 4318let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4319let messageView = ''; 4320let callback = (value: socket.LocalSocketMessageInfo) => { 4321 const uintArray = new Uint8Array(value.message) 4322 let messageView = ''; 4323 for (let i = 0; i < uintArray.length; i++) { 4324 messageView += String.fromCharCode(uintArray[i]); 4325 } 4326 console.log('total: ' + JSON.stringify(value)); 4327 console.log('message infomation: ' + messageView); 4328} 4329client.on('message', callback); 4330client.off('message'); 4331``` 4332 4333### on('connect')<sup>11+</sup> 4334 4335on(type: 'connect', callback: Callback\<void\>): void; 4336 4337订阅LocalSocket的连接事件。使用callback方式作为异步方法。 4338 4339**系统能力**：SystemCapability.Communication.NetStack 4340 4341**参数：** 4342 4343| 参数名 | 类型 | 必填 | 说明 | 4344| -------- | ---------------- | ---- | --------------------------------------------------------- | 4345| type | string | 是 | 订阅的事件类型。 | 4346| callback | Callback\<void\> | 是 | 以callback的形式异步返回与服务端连接的结果。 | 4347 4348**错误码：** 4349 4350| 错误码ID | 错误信息 | 4351| ------- | ----------------------- | 4352| 401 | Parameter error. | 4353 4354**示例：** 4355 4356```ts 4357import { socket } from '@kit.NetworkKit'; 4358 4359let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4360client.on('connect', () => { 4361 console.log("on connect success") 4362}); 4363``` 4364 4365### off('connect')<sup>11+</sup> 4366 4367off(type: 'connect', callback?: Callback\<void\>): void; 4368 4369取消订阅LocalSocket的连接事件。使用callback方式作为异步方法。 4370 4371**系统能力**：SystemCapability.Communication.NetStack 4372 4373**参数：** 4374 4375| 参数名 | 类型 | 必填 | 说明 | 4376| -------- | ---------------- | ---- | --------------------------------------------------------- | 4377| type | string | 是 | 订阅的事件类型。 | 4378| callback | Callback\<void\> | 否 | 指定传入on中的callback取消一个订阅。 | 4379 4380**错误码：** 4381 4382| 错误码ID | 错误信息 | 4383| ------- | ----------------------- | 4384| 401 | Parameter error. | 4385 4386**示例：** 4387 4388```ts 4389import { socket } from '@kit.NetworkKit'; 4390 4391let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4392let callback = () => { 4393 console.log("on connect success"); 4394} 4395client.on('connect', callback); 4396// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4397client.off('connect', callback); 4398client.off('connect'); 4399``` 4400 4401### on('close')<sup>11+</sup> 4402 4403on(type: 'close', callback: Callback\<void\>): void; 4404 4405订阅LocalSocket的关闭事件。使用callback方式作为异步方法。 4406 4407**系统能力**：SystemCapability.Communication.NetStack 4408 4409**参数：** 4410 4411| 参数名 | 类型 | 必填 | 说明 | 4412| -------- | ---------------- | ---- | ------------------------ | 4413| type | string | 是 | 订阅LocalSocket的关闭事件。 | 4414| callback | Callback\<void\> | 是 | 以callback的形式异步返回关闭localsocket的结果。| 4415 4416**错误码：** 4417 4418| 错误码ID | 错误信息 | 4419| ------- | ----------------------- | 4420| 401 | Parameter error. | 4421 4422**示例：** 4423 4424```ts 4425import { socket } from '@kit.NetworkKit'; 4426 4427let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4428let callback = () => { 4429 console.log("on close success"); 4430} 4431client.on('close', callback); 4432``` 4433 4434### off('close')<sup>11+</sup> 4435 4436off(type: 'close', callback?: Callback\<void\>): void; 4437 4438订阅LocalSocket的关闭事件。使用callback方式作为异步方法。 4439 4440**系统能力**：SystemCapability.Communication.NetStack 4441 4442**参数：** 4443 4444| 参数名 | 类型 | 必填 | 说明 | 4445| -------- | ---------------- | ---- | ------------------------ | 4446| type | string | 是 | 订阅LocalSocket的关闭事件。 | 4447| callback | Callback\<void\> | 否 | 取消指定传入on中的callback取消一个订阅。| 4448 4449**错误码：** 4450 4451| 错误码ID | 错误信息 | 4452| ------- | ----------------------- | 4453| 401 | Parameter error. | 4454 4455**示例：** 4456 4457```ts 4458import { socket } from '@kit.NetworkKit'; 4459 4460let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4461let callback = () => { 4462 console.log("on close success"); 4463} 4464client.on('close', callback); 4465// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4466client.off('close', callback); 4467client.off('close'); 4468``` 4469 4470### on('error')<sup>11+</sup> 4471 4472on(type: 'error', callback: ErrorCallback): void 4473 4474订阅LocalSocket连接的error事件。使用callback方式作为异步方法。 4475 4476**系统能力**：SystemCapability.Communication.NetStack 4477 4478**参数：** 4479 4480| 参数名 | 类型 | 必填 | 说明 | 4481| -------- | ------------- | ---- | ---------------------------- | 4482| type | string | 是 | 订阅LocalSocket的error事件。 | 4483| callback | ErrorCallback | 是 | 以callback的形式异步返回出现错误的结果。| 4484 4485**错误码：** 4486 4487| 错误码ID | 错误信息 | 4488| ------- | ----------------------- | 4489| 401 | Parameter error. | 4490 4491**示例：** 4492 4493```ts 4494import { socket } from '@kit.NetworkKit'; 4495 4496let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4497client.on('error', (err: Object) => { 4498 console.log("on error, err:" + JSON.stringify(err)) 4499}); 4500``` 4501 4502### off('error')<sup>11+</sup> 4503 4504off(type: 'error', callback?: ErrorCallback): void; 4505 4506取消订阅LocalSocket连接的error事件。使用callback方式作为异步方法。 4507 4508**系统能力**：SystemCapability.Communication.NetStack 4509 4510**参数：** 4511 4512| 参数名 | 类型 | 必填 | 说明 | 4513| -------- | ------------- | ---- | ----------------------------- | 4514| type | string | 是 | 取消订阅LocalSocket的error事件。 | 4515| callback | ErrorCallback | 否 | 指定传入on中的callback取消一个订阅。| 4516 4517**错误码：** 4518 4519| 错误码ID | 错误信息 | 4520| ------- | ----------------------- | 4521| 401 | Parameter error. | 4522 4523**示例：** 4524 4525```ts 4526import { socket } from '@kit.NetworkKit'; 4527 4528let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 4529let callback = (err: Object) => { 4530 console.log("on error, err:" + JSON.stringify(err)); 4531} 4532client.on('error', callback); 4533// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4534client.off('error', callback); 4535client.off('error'); 4536``` 4537 4538## LocalSocketMessageInfo<sup>11+</sup> 4539 4540LocalSocket客户端与服务端通信时接收的数据。 4541 4542**系统能力**：SystemCapability.Communication.NetStack 4543 4544| 名称 | 类型 | 必填 | 说明 | 4545| ------- | --------------- | --- | ------------------ | 4546| message | ArrayBuffer | 是 | 收到的消息数据。 | 4547| address | string | 是 | 使用的本地套接字路径。| 4548| size | number | 是 | 数据长度。 | 4549 4550## LocalAddress<sup>11+</sup> 4551 4552LocalSocket本地套接字文件路径信息，在传入套接字路径进行绑定时，会在此路径下创建套接字文件。 4553 4554**系统能力**：SystemCapability.Communication.NetStack 4555 4556| 名称 | 类型 | 必填 | 说明 | 4557| ------- | ---------- | --- | ------------------ | 4558| address | string | 是 | 本地套接字路径。 | 4559 4560## LocalConnectOptions<sup>11+</sup> 4561 4562LocalSocket客户端在连接服务端时传入的参数信息。 4563 4564**系统能力**：SystemCapability.Communication.NetStack 4565 4566| 名称 | 类型 | 必填 | 说明 | 4567| ------- | ---------- | --- | ------------------------------ | 4568| address | [LocalAddress](#localaddress11) | 是 | 指定的本地套接字路径。 | 4569| timeout | number | 否 | 连接服务端的超时时间，单位为毫秒。 | 4570 4571## LocalSendOptions<sup>11+</sup> 4572 4573LocalSocket发送请求的参数。 4574 4575**系统能力**：SystemCapability.Communication.NetStack 4576 4577| 名称 | 类型 | 必填 | 说明 | 4578| ------- | ---------- | --- | ------------------- | 4579| data | string \| ArrayBuffer | 是 | 需要发送的数据。 | 4580| encoding | string | 否 | 字符编码。 | 4581 4582## ExtraOptionsBase<sup>7+</sup> 4583 4584Socket套接字的基础属性。 4585 4586**系统能力**：SystemCapability.Communication.NetStack 4587 4588| 名称 | 类型 | 必填 | 说明 | 4589| ----------------- | ------- | ---- | ----------------------------- | 4590| receiveBufferSize | number | 否 | 接收缓冲区大小（单位：Byte）。 | 4591| sendBufferSize | number | 否 | 发送缓冲区大小（单位：Byte）。 | 4592| reuseAddress | boolean | 否 | 是否重用地址。 | 4593| socketTimeout | number | 否 | 套接字超时时间，单位毫秒（ms）。 | 4594 4595## socket.constructLocalSocketServerInstance<sup>11+</sup> 4596 4597constructLocalSocketServerInstance(): LocalSocketServer 4598 4599创建一个LocalSocketServer对象。 4600 4601**系统能力**：SystemCapability.Communication.NetStack 4602 4603**返回值：** 4604 4605| 类型 | 说明 | 4606| :---------------------------------- | :---------------------------- | 4607| [LocalSocketServer](#localsocketserver11) | 返回一个LocalSocketServer对象。 | 4608 4609**示例：** 4610 4611```ts 4612import { socket } from '@kit.NetworkKit'; 4613let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4614``` 4615 4616## LocalSocketServer<sup>11+</sup> 4617 4618LocalSocketServer类。在调用LocalSocketServer的方法前，需要先通过[socket.constructLocalSocketServerInstance](#socketconstructlocalsocketserverinstance11)创建LocalSocketServer对象。 4619 4620### listen<sup>11+</sup> 4621 4622listen(address: LocalAddress): Promise\<void\> 4623 4624绑定本地套接字文件，监听并接受与此套接字建立的LocalSocket连接。该接口使用多线程并发处理客户端的数据。使用Promise方法作为异步方法。 4625 4626> **说明：** 4627> 服务端使用该方法完成bind，listen，accept操作，传入套接字文件路径，调用此接口后会自动生成本地套接字文件。 4628 4629**系统能力**：SystemCapability.Communication.NetStack 4630 4631**参数：** 4632 4633| 参数名 | 类型 | 必填 | 说明 | 4634| ------- | ------------------------- | ---- | --------------------------------------------- | 4635| address | [LocalAddress](#localaddress11) | 是 | 目标地址信息。 | 4636 4637**返回值：** 4638 4639| 类型 | 说明 | 4640| :-------------- | :---------------------------------------------------- | 4641| Promise\<void\> | 以Promise形式返回执行结果, 成功返回空，失败返回错误码错误信息。| 4642 4643**错误码：** 4644 4645| 错误码ID | 错误信息 | 4646| -------- | --------------------------- | 4647| 401 | Parameter error. | 4648| 2303109 | Bad file number. | 4649| 2301013 | Insufficient permissions. | 4650| 2301022 | Invalid argument. | 4651| 2301098 | Address already in use. | 4652 4653**示例：** 4654 4655```ts 4656import { socket } from '@kit.NetworkKit'; 4657 4658let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4659let sandboxPath: string = getContext().filesDir + '/testSocket' 4660let addr: socket.LocalAddress = { 4661 address: sandboxPath 4662} 4663server.listen(addr).then(() => { 4664 console.log('listen success'); 4665}).catch((err: Object) => { 4666 console.error('listen fail: ' + JSON.stringify(err)); 4667}); 4668``` 4669 4670### getState<sup>11+</sup> 4671 4672getState(): Promise\<SocketStateBase\> 4673 4674获取LocalSocketServer状态。使用Promise方式作为异步方法。 4675 4676> **说明：** 4677> listen方法调用成功后，才可调用此方法。 4678 4679**系统能力**：SystemCapability.Communication.NetStack 4680 4681**返回值：** 4682 4683| 类型 | 说明 | 4684| :------------------------------------------- | :--------------------------------------------- | 4685| Promise\<[SocketStateBase](#socketstatebase)\> | 以Promise形式返回获取LocalSocketServer状态的结果。 | 4686 4687**示例：** 4688 4689```ts 4690import { socket } from '@kit.NetworkKit'; 4691 4692let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4693let sandboxPath: string = getContext().filesDir + '/testSocket' 4694let listenAddr: socket.LocalAddress = { 4695 address: sandboxPath 4696} 4697server.listen(listenAddr).then(() => { 4698 console.log("listen success"); 4699}).catch((err: Object) => { 4700 console.error("listen fail: " + JSON.stringify(err)); 4701}) 4702server.getState().then((data: socket.SocketStateBase) => { 4703 console.log('getState success: ' + JSON.stringify(data)); 4704}).catch((err: Object) => { 4705 console.error('getState fail: ' + JSON.stringify(err)); 4706}); 4707``` 4708 4709### setExtraOptions<sup>11+</sup> 4710 4711setExtraOptions(options: ExtraOptionsBase): Promise\<void\> 4712 4713设置LocalSocketServer连接的套接字属性，使用Promise方式作为异步方法。 4714 4715> **说明：** 4716> listen方法调用成功后，才可调用此方法。 4717 4718**系统能力**：SystemCapability.Communication.NetStack 4719 4720**参数：** 4721 4722| 参数名 | 类型 | 必填 | 说明 | 4723| ------- | --------------------------------------- | ---- | ------------------------------ | 4724| options | [ExtraOptionsBase](#extraoptionsbase7) | 是 | LocalSocketServer连接的其他属性。 | 4725 4726**返回值：** 4727 4728| 类型 | 说明 | 4729| :-------------- | :---------------------------------------------- | 4730| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 4731 4732**错误码：** 4733 4734| 错误码ID | 错误信息 | 4735| -------- | ------------------------------- | 4736| 401 | Parameter error. | 4737| 2301009 | Bad file descriptor. | 4738 4739**示例：** 4740 4741```ts 4742import { socket } from '@kit.NetworkKit'; 4743 4744let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4745let sandboxPath: string = getContext().filesDir + '/testSocket' 4746let listenAddr: socket.NetAddress = { 4747 address: sandboxPath 4748} 4749server.listen(listenAddr).then(() => { 4750 console.log("listen success"); 4751}).catch((err: Object) => { 4752 console.error("listen fail: " + JSON.stringify(err)); 4753}) 4754 4755let options: socket.ExtraOptionsBase = { 4756 receiveBufferSize: 6000, 4757 sendBufferSize: 6000, 4758 socketTimeout: 3000 4759} 4760server.setExtraOptions(options).then(() => { 4761 console.log('setExtraOptions success'); 4762}).catch((err: Object) => { 4763 console.error('setExtraOptions fail: ' + JSON.stringify(err)); 4764}); 4765``` 4766 4767### getExtraOptions<sup>11+</sup> 4768 4769getExtraOptions(): Promise\<ExtraOptionsBase\>; 4770 4771获取LocalSocketServer中连接的套接字的属性，使用Promise方式作为异步方法。 4772 4773> **说明：** 4774> listen方法调用成功后，才可调用此方法。 4775 4776**系统能力**：SystemCapability.Communication.NetStack 4777 4778**返回值：** 4779 4780| 类型 | 说明 | 4781| :-------------------------- | :-------------------------- | 4782| Promise\<[ExtraOptionsBase](#extraoptionsbase7)\> | 以Promise形式返回套接字的属性。 | 4783 4784**错误码：** 4785 4786| 错误码ID | 错误信息 | 4787| -------- | -------------------- | 4788| 401 | Parameter error. | 4789 4790**示例：** 4791 4792```ts 4793import { socket } from '@kit.NetworkKit'; 4794 4795let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4796let sandboxPath: string = getContext().filesDir + '/testSocket' 4797let listenAddr: socket.LocalAddress = { 4798 address: sandboxPath 4799} 4800server.listen(listenAddr).then(() => { 4801 console.log("listen success"); 4802}).catch((err: Object) => { 4803 console.error("listen fail: " + JSON.stringify(err)); 4804}) 4805server.getExtraOptions().then((options: socket.ExtraOptionsBase) => { 4806 console.log('options: ' + JSON.stringify(options)); 4807}).catch((err: Object) => { 4808 console.error('getExtraOptions fail: ' + JSON.stringify(err)); 4809}); 4810``` 4811 4812### getLocalAddress<sup>12+</sup> 4813 4814getLocalAddress(): Promise\<string\> 4815 4816获取LocalSocketServer中本地Socket地址。使用Promise方式作为异步方法。 4817 4818> **说明：** 4819> listen方法调用成功后，才可调用此方法。 4820 4821**系统能力**：SystemCapability.Communication.NetStack 4822 4823**返回值：** 4824 4825| 类型 | 说明 | 4826| -------------- | --------------------------------------------------- | 4827| Promise\<string\> | 以Promise形式返回获取本地socket地址的结果。 | 4828 4829**错误码：** 4830 4831| 错误码ID | 错误信息 | 4832| -------- | ------------------------------------------- | 4833| 2300002 | System internal error. | 4834| 2301009 | Bad file descriptor. | 4835| 2303188 | Socket operation on non-socket. | 4836 4837**示例：** 4838 4839```ts 4840let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4841let sandboxPath: string = getContext().filesDir + '/testSocket'; 4842let listenAddr: socket.LocalAddress = { 4843 address: sandboxPath 4844} 4845server.listen(listenAddr).then(() => { 4846 console.info("listen success"); 4847 server.getLocalAddress().then((localPath: string) => { 4848 console.info("SUCCESS " + JSON.stringify(localPath)); 4849 }).catch((err: BusinessError) => { 4850 console.error("FAIL " + JSON.stringify(err)); 4851 }) 4852}).catch((err: Object) => { 4853 console.error("listen fail: " + JSON.stringify(err)); 4854}) 4855 4856``` 4857 4858### on('connect')<sup>11+</sup> 4859 4860on(type: 'connect', callback: Callback\<LocalSocketConnection\>): void 4861 4862订阅LocalSocketServer的连接事件。使用callback方式作为异步方法。 4863 4864> **说明：** 4865> listen方法调用成功后，才可调用此方法。 4866 4867**系统能力**：SystemCapability.Communication.NetStack 4868 4869**参数：** 4870 4871| 参数名 | 类型 | 必填 | 说明 | 4872| -------- | ------------------------------- | ---- | ------------------------------------- | 4873| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 4874| callback | Callback\<[LocalSocketConnection](#localsocketconnection11)\> | 是 | 以callback的形式异步返回接收到客户端连接的结果。| 4875 4876**错误码：** 4877 4878| 错误码ID | 错误信息 | 4879| -------- | ---------------- | 4880| 401 | Parameter error. | 4881 4882**示例：** 4883 4884```ts 4885import { socket } from '@kit.NetworkKit'; 4886 4887let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4888server.on('connect', (connection: socket.LocalSocketConnection) => { 4889 if (connection) { 4890 console.log('accept a client') 4891 } 4892}); 4893``` 4894 4895### off('connect')<sup>11+</sup> 4896 4897off(type: 'connect', callback?: Callback\<LocalSocketConnection\>): void 4898 4899取消订阅LocalSocketServer的连接事件。使用callback方式作为异步方法。 4900 4901**系统能力**：SystemCapability.Communication.NetStack 4902 4903**参数：** 4904 4905| 参数名 | 类型 | 必填 | 说明 | 4906| -------- | ------------------------------- | ---- | ------------------------------------- | 4907| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 4908| callback | Callback\<[LocalSocketConnection](#localsocketconnection11)\> | 否 | 指定传入on的一个callback取消注册。| 4909 4910**错误码：** 4911 4912| 错误码ID | 错误信息 | 4913| -------- | ---------------- | 4914| 401 | Parameter error. | 4915 4916**示例：** 4917 4918```ts 4919import { socket } from '@kit.NetworkKit'; 4920 4921let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4922let callback = (connection: socket.LocalSocketConnection) => { 4923 if (connection) { 4924 console.log('accept a client') 4925 } 4926} 4927server.on('connect', callback); 4928// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 4929server.off('connect', callback); 4930server.off('connect'); 4931``` 4932 4933### on('error')<sup>11+</sup> 4934 4935on(type: 'error', callback: ErrorCallback): void 4936 4937订阅LocalSocketServer连接的error事件。使用callback方式作为异步方法。 4938 4939> **说明：** 4940> listen方法调用成功后，才可调用此方法。 4941 4942**系统能力**：SystemCapability.Communication.NetStack 4943 4944**参数：** 4945 4946| 参数名 | 类型 | 必填 | 说明 | 4947| -------- | ------------- | ---- | ------------------------------------ | 4948| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 4949| callback | ErrorCallback | 是 | 以callback的形式异步返回出现错误的结果。| 4950 4951**错误码：** 4952 4953| 错误码ID | 错误信息 | 4954| -------- | ---------------- | 4955| 401 | Parameter error. | 4956 4957**示例：** 4958 4959```ts 4960import { socket } from '@kit.NetworkKit'; 4961 4962let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4963server.on('error', (err: Object) => { 4964 console.error("on error, err:" + JSON.stringify(err)) 4965}); 4966``` 4967 4968### off('error')<sup>11+</sup> 4969 4970off(type: 'error', callback?: ErrorCallback): void 4971 4972取消订阅LocalSocketServer连接的error事件。使用callback方式作为异步方法。 4973 4974**系统能力**：SystemCapability.Communication.NetStack 4975 4976**参数：** 4977 4978| 参数名 | 类型 | 必填 | 说明 | 4979| -------- | ------------- | ---- | ------------------------------------ | 4980| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 4981| callback | ErrorCallback | 否 | 指定传入on的一个callback取消订阅。 | 4982 4983**错误码：** 4984 4985| 错误码ID | 错误信息 | 4986| -------- | ---------------- | 4987| 401 | Parameter error. | 4988 4989**示例：** 4990 4991```ts 4992import { socket } from '@kit.NetworkKit'; 4993 4994let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 4995let callback = (err: Object) => { 4996 console.error("on error, err:" + JSON.stringify(err)); 4997} 4998server.on('error', callback); 4999// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5000server.off('error', callback); 5001server.off('error'); 5002``` 5003 5004 5005## LocalSocketConnection<sup>11+</sup> 5006 5007LocalSocketConnection连接，即LocalSocket客户端与服务端的会话连接。在调用LocalSocketConnection的方法前，需要先获取LocalSocketConnection对象。 5008 5009> **说明：** 5010> 客户端与服务端成功建立连接后，才能通过返回的LocalSocketConnection对象调用相应的接口。 5011 5012**系统能力**：SystemCapability.Communication.NetStack 5013 5014### 属性 5015 5016| 名称 | 类型 | 必填 | 说明 | 5017| -------- | ------ | ---- | ---------------------------- | 5018| clientId | number | 是 | 客户端与服务端建立的会话连接的id。 | 5019 5020### send<sup>11+</sup> 5021 5022send(options: LocalSendOptions): Promise\<void\> 5023 5024通过LocalSocketConnection连接对象发送数据。使用Promise方式作为异步方法。 5025 5026> **说明：** 5027> 服务端与客户端建立连接后，服务端通过connect事件回调得到LocalSocketConnection连接对象后，才可使用连接对象调用此方法。 5028 5029**系统能力**：SystemCapability.Communication.NetStack 5030 5031**参数：** 5032 5033| 参数名 | 类型 | 必填 | 说明 | 5034| ------- | --------------------------------- | ---- | -------------------------------------- | 5035| options | [LocalSendOptions](#localsendoptions11) | 是 | LocalSocketConnection发送请求的参数。 | 5036 5037**返回值：** 5038 5039| 类型 | 说明 | 5040| :-------------- | :---------------------------------------------- | 5041| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 5042 5043**错误码：** 5044 5045| 错误码ID | 错误信息 | 5046| -------- | ---------------------- | 5047| 401 | Parameter error. | 5048| 2301011 | Operation would block. | 5049 5050**示例：** 5051 5052```ts 5053import { socket } from '@kit.NetworkKit'; 5054 5055let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5056 5057server.on('connect', (connection: socket.LocalSocketConnection) => { 5058 let sendOptions: socket.LocalSendOptions = { 5059 data: 'Hello, client!' 5060 } 5061 connection.send(sendOptions).then(() => { 5062 console.log('send success'); 5063 }).catch((err: Object) => { 5064 console.error('send fail: ' + JSON.stringify(err)); 5065 }); 5066}); 5067``` 5068 5069### close<sup>11+</sup> 5070 5071close(): Promise\<void\> 5072 5073关闭一个LocalSocket客户端与服务端建立的连接。使用Promise方式作为异步方法。 5074 5075**系统能力**：SystemCapability.Communication.NetStack 5076 5077**返回值：** 5078 5079| 类型 | 说明 | 5080| :-------------- | :------------------------------------------- | 5081| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码错误信息。 | 5082 5083**错误码：** 5084 5085| 错误码ID | 错误信息 | 5086| -------- | -------------------- | 5087| 2301009 | Bad file descriptor. | 5088 5089**示例：** 5090 5091```ts 5092import { socket } from '@kit.NetworkKit'; 5093 5094let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5095server.on('connect', (connection: socket.LocalSocketConnection) => { 5096 connection.close().then(() => { 5097 console.log('close success'); 5098 }).catch((err: Object) => { 5099 console.error('close fail: ' + JSON.stringify(err)); 5100 }); 5101}); 5102``` 5103 5104### getLocalAddress<sup>12+</sup> 5105 5106getLocalAddress(): Promise\<string\> 5107 5108获取LocalSocketConnection连接中的本地Socket地址。使用Promise方式作为异步方法。 5109 5110**系统能力**：SystemCapability.Communication.NetStack 5111 5112**返回值：** 5113 5114| 类型 | 说明 | 5115| -------------- | --------------------------------------------------- | 5116| Promise\<string\> | 以Promise形式返回获取本地socket地址的结果。 | 5117 5118**错误码：** 5119 5120| 错误码ID | 错误信息 | 5121| -------- | ------------------------------------------- | 5122| 2300002 | System internal error. | 5123| 2301009 | Bad file descriptor. | 5124| 2303188 | Socket operation on non-socket. | 5125 5126**示例：** 5127 5128```ts 5129let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5130let sandboxPath: string = getContext().filesDir + '/testSocket'; 5131let localAddr: socket.LocalAddress = { 5132 address: sandboxPath 5133} 5134server.listen(localAddr).then(() => { 5135 console.info('listen success'); 5136 let client: socket.LocalSocket = socket.constructLocalSocketInstance(); 5137 let connectOpt: socket.LocalConnectOptions = { 5138 address: localAddr, 5139 timeout: 6000 5140 } 5141 client.connect(connectOpt).then(() => { 5142 server.getLocalAddress().then((localPath: string) => { 5143 console.info("success, localPath is" + JSON.stringify(localPath)); 5144 }).catch((err: BusinessError) => { 5145 console.error("FAIL " + JSON.stringify(err)); 5146 }) 5147 }).catch((err: Object) => { 5148 console.error('connect fail: ' + JSON.stringify(err)); 5149 }); 5150}); 5151``` 5152 5153### on('message')<sup>11+</sup> 5154 5155on(type: 'message', callback: Callback\<LocalSocketMessageInfo\>): void; 5156 5157订阅LocalSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 5158 5159**系统能力**：SystemCapability.Communication.NetStack 5160 5161**参数：** 5162 5163| 参数名 | 类型 | 必填 | 说明 | 5164| -------- | ----------------------------------------------- | ---- | --------------------------------------- | 5165| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 5166| callback | Callback\<[LocalSocketMessageInfo](#localsocketmessageinfo11)\> | 是 | 以callback的形式异步返回接收到的来自客户端的消息。 | 5167 5168**错误码：** 5169 5170| 错误码ID | 错误信息 | 5171| -------- | ---------------- | 5172| 401 | Parameter error. | 5173 5174**示例：** 5175 5176```ts 5177import { socket } from '@kit.NetworkKit'; 5178 5179let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5180let sandboxPath: string = getContext().filesDir + '/testSocket' 5181let listenAddr: socket.LocalAddress = { 5182 address: sandboxPath 5183} 5184server.listen(listenAddr).then(() => { 5185 console.log("listen success"); 5186}).catch((err: Object) => { 5187 console.error("listen fail: " + JSON.stringify(err)); 5188}); 5189server.on('connect', (connection: socket.LocalSocketConnection) => { 5190 connection.on('message', (value: socket.LocalSocketMessageInfo) => { 5191 const uintArray = new Uint8Array(value.message); 5192 let messageView = ''; 5193 for (let i = 0; i < uintArray.length; i++) { 5194 messageView += String.fromCharCode(uintArray[i]); 5195 } 5196 console.log('total: ' + JSON.stringify(value)); 5197 console.log('message infomation: ' + messageView); 5198 }); 5199}); 5200``` 5201 5202### off('message')<sup>11+</sup> 5203 5204off(type: 'message', callback?: Callback\<LocalSocketMessageInfo\>): void 5205 5206取消订阅LocalSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 5207 5208**系统能力**：SystemCapability.Communication.NetStack 5209 5210**参数：** 5211 5212| 参数名 | 类型 | 必填 | 说明 | 5213| -------- | ----------------------------------------------- | ---- | ----------------------------------- | 5214| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 5215| callback | Callback\<[LocalSocketMessageInfo](#localsocketmessageinfo11)\> | 否 | 指定传入on的一个callback取消注册。 | 5216 5217**错误码：** 5218 5219| 错误码ID | 错误信息 | 5220| -------- | ---------------- | 5221| 401 | Parameter error. | 5222 5223**示例：** 5224 5225```ts 5226import { socket } from '@kit.NetworkKit'; 5227 5228let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5229let callback = (value: socket.LocalSocketMessageInfo) => { 5230 const uintArray = new Uint8Array(value.message) 5231 let messageView = ''; 5232 for (let i = 0; i < uintArray.length; i++) { 5233 messageView += String.fromCharCode(uintArray[i]); 5234 } 5235 console.log('total: ' + JSON.stringify(value)); 5236 console.log('message infomation: ' + messageView); 5237} 5238server.on('connect', (connection: socket.LocalSocketConnection) => { 5239 connection.on('message', callback); 5240 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5241 connection.off('message', callback); 5242 connection.off('message'); 5243}); 5244``` 5245 5246### on('close')<sup>11+</sup> 5247 5248on(type: 'close', callback: Callback\<void\>): void 5249 5250订阅LocalSocketConnection的关闭事件。使用callback方式作为异步方法。 5251 5252**系统能力**：SystemCapability.Communication.NetStack 5253 5254**参数：** 5255 5256| 参数名 | 类型 | 必填 | 说明 | 5257| -------- | ---------------- | ---- | ----------------------------------- | 5258| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 5259| callback | Callback\<void\> | 是 | 以callback的形式异步返回会话关闭的结果。 | 5260 5261**错误码：** 5262 5263| 错误码ID | 错误信息 | 5264| -------- | ---------------- | 5265| 401 | Parameter error. | 5266 5267**示例：** 5268 5269```ts 5270import { socket } from '@kit.NetworkKit'; 5271 5272let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5273server.on('connect', (connection: socket.LocalSocketConnection) => { 5274 connection.on('close', () => { 5275 console.log("on close success") 5276 }); 5277}); 5278``` 5279 5280### off('close')<sup>11+</sup> 5281 5282off(type: 'close', callback?: Callback\<void\>): void 5283 5284取消订阅LocalSocketConnection的关闭事件。使用callback方式作为异步方法。 5285 5286**系统能力**：SystemCapability.Communication.NetStack 5287 5288**参数：** 5289 5290| 参数名 | 类型 | 必填 | 说明 | 5291| -------- | ---------------- | ---- | ----------------------------------- | 5292| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 5293| callback | Callback\<void\> | 否 | 指定传入on的一个callback取消订阅。 | 5294 5295**错误码：** 5296 5297| 错误码ID | 错误信息 | 5298| -------- | ---------------- | 5299| 401 | Parameter error. | 5300 5301**示例：** 5302 5303```ts 5304import { socket } from '@kit.NetworkKit'; 5305 5306let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5307let callback = () => { 5308 console.log("on close success"); 5309} 5310server.on('connect', (connection: socket.LocalSocketConnection) => { 5311 connection.on('close', callback); 5312 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5313 connection.off('close', callback); 5314 connection.off('close'); 5315}); 5316``` 5317 5318### on('error')<sup>11+</sup> 5319 5320on(type: 'error', callback: ErrorCallback): void 5321 5322订阅LocalSocketConnection连接的error事件。使用callback方式作为异步方法。 5323 5324**系统能力**：SystemCapability.Communication.NetStack 5325 5326**参数：** 5327 5328| 参数名 | 类型 | 必填 | 说明 | 5329| -------- | ------------- | ---- | ------------------------------------ | 5330| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 5331| callback | ErrorCallback | 是 | 以callback的形式异步返回出现错误的结果。| 5332 5333**错误码：** 5334 5335| 错误码ID | 错误信息 | 5336| -------- | ---------------- | 5337| 401 | Parameter error. | 5338 5339**示例：** 5340 5341```ts 5342import { socket } from '@kit.NetworkKit'; 5343 5344let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5345server.on('connect', (connection: socket.LocalSocketConnection) => { 5346 connection.on('error', (err: Object) => { 5347 console.error("on error, err:" + JSON.stringify(err)) 5348 }); 5349}); 5350``` 5351 5352### off('error')<sup>11+</sup> 5353 5354off(type: 'error', callback?: ErrorCallback): void 5355 5356取消订阅LocalSocketConnection连接的error事件。使用callback方式作为异步方法。 5357 5358**系统能力**：SystemCapability.Communication.NetStack 5359 5360**参数：** 5361 5362| 参数名 | 类型 | 必填 | 说明 | 5363| -------- | ------------- | ---- | ------------------------------------ | 5364| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 5365| callback | ErrorCallback | 否 | 指定传入on的一个callback取消订阅。 | 5366 5367**错误码：** 5368 5369| 错误码ID | 错误信息 | 5370| -------- | ---------------- | 5371| 401 | Parameter error. | 5372 5373**示例：** 5374 5375```ts 5376import { socket } from '@kit.NetworkKit'; 5377 5378let callback = (err: Object) => { 5379 console.error("on error, err: " + JSON.stringify(err)); 5380} 5381let server: socket.LocalSocketServer = socket.constructLocalSocketServerInstance(); 5382server.on('connect', (connection: socket.LocalSocketConnection) => { 5383 connection.on('error', callback); 5384 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5385 connection.off('error', callback); 5386 connection.off('error'); 5387}); 5388``` 5389 5390## LocalSocket 错误码说明 5391 5392LocalSocket 错误码映射形式为：2301000 + Linux内核错误码。 5393 5394错误码的详细介绍参见[Socket错误码](errorcode-net-socket.md) 5395 5396## socket.constructTLSSocketInstance<sup>9+</sup> 5397 5398constructTLSSocketInstance(): TLSSocket 5399 5400创建并返回一个TLSSocket对象。 5401 5402**系统能力**：SystemCapability.Communication.NetStack 5403 5404**返回值:** 5405 5406| 类型 | 说明 | 5407| --------------------------------- | ---------------------- | 5408| [TLSSocket](#tlssocket9) | 返回一个TLSSocket对象。 | 5409 5410**示例：** 5411 5412```ts 5413import { socket } from '@kit.NetworkKit'; 5414 5415let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5416``` 5417 5418## socket.constructTLSSocketInstance<sup>12+</sup> 5419 5420constructTLSSocketInstance(tcpSocket: TCPSocket): TLSSocket 5421 5422将TCPSocket升级为TLSSocket，创建并返回一个TLSSocket对象。 5423 5424> **说明：** 5425> 需要确保TCPSocket已连接，并且当前已经没有传输数据，再调用constructTLSSocketInstance升级TLSSocket。当升级成功后，无需对TCPSocket对象调用close方法。 5426 5427**系统能力**：SystemCapability.Communication.NetStack 5428 5429**参数：** 5430 5431| 参数名 | 类型 | 必填 | 说明 | 5432|-----------|----| ---- |------------------------| 5433| tcpSocket | [TCPSocket](#tcpsocket) | 是 | 需要进行升级的TCPSocket对象。 | 5434 5435**返回值:** 5436 5437| 类型 | 说明 | 5438| --------------------------------- | ---------------------- | 5439| [TLSSocket](#tlssocket9) | 返回一个TLSSocket对象。 | 5440 5441**错误码：** 5442 5443| 错误码ID | 错误信息 | 5444|---------|----------------------------------| 5445| 401 | Parameter error. | 5446| 2300002 | System internal error. | 5447| 2303601 | Invalid socket FD. | 5448| 2303602 | Socket is not connected. | 5449 5450**示例：** 5451 5452```ts 5453import { socket } from '@kit.NetworkKit'; 5454import { BusinessError } from '@kit.BasicServicesKit'; 5455 5456let tcp: socket.TCPSocket = socket.constructTCPSocketInstance(); 5457let tcpconnectoptions: socket.TCPConnectOptions = { 5458 address: { 5459 address: '192.168.xx.xxx', 5460 port: 8080 5461 }, 5462 timeout: 6000 5463} 5464tcp.connect(tcpconnectoptions, (err: BusinessError) => { 5465 if (err) { 5466 console.log('connect fail'); 5467 return; 5468 } 5469 console.log('connect success'); 5470 5471 // 确保TCPSocket已连接后，再升级TLSSocket 5472 let tls: socket.TLSSocket = socket.constructTLSSocketInstance(tcp); 5473}) 5474``` 5475 5476## TLSSocket<sup>9+</sup> 5477 5478TLSSocket连接。在调用TLSSocket的方法前，需要先通过[socket.constructTLSSocketInstance](#socketconstructtlssocketinstance9)创建TLSSocket对象。 5479 5480### bind<sup>9+</sup> 5481 5482bind(address: NetAddress, callback: AsyncCallback\<void\>): void 5483 5484绑定IP地址和端口。使用callback方法作为异步方法。 5485 5486> **说明：** 5487> 如果TLSSocket对象是通过TCPSocket对象升级创建的，可以不用执行bind方法。 5488 5489**需要权限**：ohos.permission.INTERNET 5490 5491**系统能力**：SystemCapability.Communication.NetStack 5492 5493**参数：** 5494 5495| 参数名 | 类型 | 必填 | 说明 | 5496| -------- | ---------------------------------- | ---- | ------------------------------------------------------ | 5497| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 5498| callback | AsyncCallback\<void\> | 是 | 回调函数。成功返回TLSSocket绑定本机的IP地址和端口的结果。失败返回错误码、错误信息。| 5499 5500**错误码：** 5501 5502| 错误码ID | 错误信息 | 5503| ------- | ----------------------- | 5504| 401 | Parameter error. | 5505| 201 | Permission denied. | 5506| 2303198 | Address already in use. | 5507| 2300002 | System internal error. | 5508 5509**示例：** 5510 5511```ts 5512import { socket } from '@kit.NetworkKit'; 5513import { BusinessError } from '@kit.BasicServicesKit'; 5514 5515let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5516let bindAddr: socket.NetAddress = { 5517 address: '192.168.xx.xxx', 5518 port: 8080 5519} 5520tls.bind(bindAddr, (err: BusinessError) => { 5521 if (err) { 5522 console.log('bind fail'); 5523 return; 5524 } 5525 console.log('bind success'); 5526}); 5527``` 5528 5529### bind<sup>9+</sup> 5530 5531bind(address: NetAddress): Promise\<void\> 5532 5533绑定IP地址和端口。使用Promise方法作为异步方法。 5534 5535> **说明：** 5536> 如果TLSSocket对象是通过TCPSocket对象升级创建的，可以不用执行bind方法。 5537 5538**需要权限**：ohos.permission.INTERNET 5539 5540**系统能力**：SystemCapability.Communication.NetStack 5541 5542**参数：** 5543 5544| 参数名 | 类型 | 必填 | 说明 | 5545| ------- | ---------------------------------- | ---- | ------------------------------------------------------ | 5546| address | [NetAddress](#netaddress) | 是 | 目标地址信息，参考[NetAddress](#netaddress)。 | 5547 5548**返回值：** 5549 5550| 类型 | 说明 | 5551| -------------- | ------------------------------------------------------- | 5552| Promise\<void\> | 以Promise形式返回TLSSocket绑定本机的IP地址和端口的结果。失败返回错误码，错误信息。 | 5553 5554**错误码：** 5555 5556| 错误码ID | 错误信息 | 5557| ------- | ----------------------- | 5558| 401 | Parameter error. | 5559| 201 | Permission denied. | 5560| 2303198 | Address already in use. | 5561| 2300002 | System internal error. | 5562 5563**示例：** 5564 5565```ts 5566import { socket } from '@kit.NetworkKit'; 5567import { BusinessError } from '@kit.BasicServicesKit'; 5568 5569let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5570let bindAddr: socket.NetAddress = { 5571 address: '192.168.xx.xxx', 5572 port: 8080 5573} 5574tls.bind(bindAddr).then(() => { 5575 console.log('bind success'); 5576}).catch((err: BusinessError) => { 5577 console.log('bind fail'); 5578}); 5579``` 5580 5581### getState<sup>9+</sup> 5582 5583getState(callback: AsyncCallback\<SocketStateBase\>): void 5584 5585在TLSSocket的bind成功之后，获取TLSSocket状态。使用callback方式作为异步方法。 5586 5587**系统能力**：SystemCapability.Communication.NetStack 5588 5589**参数：** 5590 5591| 参数名 | 类型 | 必填 | 说明 | 5592| -------- | ------------------------------------------------------ | ---- | ---------- | 5593| callback | AsyncCallback\<[SocketStateBase](#socketstatebase)\> | 是 | 回调函数。成功返回TLSSocket状态，失败返回错误码、错误信息。 | 5594 5595**错误码：** 5596 5597| 错误码ID | 错误信息 | 5598| ------- | ------------------------------ | 5599| 2303188 | Socket operation on non-socket.| 5600| 2300002 | System internal error. | 5601 5602**示例：** 5603 5604```ts 5605import { socket } from '@kit.NetworkKit'; 5606import { BusinessError } from '@kit.BasicServicesKit'; 5607 5608let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5609let bindAddr: socket.NetAddress = { 5610 address: '192.168.xx.xxx', 5611 port: 8080 5612} 5613tls.bind(bindAddr, (err: BusinessError) => { 5614 if (err) { 5615 console.log('bind fail'); 5616 return; 5617 } 5618 console.log('bind success'); 5619}); 5620tls.getState((err: BusinessError, data: socket.SocketStateBase) => { 5621 if (err) { 5622 console.log('getState fail'); 5623 return; 5624 } 5625 console.log('getState success:' + JSON.stringify(data)); 5626}); 5627``` 5628 5629### getState<sup>9+</sup> 5630 5631getState(): Promise\<SocketStateBase\> 5632 5633在TLSSocket的bind成功之后，获取TLSSocket状态。使用Promise方式作为异步方法。 5634 5635**系统能力**：SystemCapability.Communication.NetStack 5636 5637**返回值：** 5638 5639| 类型 | 说明 | 5640| ----------------------------------------------- | ----------------------------------------- | 5641| Promise\<[SocketStateBase](#socketstatebase)\> | 以Promise形式返回获取TLSSocket状态的结果。失败返回错误码，错误信息。| 5642 5643**错误码：** 5644 5645| 错误码ID | 错误信息 | 5646| ------- | ------------------------------ | 5647| 2303188 | Socket operation on non-socket.| 5648| 2300002 | System internal error. | 5649 5650**示例：** 5651 5652```ts 5653import { socket } from '@kit.NetworkKit'; 5654import { BusinessError } from '@kit.BasicServicesKit'; 5655 5656let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5657let bindAddr: socket.NetAddress = { 5658 address: '192.168.xx.xxx', 5659 port: 8080 5660} 5661tls.bind(bindAddr, (err: BusinessError) => { 5662 if (err) { 5663 console.log('bind fail'); 5664 return; 5665 } 5666 console.log('bind success'); 5667}); 5668tls.getState().then(() => { 5669 console.log('getState success'); 5670}).catch((err: BusinessError) => { 5671 console.log('getState fail'); 5672}); 5673``` 5674 5675### setExtraOptions<sup>9+</sup> 5676 5677setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void 5678 5679在TLSSocket的bind成功之后，设置TCPSocket连接的其他属性。使用callback方式作为异步方法。 5680 5681**系统能力**：SystemCapability.Communication.NetStack 5682 5683**参数：** 5684 5685| 参数名 | 类型 | 必填 | 说明 | 5686| -------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 5687| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 | 5688| callback | AsyncCallback\<void\> | 是 | 回调函数。成功返回设置TCPSocket连接的其他属性的结果，失败返回错误码、错误信息。| 5689 5690**错误码：** 5691 5692| 错误码ID | 错误信息 | 5693| ------- | ----------------------------- | 5694| 401 | Parameter error. | 5695| 2303188 | Socket operation on non-socket.| 5696| 2300002 | System internal error. | 5697 5698**示例：** 5699 5700```ts 5701import { socket } from '@kit.NetworkKit'; 5702import { BusinessError } from '@kit.BasicServicesKit'; 5703 5704let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5705let bindAddr: socket.NetAddress = { 5706 address: '192.168.xx.xxx', 5707 port: 8080 5708} 5709tls.bind(bindAddr, (err: BusinessError) => { 5710 if (err) { 5711 console.log('bind fail'); 5712 return; 5713 } 5714 console.log('bind success'); 5715}); 5716 5717interface SocketLinger { 5718 on: boolean; 5719 linger: number; 5720} 5721 5722let tcpExtraOptions: socket.TCPExtraOptions = { 5723 keepAlive: true, 5724 OOBInline: true, 5725 TCPNoDelay: true, 5726 socketLinger: { on: true, linger: 10 } as SocketLinger, 5727 receiveBufferSize: 1000, 5728 sendBufferSize: 1000, 5729 reuseAddress: true, 5730 socketTimeout: 3000 5731} 5732tls.setExtraOptions(tcpExtraOptions, (err: BusinessError) => { 5733 if (err) { 5734 console.log('setExtraOptions fail'); 5735 return; 5736 } 5737 console.log('setExtraOptions success'); 5738}); 5739``` 5740 5741### setExtraOptions<sup>9+</sup> 5742 5743setExtraOptions(options: TCPExtraOptions): Promise\<void\> 5744 5745在TLSSocket的bind成功之后，设置TCPSocket连接的其他属性，使用Promise方式作为异步方法。 5746 5747**系统能力**：SystemCapability.Communication.NetStack 5748 5749**参数：** 5750 5751| 参数名 | 类型 | 必填 | 说明 | 5752| ------- | ----------------------------------------- | ---- | ------------------------------------------------------------ | 5753| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TCPSocket连接的其他属性，参考[TCPExtraOptions](#tcpextraoptions)。 | 5754 5755**返回值：** 5756 5757| 类型 | 说明 | 5758| -------------- | --------------------------------------------------- | 5759| Promise\<void\> | 以Promise形式返回设置TCPSocket连接的其他属性的结果。失败返回错误码，错误信息。 | 5760 5761**错误码：** 5762 5763| 错误码ID | 错误信息 | 5764| ------- | ------------------------------ | 5765| 401 | Parameter error. | 5766| 2303188 | Socket operation on non-socket.| 5767| 2300002 | System internal error. | 5768 5769**示例：** 5770 5771```ts 5772import { socket } from '@kit.NetworkKit'; 5773import { BusinessError } from '@kit.BasicServicesKit'; 5774 5775let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5776let bindAddr: socket.NetAddress = { 5777 address: '192.168.xx.xxx', 5778 port: 8080 5779} 5780tls.bind(bindAddr, (err: BusinessError) => { 5781 if (err) { 5782 console.log('bind fail'); 5783 return; 5784 } 5785 console.log('bind success'); 5786}); 5787 5788interface SocketLinger { 5789 on: boolean; 5790 linger: number; 5791} 5792 5793let tcpExtraOptions: socket.TCPExtraOptions = { 5794 keepAlive: true, 5795 OOBInline: true, 5796 TCPNoDelay: true, 5797 socketLinger: { on: true, linger: 10 } as SocketLinger, 5798 receiveBufferSize: 1000, 5799 sendBufferSize: 1000, 5800 reuseAddress: true, 5801 socketTimeout: 3000 5802} 5803tls.setExtraOptions(tcpExtraOptions).then(() => { 5804 console.log('setExtraOptions success'); 5805}).catch((err: BusinessError) => { 5806 console.log('setExtraOptions fail'); 5807}); 5808``` 5809 5810### on('message')<sup>9+</sup> 5811 5812on(type: 'message', callback: Callback\<SocketMessageInfo\>): void; 5813 5814订阅TLSSocket连接的接收消息事件。使用callback方式作为异步方法。 5815 5816**系统能力**：SystemCapability.Communication.NetStack 5817 5818**参数：** 5819 5820| 参数名 | 类型 | 必填 | 说明 | 5821| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 5822| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 5823| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 是 | 回调函数。TLSSocket连接订阅某类接受消息事件触发的调用函数，返回TLSSocket连接信息。 | 5824 5825**错误码：** 5826 5827| 错误码ID | 错误信息 | 5828| ------- | ------------------------------ | 5829| 401 | Parameter error. | 5830 5831**示例：** 5832 5833```ts 5834import { socket } from '@kit.NetworkKit'; 5835import { BusinessError } from '@kit.BasicServicesKit'; 5836 5837let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5838let messageView = ''; 5839tls.on('message', (value: socket.SocketMessageInfo) => { 5840 for (let i: number = 0; i < value.message.byteLength; i++) { 5841 let uint8Array = new Uint8Array(value.message) 5842 let messages = uint8Array[i] 5843 let message = String.fromCharCode(messages); 5844 messageView += message; 5845 } 5846 console.log('on message message: ' + JSON.stringify(messageView)); 5847 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 5848}); 5849``` 5850 5851### off('message')<sup>9+</sup> 5852 5853off(type: 'message', callback?: Callback\<SocketMessageInfo\>): void 5854 5855取消订阅TLSSocket连接的接收消息事件。使用callback方式作为异步方法。 5856 5857**系统能力**：SystemCapability.Communication.NetStack 5858 5859**参数：** 5860 5861| 参数名 | 类型 | 必填 | 说明 | 5862| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 5863| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 5864| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 否 | 回调函数。TLSSocket连接取消订阅某类接受消息事件触发的调用函数，返回TLSSocket连接信息。 | 5865 5866**错误码：** 5867 5868| 错误码ID | 错误信息 | 5869| ------- | ------------------------------ | 5870| 401 | Parameter error. | 5871 5872**示例：** 5873 5874```ts 5875import { socket } from '@kit.NetworkKit'; 5876import { BusinessError } from '@kit.BasicServicesKit'; 5877 5878let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5879let messageView = ''; 5880let callback = (value: socket.SocketMessageInfo) => { 5881 for (let i: number = 0; i < value.message.byteLength; i++) { 5882 let uint8Array = new Uint8Array(value.message) 5883 let messages = uint8Array[i] 5884 let message = String.fromCharCode(messages); 5885 messageView += message; 5886 } 5887 console.log('on message message: ' + JSON.stringify(messageView)); 5888 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 5889} 5890tls.on('message', callback); 5891// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5892tls.off('message', callback); 5893``` 5894### on('connect' | 'close')<sup>9+</sup> 5895 5896on(type: 'connect' | 'close', callback: Callback\<void\>): void 5897 5898订阅TLSSocket的连接事件或关闭事件。使用callback方式作为异步方法。 5899 5900**系统能力**：SystemCapability.Communication.NetStack 5901 5902**参数：** 5903 5904| 参数名 | 类型 | 必填 | 说明 | 5905| -------- | ---------------- | ---- | ------------------------------------------------------------ | 5906| type | string | 是 | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 | 5907| callback | Callback\<void\> | 是 | 回调函数。TLSSocket连接订阅某类事件触发的调用函数。 | 5908 5909**错误码：** 5910 5911| 错误码ID | 错误信息 | 5912| ------- | ------------------------------ | 5913| 401 | Parameter error. | 5914 5915**示例：** 5916 5917```ts 5918import { socket } from '@kit.NetworkKit'; 5919import { BusinessError } from '@kit.BasicServicesKit'; 5920 5921let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5922tls.on('connect', () => { 5923 console.log("on connect success") 5924}); 5925tls.on('close', () => { 5926 console.log("on close success") 5927}); 5928``` 5929 5930### off('connect' | 'close')<sup>9+</sup> 5931 5932off(type: 'connect' | 'close', callback?: Callback\<void\>): void 5933 5934取消订阅TLSSocket的连接事件或关闭事件。使用callback方式作为异步方法。 5935 5936**系统能力**：SystemCapability.Communication.NetStack 5937 5938**参数：** 5939 5940| 参数名 | 类型 | 必填 | 说明 | 5941| -------- | ---------------- | ---- | ------------------------------------------------------------ | 5942| type | string | 是 | 订阅的事件类型。<br />- 'connect'：连接事件。<br />- 'close'：关闭事件。 | 5943| callback | Callback\<void\> | 否 | 回调函数。TLSSocket连接订阅某类事件触发的调用函数。 | 5944 5945**错误码：** 5946 5947| 错误码ID | 错误信息 | 5948| ------- | ------------------------------ | 5949| 401 | Parameter error. | 5950 5951**示例：** 5952 5953```ts 5954import { socket } from '@kit.NetworkKit'; 5955import { BusinessError } from '@kit.BasicServicesKit'; 5956 5957let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 5958let callback1 = () => { 5959 console.log("on connect success"); 5960} 5961tls.on('connect', callback1); 5962// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5963tls.off('connect', callback1); 5964tls.off('connect'); 5965let callback2 = () => { 5966 console.log("on close success"); 5967} 5968tls.on('close', callback2); 5969// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 5970tls.off('close', callback2); 5971``` 5972 5973### on('error')<sup>9+</sup> 5974 5975on(type: 'error', callback: ErrorCallback): void 5976 5977订阅TLSSocket连接的error事件。使用callback方式作为异步方法。 5978 5979**系统能力**：SystemCapability.Communication.NetStack 5980 5981**参数：** 5982 5983| 参数名 | 类型 | 必填 | 说明 | 5984| -------- | ------------- | ---- | ------------------------------------ | 5985| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 5986| callback | ErrorCallback | 是 | 回调函数。TLSSocket连接订阅某类error事件触发的调用函数。 | 5987 5988**错误码：** 5989 5990| 错误码ID | 错误信息 | 5991| ------- | ------------------------------ | 5992| 401 | Parameter error. | 5993 5994**示例：** 5995 5996```ts 5997import { socket } from '@kit.NetworkKit'; 5998import { BusinessError } from '@kit.BasicServicesKit'; 5999 6000let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6001tls.on('error', (err: BusinessError) => { 6002 console.log("on error, err:" + JSON.stringify(err)) 6003}); 6004``` 6005 6006### off('error')<sup>9+</sup> 6007 6008off(type: 'error', callback?: ErrorCallback): void 6009 6010取消订阅TLSSocket连接的error事件。使用callback方式作为异步方法。 6011 6012**系统能力**：SystemCapability.Communication.NetStack 6013 6014**参数：** 6015 6016| 参数名 | 类型 | 必填 | 说明 | 6017| -------- | ------------- | ---- | ------------------------------------ | 6018| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 6019| callback | ErrorCallback | 否 | 回调函数。TLSSocket连接取消订阅某类error事件触发的调用函数。 | 6020 6021**错误码：** 6022 6023| 错误码ID | 错误信息 | 6024| ------- | ------------------------------ | 6025| 401 | Parameter error. | 6026 6027**示例：** 6028 6029```ts 6030import { socket } from '@kit.NetworkKit'; 6031import { BusinessError } from '@kit.BasicServicesKit'; 6032 6033let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6034let callback = (err: BusinessError) => { 6035 console.log("on error, err:" + JSON.stringify(err)); 6036} 6037tls.on('error', callback); 6038// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 6039tls.off('error', callback); 6040``` 6041 6042### connect<sup>9+</sup> 6043 6044connect(options: TLSConnectOptions, callback: AsyncCallback\<void\>): void 6045 6046在TLSSocket上bind成功之后，进行通信连接，并创建和初始化TLS会话，实现建立连接过程，启动与服务器的TLS/SSL握手，实现数据传输功能，使用callback方式作为异步方法。需要注意options入参下secureOptions内的ca为必填项，需填入服务端的ca证书(用于认证校验服务端的数字证书),证书内容以"-----BEGIN CERTIFICATE-----"开头，以"-----END CERTIFICATE-----"结尾。 6047 6048**系统能力**：SystemCapability.Communication.NetStack 6049 6050**参数：** 6051 6052| 参数名 | 类型 | 必填 | 说明 | 6053| -------- | ---------------------------------------| ----| --------------- | 6054| options | [TLSConnectOptions](#tlsconnectoptions9) | 是 | TLSSocket连接所需要的参数。| 6055| callback | AsyncCallback\<void\> | 是 | 回调函数，成功无返回，失败返回错误码、错误信息。| 6056 6057**错误码：** 6058 6059| 错误码ID | 错误信息 | 6060| ------- | -------------------------------------------- | 6061| 401 | Parameter error. | 6062| 2303104 | Interrupted system call. | 6063| 2303109 | Bad file number. | 6064| 2303111 | Resource temporarily unavailable. Try again. | 6065| 2303188 | Socket operation on non-socket. | 6066| 2303191 | Incorrect socket protocol type. | 6067| 2303198 | Address already in use. | 6068| 2303199 | Cannot assign requested address. | 6069| 2303210 | Connection timed out. | 6070| 2303501 | SSL is null. | 6071| 2303502 | An error occurred when reading data on the TLS socket.| 6072| 2303503 | An error occurred when writing data on the TLS socket.| 6073| 2303505 | An error occurred in the TLS system call. | 6074| 2303506 | Failed to close the TLS connection. | 6075| 2300002 | System internal error. | 6076 6077**示例：** 6078 6079```ts 6080import { socket } from '@kit.NetworkKit'; 6081import { BusinessError } from '@kit.BasicServicesKit'; 6082 6083let tlsTwoWay: socket.TLSSocket = socket.constructTLSSocketInstance(); // Two way authentication 6084let bindAddr: socket.NetAddress = { 6085 address: '0.0.0.0', 6086} 6087tlsTwoWay.bind(bindAddr, (err: BusinessError) => { 6088 if (err) { 6089 console.log('bind fail'); 6090 return; 6091 } 6092 console.log('bind success'); 6093}); 6094let twoWayNetAddr: socket.NetAddress = { 6095 address: '192.168.xx.xxx', 6096 port: 8080 6097} 6098let twoWaySecureOptions: socket.TLSSecureOptions = { 6099 key: "xxxx", 6100 cert: "xxxx", 6101 ca: ["xxxx"], 6102 password: "xxxx", 6103 protocols: socket.Protocol.TLSv12, 6104 useRemoteCipherPrefer: true, 6105 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6106 cipherSuite: "AES256-SHA256" 6107} 6108let tlsConnectOptions: socket.TLSConnectOptions = { 6109 address: twoWayNetAddr, 6110 secureOptions: twoWaySecureOptions, 6111 ALPNProtocols: ["spdy/1", "http/1.1"] 6112} 6113 6114tlsTwoWay.connect(tlsConnectOptions, (err: BusinessError) => { 6115 console.error("connect callback error" + err); 6116}); 6117 6118let tlsOneWay: socket.TLSSocket = socket.constructTLSSocketInstance(); // One way authentication 6119tlsOneWay.bind(bindAddr, (err: BusinessError) => { 6120 if (err) { 6121 console.log('bind fail'); 6122 return; 6123 } 6124 console.log('bind success'); 6125}); 6126let oneWayNetAddr: socket.NetAddress = { 6127 address: '192.168.xx.xxx', 6128 port: 8080 6129} 6130let oneWaySecureOptions: socket.TLSSecureOptions = { 6131 ca: ["xxxx", "xxxx"], 6132 cipherSuite: "AES256-SHA256" 6133} 6134let tlsOneWayConnectOptions: socket.TLSConnectOptions = { 6135 address: oneWayNetAddr, 6136 secureOptions: oneWaySecureOptions 6137} 6138tlsOneWay.connect(tlsOneWayConnectOptions, (err: BusinessError) => { 6139 console.error("connect callback error" + err); 6140}); 6141``` 6142 6143### connect<sup>9+</sup> 6144 6145connect(options: TLSConnectOptions): Promise\<void\> 6146 6147在TLSSocket上bind成功之后，进行通信连接，并创建和初始化TLS会话，实现建立连接过程，启动与服务器的TLS/SSL握手，实现数据传输功能，该连接包括两种认证方式，单向认证与双向认证，使用Promise方式作为异步方法。需要注意options入参下secureOptions内的ca为必填项，需填入服务端的ca证书(用于认证校验服务端的数字证书),证书内容以"-----BEGIN CERTIFICATE-----"开头，以"-----END CERTIFICATE-----"结尾。 6148 6149**系统能力**：SystemCapability.Communication.NetStack 6150 6151**参数：** 6152 6153| 参数名 | 类型 | 必填 | 说明 | 6154| -------- | --------------------------------------| ----| --------------- | 6155| options | [TLSConnectOptions](#tlsconnectoptions9) | 是 | 连接所需要的参数。| 6156 6157**返回值：** 6158 6159| 类型 | 说明 | 6160| ------------------------------------------- | ----------------------------- | 6161| Promise\<void\> | 以Promise形式返回，成功无返回，失败返回错误码，错误信息。| 6162 6163**错误码：** 6164 6165| 错误码ID | 错误信息 | 6166| ------- | -------------------------------------------- | 6167| 401 | Parameter error. | 6168| 2303104 | Interrupted system call. | 6169| 2303109 | Bad file number. | 6170| 2303111 | Resource temporarily unavailable. Try again. | 6171| 2303188 | Socket operation on non-socket. | 6172| 2303191 | Incorrect socket protocol type. | 6173| 2303198 | Address already in use. | 6174| 2303199 | Cannot assign requested address. | 6175| 2303210 | Connection timed out. | 6176| 2303501 | SSL is null. | 6177| 2303502 | An error occurred when reading data on the TLS socket.| 6178| 2303503 | An error occurred when writing data on the TLS socket.| 6179| 2303505 | An error occurred in the TLS system call. | 6180| 2303506 | Failed to close the TLS connection. | 6181| 2300002 | System internal error. | 6182 6183**示例：** 6184 6185```ts 6186import { socket } from '@kit.NetworkKit'; 6187import { BusinessError } from '@kit.BasicServicesKit'; 6188 6189let tlsTwoWay: socket.TLSSocket = socket.constructTLSSocketInstance(); // Two way authentication 6190let bindAddr: socket.NetAddress = { 6191 address: '0.0.0.0', 6192} 6193tlsTwoWay.bind(bindAddr, (err: BusinessError) => { 6194 if (err) { 6195 console.log('bind fail'); 6196 return; 6197 } 6198 console.log('bind success'); 6199}); 6200let twoWayNetAddr: socket.NetAddress = { 6201 address: '192.168.xx.xxx', 6202 port: 8080 6203} 6204let twoWaySecureOptions: socket.TLSSecureOptions = { 6205 key: "xxxx", 6206 cert: "xxxx", 6207 ca: ["xxxx"], 6208 password: "xxxx", 6209 protocols: socket.Protocol.TLSv12, 6210 useRemoteCipherPrefer: true, 6211 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 6212 cipherSuite: "AES256-SHA256" 6213} 6214let tlsConnectOptions: socket.TLSConnectOptions = { 6215 address: twoWayNetAddr, 6216 secureOptions: twoWaySecureOptions, 6217 ALPNProtocols: ["spdy/1", "http/1.1"] 6218} 6219 6220tlsTwoWay.connect(tlsConnectOptions).then(() => { 6221 console.log("connect successfully"); 6222}).catch((err: BusinessError) => { 6223 console.log("connect failed " + JSON.stringify(err)); 6224}); 6225 6226let tlsOneWay: socket.TLSSocket = socket.constructTLSSocketInstance(); // One way authentication 6227tlsOneWay.bind(bindAddr, (err: BusinessError) => { 6228 if (err) { 6229 console.log('bind fail'); 6230 return; 6231 } 6232 console.log('bind success'); 6233}); 6234let oneWayNetAddr: socket.NetAddress = { 6235 address: '192.168.xx.xxx', 6236 port: 8080 6237} 6238let oneWaySecureOptions: socket.TLSSecureOptions = { 6239 ca: ["xxxx", "xxxx"], 6240 cipherSuite: "AES256-SHA256" 6241} 6242let tlsOneWayConnectOptions: socket.TLSConnectOptions = { 6243 address: oneWayNetAddr, 6244 secureOptions: oneWaySecureOptions 6245} 6246tlsOneWay.connect(tlsOneWayConnectOptions).then(() => { 6247 console.log("connect successfully"); 6248}).catch((err: BusinessError) => { 6249 console.log("connect failed " + JSON.stringify(err)); 6250}); 6251``` 6252 6253### getRemoteAddress<sup>9+</sup> 6254 6255getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void 6256 6257在TLSSocket通信连接成功之后，获取对端Socket地址。使用callback方式作为异步方法。 6258 6259**系统能力**：SystemCapability.Communication.NetStack 6260 6261**参数：** 6262 6263| 参数名 | 类型 | 必填 | 说明 | 6264| -------- | ------------------------------------------------- | ---- | ---------- | 6265| callback | AsyncCallback\<[NetAddress](#netaddress)\> | 是 | 回调函数。成功返回对端的socket地址，失败返回错误码、错误信息。 | 6266 6267**错误码：** 6268 6269| 错误码ID | 错误信息 | 6270| ------- | ----------------------------- | 6271| 2303188 | Socket operation on non-socket.| 6272| 2300002 | System internal error. | 6273 6274**示例：** 6275 6276```ts 6277import { socket } from '@kit.NetworkKit'; 6278import { BusinessError } from '@kit.BasicServicesKit'; 6279 6280let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6281tls.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => { 6282 if (err) { 6283 console.log('getRemoteAddress fail'); 6284 return; 6285 } 6286 console.log('getRemoteAddress success:' + JSON.stringify(data)); 6287}); 6288``` 6289 6290### getRemoteAddress<sup>9+</sup> 6291 6292getRemoteAddress(): Promise\<NetAddress\> 6293 6294在TLSSocket通信连接成功之后，获取对端Socket地址。使用Promise方式作为异步方法。 6295 6296**系统能力**：SystemCapability.Communication.NetStack 6297 6298**返回值：** 6299 6300| 类型 | 说明 | 6301| ------------------------------------------ | ------------------------------------------ | 6302| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取对端socket地址的结果。失败返回错误码，错误信息。 | 6303 6304**错误码：** 6305 6306| 错误码ID | 错误信息 | 6307| ------- | ------------------------------ | 6308| 2303188 | Socket operation on non-socket.| 6309| 2300002 | System internal error. | 6310 6311**示例：** 6312 6313```ts 6314import { socket } from '@kit.NetworkKit'; 6315import { BusinessError } from '@kit.BasicServicesKit'; 6316 6317let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6318tls.getRemoteAddress().then(() => { 6319 console.log('getRemoteAddress success'); 6320}).catch((err: BusinessError) => { 6321 console.log('getRemoteAddress fail'); 6322}); 6323``` 6324 6325### getCertificate<sup>9+</sup> 6326 6327getCertificate(callback: AsyncCallback\<[X509CertRawData](#x509certrawdata9)\>): void 6328 6329在TLSSocket通信连接成功之后，获取本地的数字证书，该接口只适用于双向认证时，使用callback方式作为异步方法。 6330 6331**系统能力**：SystemCapability.Communication.NetStack 6332 6333**参数：** 6334 6335| 参数名 | 类型 | 必填 | 说明 | 6336| -------- | ----------------------------------------| ---- | ---------------| 6337| callback | AsyncCallback\<[X509CertRawData](#x509certrawdata9)\> | 是 | 回调函数，成功返回本地的证书，失败返回错误码、错误信息。| 6338 6339**错误码：** 6340 6341| 错误码ID | 错误信息 | 6342| ------- | ------------------------------ | 6343| 2303501 | SSL is null. | 6344| 2303504 | An error occurred when verifying the X.509 certificate.| 6345| 2300002 | System internal error. | 6346 6347**示例：** 6348 6349```ts 6350import { socket } from '@kit.NetworkKit'; 6351import { BusinessError } from '@kit.BasicServicesKit'; 6352 6353let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6354tls.getCertificate((err: BusinessError, data: socket.X509CertRawData) => { 6355 if (err) { 6356 console.log("getCertificate callback error = " + err); 6357 } else { 6358 console.log("getCertificate callback = " + data); 6359 } 6360}); 6361``` 6362 6363### getCertificate<sup>9+</sup> 6364 6365getCertificate():Promise\<[X509CertRawData](#x509certrawdata9)\> 6366 6367在TLSSocket通信连接之后，获取本地的数字证书，该接口只适用于双向认证时，使用Promise方式作为异步方法。 6368 6369**系统能力**：SystemCapability.Communication.NetStack 6370 6371**返回值：** 6372 6373| 类型 | 说明 | 6374| -------------- | -------------------- | 6375| Promise\<[X509CertRawData](#x509certrawdata9)\> | 以Promise形式返回本地的数字证书的结果。失败返回错误码，错误信息。 | 6376 6377**错误码：** 6378 6379| 错误码ID | 错误信息 | 6380| ------- | ------------------------------ | 6381| 2303501 | SSL is null. | 6382| 2303504 | An error occurred when verifying the X.509 certificate.| 6383| 2300002 | System internal error. | 6384 6385**示例：** 6386 6387```ts 6388import { socket } from '@kit.NetworkKit'; 6389import { BusinessError } from '@kit.BasicServicesKit'; 6390import { util } from '@kit.ArkTS'; 6391 6392let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6393tls.getCertificate().then((data: socket.X509CertRawData) => { 6394 const decoder = util.TextDecoder.create(); 6395 const str = decoder.decodeWithStream(data.data); 6396 console.log("getCertificate: " + str); 6397}).catch((err: BusinessError) => { 6398 console.error("failed" + err); 6399}); 6400``` 6401 6402### getRemoteCertificate<sup>9+</sup> 6403 6404getRemoteCertificate(callback: AsyncCallback\<[X509CertRawData](#x509certrawdata9)\>): void 6405 6406在TLSSocket通信连接成功之后，获取服务端的数字证书，使用callback方式作为异步方法。 6407 6408**系统能力**：SystemCapability.Communication.NetStack 6409 6410**参数：** 6411 6412| 参数名 | 类型 | 必填 | 说明 | 6413| -------- | ----------------------------------------| ---- | ---------------| 6414| callback | AsyncCallback\<[X509CertRawData](#x509certrawdata9)\> | 是 | 回调函数，返回服务端的证书。失败返回错误码、错误信息。 | 6415 6416**错误码：** 6417 6418| 错误码ID | 错误信息 | 6419| ------- | ------------------------------ | 6420| 2303501 | SSL is null. | 6421| 2300002 | System internal error. | 6422 6423**示例：** 6424 6425```ts 6426import { socket } from '@kit.NetworkKit'; 6427import { BusinessError } from '@kit.BasicServicesKit'; 6428import { util } from '@kit.ArkTS'; 6429 6430let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6431tls.getRemoteCertificate((err: BusinessError, data: socket.X509CertRawData) => { 6432 if (err) { 6433 console.log("getRemoteCertificate callback error = " + err); 6434 } else { 6435 const decoder = util.TextDecoder.create(); 6436 const str = decoder.decodeWithStream(data.data); 6437 console.log("getRemoteCertificate callback = " + str); 6438 } 6439}); 6440``` 6441 6442### getRemoteCertificate<sup>9+</sup> 6443 6444getRemoteCertificate():Promise\<[X509CertRawData](#x509certrawdata9)\> 6445 6446在TLSSocket通信连接成功之后，获取服务端的数字证书，使用Promise方式作为异步方法。 6447 6448**系统能力**：SystemCapability.Communication.NetStack 6449 6450**返回值：** 6451 6452| 类型 | 说明 | 6453| -------------- | -------------------- | 6454| Promise\<[X509CertRawData](#x509certrawdata9)\> | 以Promise形式返回服务端的数字证书的结果。失败返回错误码，错误信息。 | 6455 6456**错误码：** 6457 6458| 错误码ID | 错误信息 | 6459| ------- | ------------------------------ | 6460| 2303501 | SSL is null. | 6461| 2300002 | System internal error. | 6462 6463**示例：** 6464 6465```ts 6466import { socket } from '@kit.NetworkKit'; 6467import { BusinessError } from '@kit.BasicServicesKit'; 6468import { util } from '@kit.ArkTS'; 6469 6470let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6471tls.getRemoteCertificate().then((data: socket.X509CertRawData) => { 6472 const decoder = util.TextDecoder.create(); 6473 const str = decoder.decodeWithStream(data.data); 6474 console.log("getRemoteCertificate:" + str); 6475}).catch((err: BusinessError) => { 6476 console.error("failed" + err); 6477}); 6478``` 6479 6480### getProtocol<sup>9+</sup> 6481 6482getProtocol(callback: AsyncCallback\<string\>): void 6483 6484在TLSSocket通信连接成功之后，获取通信的协议版本，使用callback方式作为异步方法。 6485 6486**系统能力**：SystemCapability.Communication.NetStack 6487 6488**参数：** 6489 6490| 参数名 | 类型 | 必填 | 说明 | 6491| -------- | ----------------------------------------| ---- | ---------------| 6492| callback | AsyncCallback\<string\> | 是 | 回调函数，返回通信的协议。失败返回错误码、错误信息。| 6493 6494**错误码：** 6495 6496| 错误码ID | 错误信息 | 6497| ------- | ----------------------------- | 6498| 2303501 | SSL is null. | 6499| 2303505 | An error occurred in the TLS system call. | 6500| 2300002 | System internal error. | 6501 6502**示例：** 6503 6504```ts 6505import { socket } from '@kit.NetworkKit'; 6506import { BusinessError } from '@kit.BasicServicesKit'; 6507 6508let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6509tls.getProtocol((err: BusinessError, data: string) => { 6510 if (err) { 6511 console.log("getProtocol callback error = " + err); 6512 } else { 6513 console.log("getProtocol callback = " + data); 6514 } 6515}); 6516``` 6517 6518### getProtocol<sup>9+</sup> 6519 6520getProtocol():Promise\<string\> 6521 6522在TLSSocket通信连接成功之后，获取通信的协议版本，使用Promise方式作为异步方法。 6523 6524**系统能力**：SystemCapability.Communication.NetStack 6525 6526**返回值：** 6527 6528| 类型 | 说明 | 6529| -------------- | -------------------- | 6530| Promise\<string\> | 以Promise形式返回通信的协议。失败返回错误码，错误信息。 | 6531 6532**错误码：** 6533 6534| 错误码ID | 错误信息 | 6535| ------- | ------------------------------ | 6536| 2303501 | SSL is null. | 6537| 2303505 | An error occurred in the TLS system call. | 6538| 2300002 | System internal error. | 6539 6540**示例：** 6541 6542```ts 6543import { socket } from '@kit.NetworkKit'; 6544import { BusinessError } from '@kit.BasicServicesKit'; 6545 6546let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6547tls.getProtocol().then((data: string) => { 6548 console.log(data); 6549}).catch((err: BusinessError) => { 6550 console.error("failed" + err); 6551}); 6552``` 6553 6554### getCipherSuite<sup>9+</sup> 6555 6556getCipherSuite(callback: AsyncCallback\<Array\<string\>\>): void 6557 6558在TLSSocket通信连接成功之后，获取通信双方协商后的加密套件，使用callback方式作为异步方法。 6559 6560**系统能力**：SystemCapability.Communication.NetStack 6561 6562**参数：** 6563 6564| 参数名 | 类型 | 必填 | 说明 | 6565| -------- | ----------------------------------------| ---- | ---------------| 6566| callback | AsyncCallback\<Array\<string\>\> | 是 | 回调函数，返回通信双方支持的加密套件。失败返回错误码、错误信息。 | 6567 6568**错误码：** 6569 6570| 错误码ID | 错误信息 | 6571| ------- | ------------------------------ | 6572| 2303501 | SSL is null. | 6573| 2303502 | An error occurred when reading data on the TLS socket.| 6574| 2303505 | An error occurred in the TLS system call. | 6575| 2300002 | System internal error. | 6576 6577**示例：** 6578 6579```ts 6580import { socket } from '@kit.NetworkKit'; 6581import { BusinessError } from '@kit.BasicServicesKit'; 6582 6583let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6584tls.getCipherSuite((err: BusinessError, data: Array<string>) => { 6585 if (err) { 6586 console.log("getCipherSuite callback error = " + err); 6587 } else { 6588 console.log("getCipherSuite callback = " + data); 6589 } 6590}); 6591``` 6592 6593### getCipherSuite<sup>9+</sup> 6594 6595getCipherSuite(): Promise\<Array\<string\>\> 6596 6597在TLSSocket通信连接成功之后，获取通信双方协商后的加密套件，使用Promise方式作为异步方法。 6598 6599**系统能力**：SystemCapability.Communication.NetStack 6600 6601**返回值：** 6602 6603| 类型 | 说明 | 6604| ---------------------- | --------------------- | 6605| Promise\<Array\<string\>\> | 以Promise形式返回通信双方支持的加密套件。失败返回错误码，错误信息。 | 6606 6607**错误码：** 6608 6609| 错误码ID | 错误信息 | 6610| ------- | ------------------------------ | 6611| 2303501 | SSL is null. | 6612| 2303502 | An error occurred when reading data on the TLS socket.| 6613| 2303505 | An error occurred in the TLS system call. | 6614| 2300002 | System internal error. | 6615 6616**示例：** 6617 6618```ts 6619import { socket } from '@kit.NetworkKit'; 6620import { BusinessError } from '@kit.BasicServicesKit'; 6621 6622let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6623tls.getCipherSuite().then((data: Array<string>) => { 6624 console.log('getCipherSuite success:' + JSON.stringify(data)); 6625}).catch((err: BusinessError) => { 6626 console.error("failed" + err); 6627}); 6628``` 6629 6630### getSignatureAlgorithms<sup>9+</sup> 6631 6632getSignatureAlgorithms(callback: AsyncCallback\<Array\<string\>\>): void 6633 6634在TLSSocket通信连接成功之后，获取通信双方协商后签名算法，该接口只适配双向认证模式下，使用callback方式作为异步方法。 6635 6636**系统能力**：SystemCapability.Communication.NetStack 6637 6638**参数：** 6639 6640| 参数名 | 类型 | 必填 | 说明 | 6641| -------- | -------------------------------------| ---- | ---------------| 6642| callback | AsyncCallback\<Array\<string\>\> | 是 | 回调函数，返回双方支持的签名算法。 | 6643 6644**错误码：** 6645 6646| 错误码ID | 错误信息 | 6647| ------- | ------------------------------ | 6648| 2303501 | SSL is null. | 6649| 2300002 | System internal error. | 6650 6651**示例：** 6652 6653```ts 6654import { socket } from '@kit.NetworkKit'; 6655import { BusinessError } from '@kit.BasicServicesKit'; 6656 6657let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6658tls.getSignatureAlgorithms((err: BusinessError, data: Array<string>) => { 6659 if (err) { 6660 console.log("getSignatureAlgorithms callback error = " + err); 6661 } else { 6662 console.log("getSignatureAlgorithms callback = " + data); 6663 } 6664}); 6665``` 6666 6667### getSignatureAlgorithms<sup>9+</sup> 6668 6669getSignatureAlgorithms(): Promise\<Array\<string\>\> 6670 6671在TLSSocket通信连接成功之后，获取通信双方协商后的签名算法，该接口只适配双向认证模式下，使用Promise方式作为异步方法。 6672 6673**系统能力**：SystemCapability.Communication.NetStack 6674 6675**返回值：** 6676 6677| 类型 | 说明 | 6678| ---------------------- | -------------------- | 6679| Promise\<Array\<string\>\> | 以Promise形式返回获取到的双方支持的签名算法。 | 6680 6681**错误码：** 6682 6683| 错误码ID | 错误信息 | 6684| ------- | ------------------------------ | 6685| 2303501 | SSL is null. | 6686| 2300002 | System internal error. | 6687 6688**示例：** 6689 6690```ts 6691import { socket } from '@kit.NetworkKit'; 6692import { BusinessError } from '@kit.BasicServicesKit'; 6693 6694let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6695tls.getSignatureAlgorithms().then((data: Array<string>) => { 6696 console.log("getSignatureAlgorithms success" + data); 6697}).catch((err: BusinessError) => { 6698 console.error("failed" + err); 6699}); 6700``` 6701 6702### getLocalAddress<sup>12+</sup> 6703 6704getLocalAddress(): Promise\<NetAddress\> 6705 6706获取TLSSocket的本地Socket地址。使用Promise方式作为异步方法。 6707 6708> **说明：** 6709> 在TLSSocketServer通信连接成功之后，才可调用此方法。 6710 6711**系统能力**：SystemCapability.Communication.NetStack 6712 6713**返回值：** 6714 6715| 类型 | 说明 | 6716| -------------- | --------------------------------------------------- | 6717| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取本地socket地址的结果。 | 6718 6719**错误码：** 6720 6721| 错误码ID | 错误信息 | 6722| -------- | ------------------------------------------- | 6723| 2300002 | System internal error. | 6724| 2301009 | Bad file descriptor. | 6725| 2303188 | Socket operation on non-socket. | 6726 6727**示例：** 6728 6729```ts 6730import { socket } from '@kit.NetworkKit'; 6731import { BusinessError } from '@kit.BasicServicesKit'; 6732 6733let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6734tls.getLocalAddress().then((localAddress: socket.NetAddress) => { 6735 console.info("Get success: " + JSON.stringify(localAddress)); 6736}).catch((err: BusinessError) => { 6737 console.error("Get failed, error: " + JSON.stringify(err)); 6738}) 6739``` 6740 6741### send<sup>9+</sup> 6742 6743send(data: string \| ArrayBuffer, callback: AsyncCallback\<void\>): void 6744 6745在TLSSocket通信连接成功之后，向服务端发送消息，使用callback方式作为异步方法。 6746 6747**系统能力**：SystemCapability.Communication.NetStack 6748 6749**参数：** 6750 6751| 参数名 | 类型 | 必填 | 说明 | 6752| -------- | -----------------------------| ---- | ---------------| 6753| data | string \| ArrayBuffer | 是 | 发送的数据内容。 | 6754| callback | AsyncCallback\<void\> | 是 | 回调函数,返回TLSSocket发送数据的结果。失败返回错误码、错误信息。 | 6755 6756**错误码：** 6757 6758| 错误码ID | 错误信息 | 6759| ------- | -------------------------------------------- | 6760| 401 | Parameter error. | 6761| 2303501 | SSL is null. | 6762| 2303503 | An error occurred when writing data on the TLS socket.| 6763| 2303505 | An error occurred in the TLS system call. | 6764| 2303506 | Failed to close the TLS connection. | 6765| 2300002 | System internal error. | 6766 6767**示例：** 6768 6769```ts 6770import { socket } from '@kit.NetworkKit'; 6771import { BusinessError } from '@kit.BasicServicesKit'; 6772 6773let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6774tls.send("xxxx", (err: BusinessError) => { 6775 if (err) { 6776 console.log("send callback error = " + err); 6777 } else { 6778 console.log("send success"); 6779 } 6780}); 6781``` 6782 6783### send<sup>9+</sup> 6784 6785send(data: string \| ArrayBuffer): Promise\<void\> 6786 6787在TLSSocket通信连接成功之后，向服务端发送消息，使用Promise方式作为异步方法。 6788 6789**系统能力**：SystemCapability.Communication.NetStack 6790 6791**参数：** 6792 6793| 参数名 | 类型 | 必填 | 说明 | 6794| -------- | -----------------------------| ---- | ---------------| 6795| data | string \| ArrayBuffer | 是 | 发送的数据内容。 | 6796 6797**错误码：** 6798 6799| 错误码ID | 错误信息 | 6800| ------- | -------------------------------------------- | 6801| 401 | Parameter error. | 6802| 2303501 | SSL is null. | 6803| 2303503 | An error occurred when writing data on the TLS socket.| 6804| 2303505 | An error occurred in the TLS system call. | 6805| 2303506 | Failed to close the TLS connection. | 6806| 2300002 | System internal error. | 6807 6808**返回值：** 6809 6810| 类型 | 说明 | 6811| -------------- | -------------------- | 6812| Promise\<void\> | 以Promise形式返回,返回TLSSocket发送数据的结果。失败返回错误码，错误信息。 | 6813 6814**示例：** 6815 6816```ts 6817import { socket } from '@kit.NetworkKit'; 6818import { BusinessError } from '@kit.BasicServicesKit'; 6819 6820let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6821tls.send("xxxx").then(() => { 6822 console.log("send success"); 6823}).catch((err: BusinessError) => { 6824 console.error("failed" + err); 6825}); 6826``` 6827 6828### close<sup>9+</sup> 6829 6830close(callback: AsyncCallback\<void\>): void 6831 6832在TLSSocket通信连接成功之后，断开连接，使用callback方式作为异步方法。 6833 6834**系统能力**：SystemCapability.Communication.NetStack 6835 6836**参数：** 6837 6838| 参数名 | 类型 | 必填 | 说明 | 6839| -------- | -----------------------------| ---- | ---------------| 6840| callback | AsyncCallback\<void\> | 是 | 回调函数,成功返回TLSSocket关闭连接的结果。失败返回错误码、错误信息。 | 6841 6842**错误码：** 6843 6844| 错误码ID | 错误信息 | 6845| ------- | -------------------------------------------- | 6846| 401 | Parameter error. | 6847| 2303501 | SSL is null. | 6848| 2303505 | An error occurred in the TLS system call. | 6849| 2303506 | Failed to close the TLS connection. | 6850| 2300002 | System internal error. | 6851 6852**示例：** 6853 6854```ts 6855import { socket } from '@kit.NetworkKit'; 6856import { BusinessError } from '@kit.BasicServicesKit'; 6857 6858let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6859tls.close((err: BusinessError) => { 6860 if (err) { 6861 console.log("close callback error = " + err); 6862 } else { 6863 console.log("close success"); 6864 } 6865}); 6866``` 6867 6868### close<sup>9+</sup> 6869 6870close(): Promise\<void\> 6871 6872在TLSSocket通信连接成功之后，断开连接，使用Promise方式作为异步方法。 6873 6874**系统能力**：SystemCapability.Communication.NetStack 6875 6876**返回值：** 6877 6878| 类型 | 说明 | 6879| -------------- | -------------------- | 6880| Promise\<void\> | 以Promise形式返回,返回TLSSocket关闭连接的结果。失败返回错误码，错误信息。 | 6881 6882**错误码：** 6883 6884| 错误码ID | 错误信息 | 6885| ------- | -------------------------------------------- | 6886| 401 | Parameter error. | 6887| 2303501 | SSL is null. | 6888| 2303505 | An error occurred in the TLS system call. | 6889| 2303506 | Failed to close the TLS connection. | 6890| 2300002 | System internal error. | 6891 6892**示例：** 6893 6894```ts 6895import { socket } from '@kit.NetworkKit'; 6896import { BusinessError } from '@kit.BasicServicesKit'; 6897 6898let tls: socket.TLSSocket = socket.constructTLSSocketInstance(); 6899tls.close().then(() => { 6900 console.log("close success"); 6901}).catch((err: BusinessError) => { 6902 console.error("failed" + err); 6903}); 6904``` 6905 6906## TLSConnectOptions<sup>9+</sup> 6907 6908TLS连接的操作。 6909 6910**系统能力**：SystemCapability.Communication.NetStack 6911 6912| 名称 | 类型 | 必填 | 说明 | 6913| -------------- | ------------------------------------- | --- |-------------- | 6914| address | [NetAddress](#netaddress) | 是 | 网关地址。 | 6915| secureOptions | [TLSSecureOptions](#tlssecureoptions9) | 是 | TLS安全相关操作。| 6916| ALPNProtocols | Array\<string\> | 否 | ALPN协议，支持["spdy/1", "http/1.1"]，默认为[]。 | 6917| skipRemoteValidation<sup>12+</sup> | boolean | 否 | 是否对服务端进行证书认证，默认为false。 | 6918 6919## TLSSecureOptions<sup>9+</sup> 6920 6921TLS安全相关操作。当本地证书cert和私钥key不为空时，开启双向验证模式。cert和key其中一项为空时，开启单向验证模式。 6922 6923**系统能力**：SystemCapability.Communication.NetStack 6924 6925| 名称 | 类型 | 必填 | 说明 | 6926| --------------------- | ------------------------------------------------------ | --- |----------------------------------- | 6927| ca | string \| Array\<string\> | 否 | 服务端的ca证书，用于认证校验服务端的数字证书。默认为系统预置CA证书<sup>12+</sup>。 | 6928| cert | string | 否 | 本地客户端的数字证书。 | 6929| key | string | 否 | 本地数字证书的私钥。 | 6930| password | string | 否 | 读取私钥的密码。 | 6931| protocols | [Protocol](#protocol9) \|Array\<[Protocol](#protocol9)\> | 否 | TLS的协议版本，默认为"TLSv1.2"。 | 6932| useRemoteCipherPrefer | boolean | 否 | 优先使用对等方的密码套件。 | 6933| signatureAlgorithms | string | 否 | 通信过程中的签名算法，默认为"" 。 | 6934| cipherSuite | string | 否 | 通信过程中的加密套件，默认为"" 。 | 6935 6936## Protocol<sup>9+</sup> 6937 6938TLS通信的协议版本。 6939 6940**系统能力**：SystemCapability.Communication.NetStack 6941 6942| 名称 | 值 | 说明 | 6943| --------- | --------- |------------------ | 6944| TLSv12 | "TLSv1.2" | 使用TLSv1.2协议通信。 | 6945| TLSv13 | "TLSv1.3" | 使用TLSv1.3协议通信。 | 6946 6947## X509CertRawData<sup>9+</sup> 6948 6949存储证书的数据。 6950 6951**系统能力**：SystemCapability.Communication.NetStack 6952 6953## socket.constructTLSSocketServerInstance<sup>10+</sup> 6954 6955constructTLSSocketServerInstance(): TLSSocketServer 6956 6957创建并返回一个TLSSocketServer对象。 6958 6959**系统能力**：SystemCapability.Communication.NetStack 6960 6961**返回值:** 6962 6963| 类型 | 说明 | 6964| ------------------------------------ | ---------------------------- | 6965| [TLSSocketServer](#tlssocketserver10) | 返回一个TLSSocketServer对象。 | 6966 6967**示例：** 6968 6969```ts 6970import { socket } from '@kit.NetworkKit'; 6971import { BusinessError } from '@kit.BasicServicesKit'; 6972 6973let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 6974``` 6975 6976## TLSSocketServer<sup>10+</sup> 6977 6978TLSSocketServer连接。在调用TLSSocketServer的方法前，需要先通过[socket.constructTLSSocketServerInstance](#socketconstructtlssocketserverinstance10)创建TLSSocketServer对象。 6979 6980### listen<sup>10+</sup> 6981 6982listen(options: TLSConnectOptions, callback: AsyncCallback\<void\>): void 6983 6984绑定IP地址和端口，在TLSSocketServer上bind成功之后，监听客户端的连接，创建和初始化TLS会话，实现建立连接过程，加载证书秘钥并验证，使用callback方式作为异步方法。 6985 6986**注意：**IP地址设置为0.0.0.0时，可以监听本机所有地址。 6987 6988**需要权限**：ohos.permission.INTERNET 6989 6990**系统能力**：SystemCapability.Communication.NetStack 6991 6992**参数：** 6993 6994| 参数名 | 类型 | 必填 | 说明 | 6995| -------- | ---------------------------------------- | ---- | ------------------------------------------------ | 6996| options | [TLSConnectOptions](#tlsconnectoptions9) | 是 | TLSSocketServer连接所需要的参数。 | 6997| callback | AsyncCallback\<void\> | 是 | 回调函数，成功返回空，失败返回错误码、错误信息。 | 6998 6999**错误码：** 7000 7001| 错误码ID | 错误信息 | 7002| -------- | ------------------------------------------- | 7003| 401 | Parameter error. | 7004| 201 | Permission denied. | 7005| 2300002 | System internal error. | 7006| 2303109 | Bad file number. | 7007| 2303111 | Resource temporarily unavailable. Try again.| 7008| 2303198 | Address already in use. | 7009| 2303199 | Cannot assign requested address. | 7010| 2303501 | SSL is null. | 7011| 2303502 | An error occurred when reading data on the TLS socket.| 7012| 2303503 | An error occurred when writing data on the TLS socket.| 7013| 2303505 | An error occurred in the TLS system call. | 7014| 2303506 | Failed to close the TLS connection. | 7015 7016**示例：** 7017 7018```ts 7019import { socket } from '@kit.NetworkKit'; 7020import { BusinessError } from '@kit.BasicServicesKit'; 7021 7022let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7023let netAddress: socket.NetAddress = { 7024 address: '192.168.xx.xxx', 7025 port: 8080 7026} 7027let tlsSecureOptions: socket.TLSSecureOptions = { 7028 key: "xxxx", 7029 cert: "xxxx", 7030 ca: ["xxxx"], 7031 password: "xxxx", 7032 protocols: socket.Protocol.TLSv12, 7033 useRemoteCipherPrefer: true, 7034 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7035 cipherSuite: "AES256-SHA256" 7036} 7037let tlsConnectOptions: socket.TLSConnectOptions = { 7038 address: netAddress, 7039 secureOptions: tlsSecureOptions, 7040 ALPNProtocols: ["spdy/1", "http/1.1"], 7041 skipRemoteValidation: false 7042} 7043tlsServer.listen(tlsConnectOptions, (err: BusinessError) => { 7044 console.log("listen callback error" + err); 7045}); 7046``` 7047 7048### listen<sup>10+</sup> 7049 7050listen(options: TLSConnectOptions): Promise\<void\> 7051 7052绑定IP地址和端口，在TLSSocketServer上bind成功之后，监听客户端的连接，并创建和初始化TLS会话，实现建立连接过程，加载证书秘钥并验证，使用Promise方式作为异步方法。 7053 7054**需要权限**：ohos.permission.INTERNET 7055 7056**系统能力**：SystemCapability.Communication.NetStack 7057 7058**参数：** 7059 7060| 参数名 | 类型 | 必填 | 说明 | 7061| ------- | ---------------------------------------- | ---- | ------------------ | 7062| options | [TLSConnectOptions](#tlsconnectoptions9) | 是 | 连接所需要的参数。 | 7063 7064**返回值：** 7065 7066| 类型 | 说明 | 7067| --------------- | --------------------------------------------------------- | 7068| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码，错误信息。 | 7069 7070**错误码：** 7071 7072| 错误码ID | 错误信息 | 7073| -------- | ------------------------------------------- | 7074| 401 | Parameter error. | 7075| 201 | Permission denied. | 7076| 2300002 | System internal error. | 7077| 2303109 | Bad file number. | 7078| 2303111 | Resource temporarily unavailable. Try again.| 7079| 2303198 | Address already in use. | 7080| 2303199 | Cannot assign requested address. | 7081| 2303501 | SSL is null. | 7082| 2303502 | An error occurred when reading data on the TLS socket.| 7083| 2303503 | An error occurred when writing data on the TLS socket.| 7084| 2303505 | An error occurred in the TLS system call. | 7085| 2303506 | Failed to close the TLS connection. | 7086 7087**示例：** 7088 7089```ts 7090import { socket } from '@kit.NetworkKit'; 7091import { BusinessError } from '@kit.BasicServicesKit'; 7092 7093let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7094let netAddress: socket.NetAddress = { 7095 address: '192.168.xx.xxx', 7096 port: 8080 7097} 7098let tlsSecureOptions: socket.TLSSecureOptions = { 7099 key: "xxxx", 7100 cert: "xxxx", 7101 ca: ["xxxx"], 7102 password: "xxxx", 7103 protocols: socket.Protocol.TLSv12, 7104 useRemoteCipherPrefer: true, 7105 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7106 cipherSuite: "AES256-SHA256" 7107} 7108let tlsConnectOptions: socket.TLSConnectOptions = { 7109 address: netAddress, 7110 secureOptions: tlsSecureOptions, 7111 ALPNProtocols: ["spdy/1", "http/1.1"], 7112 skipRemoteValidation: false 7113} 7114tlsServer.listen(tlsConnectOptions).then(() => { 7115 console.log("listen callback success"); 7116}).catch((err: BusinessError) => { 7117 console.log("failed: " + JSON.stringify(err)); 7118}); 7119``` 7120 7121### getState<sup>10+</sup> 7122 7123getState(callback: AsyncCallback\<SocketStateBase\>): void 7124 7125在TLSSocketServer的listen成功之后，获取TLSSocketServer状态。使用callback方式作为异步方法。 7126 7127> **说明：** 7128> listen方法调用成功后，才可调用此方法。 7129 7130**系统能力**：SystemCapability.Communication.NetStack 7131 7132**参数：** 7133 7134| 参数名 | 类型 | 必填 | 说明 | 7135| -------- | ---------------------------------------------------- | ---- | ------------------------------------------------------------ | 7136| callback | AsyncCallback\<[SocketStateBase](#socketstatebase)\> | 是 | 回调函数。成功返回TLSSocketServer状态，失败返回错误码、错误信息。 | 7137 7138**错误码：** 7139 7140| 错误码ID | 错误信息 | 7141| -------- | ------------------------------- | 7142| 401 | Parameter error. | 7143| 2303188 | Socket operation on non-socket. | 7144| 2300002 | System internal error. | 7145 7146**示例：** 7147 7148```ts 7149import { socket } from '@kit.NetworkKit'; 7150import { BusinessError } from '@kit.BasicServicesKit'; 7151 7152let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7153let netAddress: socket.NetAddress = { 7154 address: '192.168.xx.xxx', 7155 port: 8080 7156} 7157let tlsSecureOptions: socket.TLSSecureOptions = { 7158 key: "xxxx", 7159 cert: "xxxx", 7160 ca: ["xxxx"], 7161 password: "xxxx", 7162 protocols: socket.Protocol.TLSv12, 7163 useRemoteCipherPrefer: true, 7164 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7165 cipherSuite: "AES256-SHA256" 7166} 7167let tlsConnectOptions: socket.TLSConnectOptions = { 7168 address: netAddress, 7169 secureOptions: tlsSecureOptions, 7170 ALPNProtocols: ["spdy/1", "http/1.1"] 7171} 7172tlsServer.listen(tlsConnectOptions).then(() => { 7173 console.log("listen callback success"); 7174}).catch((err: BusinessError) => { 7175 console.log("failed: " + JSON.stringify(err)); 7176}); 7177tlsServer.getState((err: BusinessError, data: socket.SocketStateBase) => { 7178 if (err) { 7179 console.log('getState fail'); 7180 return; 7181 } 7182 console.log('getState success:' + JSON.stringify(data)); 7183}); 7184``` 7185 7186### getState<sup>10+</sup> 7187 7188getState(): Promise\<SocketStateBase\> 7189 7190在TLSSocketServer的listen成功之后，获取TLSSocketServer状态。使用Promise方式作为异步方法。 7191 7192> **说明：** 7193> listen方法调用成功后，才可调用此方法。 7194 7195**系统能力**：SystemCapability.Communication.NetStack 7196 7197**返回值：** 7198 7199| 类型 | 说明 | 7200| --------------------------------------------- | ----------------------------------------------------------- | 7201| Promise\<[SocketStateBase](#socketstatebase)\> | 以Promise形式返回获取TLSSocketServer状态的结果。失败返回错误码，错误信息。 | 7202 7203**错误码：** 7204 7205| 错误码ID | 错误信息 | 7206| -------- | ------------------------------- | 7207| 2303188 | Socket operation on non-socket. | 7208| 2300002 | System internal error. | 7209 7210**示例：** 7211 7212```ts 7213import { socket } from '@kit.NetworkKit'; 7214import { BusinessError } from '@kit.BasicServicesKit'; 7215 7216let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7217let netAddress: socket.NetAddress = { 7218 address: '192.168.xx.xxx', 7219 port: 8080 7220} 7221let tlsSecureOptions: socket.TLSSecureOptions = { 7222 key: "xxxx", 7223 cert: "xxxx", 7224 ca: ["xxxx"], 7225 password: "xxxx", 7226 protocols: socket.Protocol.TLSv12, 7227 useRemoteCipherPrefer: true, 7228 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7229 cipherSuite: "AES256-SHA256" 7230} 7231let tlsConnectOptions: socket.TLSConnectOptions = { 7232 address: netAddress, 7233 secureOptions: tlsSecureOptions, 7234 ALPNProtocols: ["spdy/1", "http/1.1"] 7235} 7236tlsServer.listen(tlsConnectOptions).then(() => { 7237 console.log("listen callback success"); 7238}).catch((err: BusinessError) => { 7239 console.log("failed: " + JSON.stringify(err)); 7240}); 7241tlsServer.getState().then(() => { 7242 console.log('getState success'); 7243}).catch((err: BusinessError) => { 7244 console.log('getState fail'); 7245}); 7246``` 7247 7248### setExtraOptions<sup>10+</sup> 7249 7250setExtraOptions(options: TCPExtraOptions, callback: AsyncCallback\<void\>): void 7251 7252在TLSSocketServer的listen成功之后，设置TLSSocketServer连接的其他属性。使用callback方式作为异步方法。 7253 7254> **说明：** 7255> listen方法调用成功后，才可调用此方法。 7256 7257**系统能力**：SystemCapability.Communication.NetStack 7258 7259**参数：** 7260 7261| 参数名 | 类型 | 必填 | 说明 | 7262| -------- | ------------------------------------ | ---- | ------------------------------------------------ | 7263| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TLSSocketServer连接的其他属性。 | 7264| callback | AsyncCallback\<void\> | 是 | 回调函数。成功返回空，失败返回错误码、错误信息。 | 7265 7266**错误码：** 7267 7268| 错误码ID | 错误信息 | 7269| -------- | ------------------------------- | 7270| 401 | Parameter error. | 7271| 2303188 | Socket operation on non-socket. | 7272| 2300002 | System internal error. | 7273 7274**示例：** 7275 7276```ts 7277import { socket } from '@kit.NetworkKit'; 7278import { BusinessError } from '@kit.BasicServicesKit'; 7279 7280let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7281let netAddress: socket.NetAddress = { 7282 address: '192.168.xx.xxx', 7283 port: 8080 7284} 7285let tlsSecureOptions: socket.TLSSecureOptions = { 7286 key: "xxxx", 7287 cert: "xxxx", 7288 ca: ["xxxx"], 7289 password: "xxxx", 7290 protocols: socket.Protocol.TLSv12, 7291 useRemoteCipherPrefer: true, 7292 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7293 cipherSuite: "AES256-SHA256" 7294} 7295let tlsConnectOptions: socket.TLSConnectOptions = { 7296 address: netAddress, 7297 secureOptions: tlsSecureOptions, 7298 ALPNProtocols: ["spdy/1", "http/1.1"] 7299} 7300tlsServer.listen(tlsConnectOptions).then(() => { 7301 console.log("listen callback success"); 7302}).catch((err: BusinessError) => { 7303 console.log("failed: " + JSON.stringify(err)); 7304}); 7305 7306interface SocketLinger { 7307 on: boolean; 7308 linger: number; 7309} 7310 7311let tcpExtraOptions: socket.TCPExtraOptions = { 7312 keepAlive: true, 7313 OOBInline: true, 7314 TCPNoDelay: true, 7315 socketLinger: { on: true, linger: 10 } as SocketLinger, 7316 receiveBufferSize: 1000, 7317 sendBufferSize: 1000, 7318 reuseAddress: true, 7319 socketTimeout: 3000 7320} 7321tlsServer.setExtraOptions(tcpExtraOptions, (err: BusinessError) => { 7322 if (err) { 7323 console.log('setExtraOptions fail'); 7324 return; 7325 } 7326 console.log('setExtraOptions success'); 7327}); 7328``` 7329 7330### setExtraOptions<sup>10+</sup> 7331 7332setExtraOptions(options: TCPExtraOptions): Promise\<void\> 7333 7334在TLSSocketServer的listen成功之后，设置TLSSocketServer连接的其他属性，使用Promise方式作为异步方法。 7335 7336> **说明：** 7337> listen方法调用成功后，才可调用此方法。 7338 7339**系统能力**：SystemCapability.Communication.NetStack 7340 7341**参数：** 7342 7343| 参数名 | 类型 | 必填 | 说明 | 7344| ------- | ------------------------------------ | ---- | ------------------------------- | 7345| options | [TCPExtraOptions](#tcpextraoptions) | 是 | TLSSocketServer连接的其他属性。 | 7346 7347**返回值：** 7348 7349| 类型 | 说明 | 7350| -------------- | -------------------------------------------------------- | 7351| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码，错误信息。 | 7352 7353**错误码：** 7354 7355| 错误码ID | 错误信息 | 7356| -------- | ------------------------------- | 7357| 401 | Parameter error. | 7358| 2303188 | Socket operation on non-socket. | 7359| 2300002 | System internal error. | 7360 7361**示例：** 7362 7363```ts 7364import { socket } from '@kit.NetworkKit'; 7365import { BusinessError } from '@kit.BasicServicesKit'; 7366 7367let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7368let netAddress: socket.NetAddress = { 7369 address: '192.168.xx.xxx', 7370 port: 8080 7371} 7372let tlsSecureOptions: socket.TLSSecureOptions = { 7373 key: "xxxx", 7374 cert: "xxxx", 7375 ca: ["xxxx"], 7376 password: "xxxx", 7377 protocols: socket.Protocol.TLSv12, 7378 useRemoteCipherPrefer: true, 7379 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7380 cipherSuite: "AES256-SHA256" 7381} 7382let tlsConnectOptions: socket.TLSConnectOptions = { 7383 address: netAddress, 7384 secureOptions: tlsSecureOptions, 7385 ALPNProtocols: ["spdy/1", "http/1.1"] 7386} 7387tlsServer.listen(tlsConnectOptions).then(() => { 7388 console.log("listen callback success"); 7389}).catch((err: BusinessError) => { 7390 console.log("failed: " + JSON.stringify(err)); 7391}); 7392 7393interface SocketLinger { 7394 on: boolean; 7395 linger: number; 7396} 7397 7398let tcpExtraOptions: socket.TCPExtraOptions = { 7399 keepAlive: true, 7400 OOBInline: true, 7401 TCPNoDelay: true, 7402 socketLinger: { on: true, linger: 10 } as SocketLinger, 7403 receiveBufferSize: 1000, 7404 sendBufferSize: 1000, 7405 reuseAddress: true, 7406 socketTimeout: 3000 7407} 7408tlsServer.setExtraOptions(tcpExtraOptions).then(() => { 7409 console.log('setExtraOptions success'); 7410}).catch((err: BusinessError) => { 7411 console.log('setExtraOptions fail'); 7412}); 7413``` 7414 7415### getCertificate<sup>10+</sup> 7416 7417getCertificate(callback: AsyncCallback\<[X509CertRawData](#x509certrawdata9)\>): void 7418 7419在TLSSocketServer通信连接成功之后，获取本地的数字证书，使用callback方式作为异步方法。 7420 7421> **说明：** 7422> listen方法调用成功后，才可调用此方法。 7423 7424**系统能力**：SystemCapability.Communication.NetStack 7425 7426**参数：** 7427 7428| 参数名 | 类型 | 必填 | 说明 | 7429| -------- | ----------------------------------------------------- | ---- | -------------------------------------------------------- | 7430| callback | AsyncCallback\<[X509CertRawData](#x509certrawdata9)\> | 是 | 回调函数，成功返回本地的证书，失败返回错误码、错误信息。 | 7431 7432**错误码：** 7433 7434| 错误码ID | 错误信息 | 7435| -------- | ---------------------- | 7436| 401 | Parameter error. | 7437| 2303501 | SSL is null. | 7438| 2303504 | An error occurred when verifying the X.509 certificate. | 7439| 2300002 | System internal error. | 7440 7441**示例：** 7442 7443```ts 7444import { socket } from '@kit.NetworkKit'; 7445import { BusinessError } from '@kit.BasicServicesKit'; 7446import { util } from '@kit.ArkTS'; 7447 7448let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7449let netAddress: socket.NetAddress = { 7450 address: '192.168.xx.xxx', 7451 port: 8080 7452} 7453let tlsSecureOptions: socket.TLSSecureOptions = { 7454 key: "xxxx", 7455 cert: "xxxx", 7456 ca: ["xxxx"], 7457 password: "xxxx", 7458 protocols: socket.Protocol.TLSv12, 7459 useRemoteCipherPrefer: true, 7460 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7461 cipherSuite: "AES256-SHA256" 7462} 7463let tlsConnectOptions: socket.TLSConnectOptions = { 7464 address: netAddress, 7465 secureOptions: tlsSecureOptions, 7466 ALPNProtocols: ["spdy/1", "http/1.1"] 7467} 7468tlsServer.listen(tlsConnectOptions).then(() => { 7469 console.log("listen callback success"); 7470}).catch((err: BusinessError) => { 7471 console.log("failed: " + JSON.stringify(err)); 7472}); 7473tlsServer.getCertificate((err: BusinessError, data: socket.X509CertRawData) => { 7474 if (err) { 7475 console.log("getCertificate callback error = " + err); 7476 } else { 7477 const decoder = util.TextDecoder.create(); 7478 const str = decoder.decodeWithStream(data.data); 7479 console.log("getCertificate callback: " + str); 7480 } 7481}); 7482``` 7483 7484### getCertificate<sup>10+</sup> 7485 7486getCertificate():Promise\<[X509CertRawData](#x509certrawdata9)\> 7487 7488在TLSSocketServer通信连接之后，获取本地的数字证书，使用Promise方式作为异步方法。 7489 7490> **说明：** 7491> listen方法调用成功后，才可调用此方法。 7492 7493**系统能力**：SystemCapability.Communication.NetStack 7494 7495**返回值：** 7496 7497| 类型 | 说明 | 7498| ----------------------------------------------- | ------------------------------------------------------------ | 7499| Promise\<[X509CertRawData](#x509certrawdata9)\> | 以Promise形式返回本地的数字证书的结果。失败返回错误码，错误信息。 | 7500 7501**错误码：** 7502 7503| 错误码ID | 错误信息 | 7504| -------- | ---------------------- | 7505| 2303501 | SSL is null. | 7506| 2303504 | An error occurred when verifying the X.509 certificate. | 7507| 2300002 | System internal error. | 7508 7509**示例：** 7510 7511```ts 7512import { socket } from '@kit.NetworkKit'; 7513import { BusinessError } from '@kit.BasicServicesKit'; 7514import { util } from '@kit.ArkTS'; 7515 7516let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7517let netAddress: socket.NetAddress = { 7518 address: '192.168.xx.xxx', 7519 port: 8080 7520} 7521let tlsSecureOptions: socket.TLSSecureOptions = { 7522 key: "xxxx", 7523 cert: "xxxx", 7524 ca: ["xxxx"], 7525 password: "xxxx", 7526 protocols: socket.Protocol.TLSv12, 7527 useRemoteCipherPrefer: true, 7528 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7529 cipherSuite: "AES256-SHA256" 7530} 7531let tlsConnectOptions: socket.TLSConnectOptions = { 7532 address: netAddress, 7533 secureOptions: tlsSecureOptions, 7534 ALPNProtocols: ["spdy/1", "http/1.1"] 7535} 7536tlsServer.listen(tlsConnectOptions).then(() => { 7537 console.log("listen callback success"); 7538}).catch((err: BusinessError) => { 7539 console.log("failed: " + JSON.stringify(err)); 7540}); 7541tlsServer.getCertificate().then((data: socket.X509CertRawData) => { 7542 const decoder = util.TextDecoder.create(); 7543 const str = decoder.decodeWithStream(data.data); 7544 console.log("getCertificate: " + str); 7545}).catch((err: BusinessError) => { 7546 console.error("failed" + err); 7547}); 7548``` 7549 7550### getProtocol<sup>10+</sup> 7551 7552getProtocol(callback: AsyncCallback\<string\>): void 7553 7554在TLSSocketServer通信连接成功之后，获取通信的协议版本，使用callback方式作为异步方法。 7555 7556> **说明：** 7557> listen方法调用成功后，才可调用此方法。 7558 7559**系统能力**：SystemCapability.Communication.NetStack 7560 7561**参数：** 7562 7563| 参数名 | 类型 | 必填 | 说明 | 7564| -------- | ----------------------- | ---- | ---------------------------------------------------- | 7565| callback | AsyncCallback\<string\> | 是 | 回调函数，返回通信的协议。失败返回错误码、错误信息。 | 7566 7567**错误码：** 7568 7569| 错误码ID | 错误信息 | 7570| -------- | -------------------------------------- | 7571| 401 | Parameter error. | 7572| 2303501 | SSL is null. | 7573| 2303505 | An error occurred in the TLS system call. | 7574| 2300002 | System internal error. | 7575 7576**示例：** 7577 7578```ts 7579import { socket } from '@kit.NetworkKit'; 7580import { BusinessError } from '@kit.BasicServicesKit'; 7581 7582let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7583let netAddress: socket.NetAddress = { 7584 address: '192.168.xx.xxx', 7585 port: 8080 7586} 7587let tlsSecureOptions: socket.TLSSecureOptions = { 7588 key: "xxxx", 7589 cert: "xxxx", 7590 ca: ["xxxx"], 7591 password: "xxxx", 7592 protocols: socket.Protocol.TLSv12, 7593 useRemoteCipherPrefer: true, 7594 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7595 cipherSuite: "AES256-SHA256" 7596} 7597let tlsConnectOptions: socket.TLSConnectOptions = { 7598 address: netAddress, 7599 secureOptions: tlsSecureOptions, 7600 ALPNProtocols: ["spdy/1", "http/1.1"] 7601} 7602tlsServer.listen(tlsConnectOptions).then(() => { 7603 console.log("listen callback success"); 7604}).catch((err: BusinessError) => { 7605 console.log("failed: " + JSON.stringify(err)); 7606}); 7607tlsServer.getProtocol((err: BusinessError, data: string) => { 7608 if (err) { 7609 console.log("getProtocol callback error = " + err); 7610 } else { 7611 console.log("getProtocol callback = " + data); 7612 } 7613}); 7614``` 7615 7616### getProtocol<sup>10+</sup> 7617 7618getProtocol():Promise\<string\> 7619 7620在TLSSocketServer通信连接成功之后，获取通信的协议版本，使用Promise方式作为异步方法。 7621 7622> **说明：** 7623> listen方法调用成功后，才可调用此方法。 7624 7625**系统能力**：SystemCapability.Communication.NetStack 7626 7627**返回值：** 7628 7629| 类型 | 说明 | 7630| ----------------- | ------------------------------------------------------- | 7631| Promise\<string\> | 以Promise形式返回通信的协议。失败返回错误码，错误信息。 | 7632 7633**错误码：** 7634 7635| 错误码ID | 错误信息 | 7636| -------- | -------------------------------------- | 7637| 2303501 | SSL is null. | 7638| 2303505 | An error occurred in the TLS system call. | 7639| 2300002 | System internal error. | 7640 7641**示例：** 7642 7643```ts 7644import { socket } from '@kit.NetworkKit'; 7645import { BusinessError } from '@kit.BasicServicesKit'; 7646 7647let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7648let netAddress: socket.NetAddress = { 7649 address: '192.168.xx.xxx', 7650 port: 8080 7651} 7652let tlsSecureOptions: socket.TLSSecureOptions = { 7653 key: "xxxx", 7654 cert: "xxxx", 7655 ca: ["xxxx"], 7656 password: "xxxx", 7657 protocols: socket.Protocol.TLSv12, 7658 useRemoteCipherPrefer: true, 7659 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7660 cipherSuite: "AES256-SHA256" 7661} 7662let tlsConnectOptions: socket.TLSConnectOptions = { 7663 address: netAddress, 7664 secureOptions: tlsSecureOptions, 7665 ALPNProtocols: ["spdy/1", "http/1.1"] 7666} 7667tlsServer.listen(tlsConnectOptions).then(() => { 7668 console.log("listen callback success"); 7669}).catch((err: BusinessError) => { 7670 console.log("failed: " + JSON.stringify(err)); 7671}); 7672tlsServer.getProtocol().then((data: string) => { 7673 console.log(data); 7674}).catch((err: BusinessError) => { 7675 console.error("failed" + err); 7676}); 7677``` 7678 7679### getLocalAddress<sup>12+</sup> 7680 7681getLocalAddress(): Promise\<NetAddress\> 7682 7683获取TLSSocketServer的本地Socket地址。使用Promise方式作为异步方法。 7684 7685> **说明：** 7686> 在TLSSocketServer通信连接成功之后，才可调用此方法。 7687 7688**系统能力**：SystemCapability.Communication.NetStack 7689 7690**返回值：** 7691 7692| 类型 | 说明 | 7693| -------------- | --------------------------------------------------- | 7694| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取本地socket地址的结果。 | 7695 7696**错误码：** 7697 7698| 错误码ID | 错误信息 | 7699| -------- | ------------------------------------------- | 7700| 2300002 | System internal error. | 7701| 2301009 | Bad file descriptor. | 7702| 2303188 | Socket operation on non-socket. | 7703 7704**示例：** 7705 7706```ts 7707import { socket } from '@kit.NetworkKit'; 7708import { BusinessError } from '@kit.BasicServicesKit'; 7709 7710let tlsServer: socket.TLSSocket = socket.constructTLSSocketServerInstance(); 7711tlsServer.getLocalAddress().then((localAddress: socket.NetAddress) => { 7712 console.info("Get success: " + JSON.stringify(localAddress)); 7713}).catch((err: BusinessError) => { 7714 console.error("Get failed, error: " + JSON.stringify(err)); 7715}) 7716``` 7717 7718### on('connect')<sup>10+</sup> 7719 7720on(type: 'connect', callback: Callback\<TLSSocketConnection\>): void 7721 7722订阅TLSSocketServer的连接事件。使用callback方式作为异步方法。 7723 7724> **说明：** 7725> listen方法调用成功后，才可调用此方法。 7726 7727**系统能力**：SystemCapability.Communication.NetStack 7728 7729**参数：** 7730 7731| 参数名 | 类型 | 必填 | 说明 | 7732| -------- | ------------------------------------------------------- | ---- | ------------------------------------- | 7733| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 7734| callback | Callback\<[TLSSocketConnection](#tlssocketconnection10)\> | 是 | 回调函数。失败时返回错误码、错误信息。 | 7735 7736**错误码：** 7737 7738| 错误码ID | 错误信息 | 7739| -------- | ---------------- | 7740| 401 | Parameter error. | 7741 7742**示例：** 7743 7744```ts 7745import { socket } from '@kit.NetworkKit'; 7746import { BusinessError } from '@kit.BasicServicesKit'; 7747 7748let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7749let netAddress: socket.NetAddress = { 7750 address: '192.168.xx.xxx', 7751 port: 8080 7752} 7753let tlsSecureOptions: socket.TLSSecureOptions = { 7754 key: "xxxx", 7755 cert: "xxxx", 7756 ca: ["xxxx"], 7757 password: "xxxx", 7758 protocols: socket.Protocol.TLSv12, 7759 useRemoteCipherPrefer: true, 7760 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7761 cipherSuite: "AES256-SHA256" 7762} 7763let tlsConnectOptions: socket.TLSConnectOptions = { 7764 address: netAddress, 7765 secureOptions: tlsSecureOptions, 7766 ALPNProtocols: ["spdy/1", "http/1.1"] 7767} 7768tlsServer.listen(tlsConnectOptions).then(() => { 7769 console.log("listen callback success"); 7770}).catch((err: BusinessError) => { 7771 console.log("failed: " + JSON.stringify(err)); 7772}); 7773tlsServer.on('connect', (data: socket.TLSSocketConnection) => { 7774 console.log(JSON.stringify(data)) 7775}); 7776``` 7777 7778### off('connect')<sup>10+</sup> 7779 7780off(type: 'connect', callback?: Callback\<TLSSocketConnection\>): void 7781 7782取消订阅TLSSocketServer的连接事件。使用callback方式作为异步方法。 7783 7784> **说明：** 7785> listen方法调用成功后，才可调用此方法。 7786> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 7787 7788**系统能力**：SystemCapability.Communication.NetStack 7789 7790**参数：** 7791 7792| 参数名 | 类型 | 必填 | 说明 | 7793| -------- | ------------------------------------------------------- | ---- | ------------------------------------- | 7794| type | string | 是 | 订阅的事件类型。'connect'：连接事件。 | 7795| callback | Callback\<[TLSSocketConnection](#tlssocketconnection10)\> | 否 | 回调函数。失败时返回错误码、错误信息。 | 7796 7797**错误码：** 7798 7799| 错误码ID | 错误信息 | 7800| -------- | ---------------- | 7801| 401 | Parameter error. | 7802 7803**示例：** 7804 7805```ts 7806import { socket } from '@kit.NetworkKit'; 7807import { BusinessError } from '@kit.BasicServicesKit'; 7808 7809let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7810let netAddress: socket.NetAddress = { 7811 address: '192.168.xx.xxx', 7812 port: 8080 7813} 7814let tlsSecureOptions: socket.TLSSecureOptions = { 7815 key: "xxxx", 7816 cert: "xxxx", 7817 ca: ["xxxx"], 7818 password: "xxxx", 7819 protocols: socket.Protocol.TLSv12, 7820 useRemoteCipherPrefer: true, 7821 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7822 cipherSuite: "AES256-SHA256" 7823} 7824let tlsConnectOptions: socket.TLSConnectOptions = { 7825 address: netAddress, 7826 secureOptions: tlsSecureOptions, 7827 ALPNProtocols: ["spdy/1", "http/1.1"] 7828} 7829tlsServer.listen(tlsConnectOptions).then(() => { 7830 console.log("listen callback success"); 7831}).catch((err: BusinessError) => { 7832 console.log("failed: " + JSON.stringify(err)); 7833}); 7834 7835let callback = (data: socket.TLSSocketConnection) => { 7836 console.log('on connect message: ' + JSON.stringify(data)); 7837} 7838tlsServer.on('connect', callback); 7839// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 7840tlsServer.off('connect', callback); 7841tlsServer.off('connect'); 7842``` 7843 7844### on('error')<sup>10+</sup> 7845 7846on(type: 'error', callback: ErrorCallback): void 7847 7848订阅TLSSocketServer连接的error事件。使用callback方式作为异步方法。 7849 7850> **说明：** 7851> listen方法调用成功后，才可调用此方法。 7852 7853**系统能力**：SystemCapability.Communication.NetStack 7854 7855**参数：** 7856 7857| 参数名 | 类型 | 必填 | 说明 | 7858| -------- | ------------- | ---- | ------------------------------------ | 7859| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 7860| callback | ErrorCallback | 是 | 回调函数。失败时返回错误码、错误信息。 | 7861 7862**错误码：** 7863 7864| 错误码ID | 错误信息 | 7865| -------- | ---------------- | 7866| 401 | Parameter error. | 7867 7868**示例：** 7869 7870```ts 7871import { socket } from '@kit.NetworkKit'; 7872import { BusinessError } from '@kit.BasicServicesKit'; 7873 7874let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7875let netAddress: socket.NetAddress = { 7876 address: '192.168.xx.xxx', 7877 port: 8080 7878} 7879let tlsSecureOptions: socket.TLSSecureOptions = { 7880 key: "xxxx", 7881 cert: "xxxx", 7882 ca: ["xxxx"], 7883 password: "xxxx", 7884 protocols: socket.Protocol.TLSv12, 7885 useRemoteCipherPrefer: true, 7886 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7887 cipherSuite: "AES256-SHA256" 7888} 7889let tlsConnectOptions: socket.TLSConnectOptions = { 7890 address: netAddress, 7891 secureOptions: tlsSecureOptions, 7892 ALPNProtocols: ["spdy/1", "http/1.1"] 7893} 7894tlsServer.listen(tlsConnectOptions).then(() => { 7895 console.log("listen callback success"); 7896}).catch((err: BusinessError) => { 7897 console.log("failed: " + JSON.stringify(err)); 7898}); 7899tlsServer.on('error', (err: BusinessError) => { 7900 console.log("on error, err:" + JSON.stringify(err)) 7901}); 7902``` 7903 7904### off('error')<sup>10+</sup> 7905 7906off(type: 'error', callback?: ErrorCallback): void 7907 7908取消订阅TLSSocketServer连接的error事件。使用callback方式作为异步方法。 7909 7910> **说明：** 7911> listen方法调用成功后，才可调用此方法。 7912> 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 7913 7914**系统能力**：SystemCapability.Communication.NetStack 7915 7916**参数：** 7917 7918| 参数名 | 类型 | 必填 | 说明 | 7919| -------- | ------------- | ---- | ------------------------------------ | 7920| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 7921| callback | ErrorCallback | 否 | 回调函数。失败时返回错误码、错误信息。 | 7922 7923**错误码：** 7924 7925| 错误码ID | 错误信息 | 7926| -------- | ---------------- | 7927| 401 | Parameter error. | 7928 7929**示例：** 7930 7931```ts 7932import { socket } from '@kit.NetworkKit'; 7933import { BusinessError } from '@kit.BasicServicesKit'; 7934 7935let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 7936let netAddress: socket.NetAddress = { 7937 address: '192.168.xx.xxx', 7938 port: 8080 7939} 7940let tlsSecureOptions: socket.TLSSecureOptions = { 7941 key: "xxxx", 7942 cert: "xxxx", 7943 ca: ["xxxx"], 7944 password: "xxxx", 7945 protocols: socket.Protocol.TLSv12, 7946 useRemoteCipherPrefer: true, 7947 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 7948 cipherSuite: "AES256-SHA256" 7949} 7950let tlsConnectOptions: socket.TLSConnectOptions = { 7951 address: netAddress, 7952 secureOptions: tlsSecureOptions, 7953 ALPNProtocols: ["spdy/1", "http/1.1"] 7954} 7955tlsServer.listen(tlsConnectOptions).then(() => { 7956 console.log("listen callback success"); 7957}).catch((err: BusinessError) => { 7958 console.log("failed: " + JSON.stringify(err)); 7959}); 7960 7961let callback = (err: BusinessError) => { 7962 console.log("on error, err:" + JSON.stringify(err)); 7963} 7964tlsServer.on('error', callback); 7965// 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 7966tlsServer.off('error', callback); 7967tlsServer.off('error'); 7968``` 7969 7970## TLSSocketConnection<sup>10+</sup> 7971 7972TLSSocketConnection连接，即TLSSocket客户端与服务端的连接。在调用TLSSocketConnection的方法前，需要先获取TLSSocketConnection对象。 7973 7974> **说明：** 7975> 客户端与服务端成功建立连接后，才能通过返回的TLSSocketConnection对象调用相应的接口。 7976 7977**系统能力**：SystemCapability.Communication.NetStack 7978 7979### 属性 7980 7981| 名称 | 类型 | 必填 | 说明 | 7982| -------- | ------ | ---- | ------------------------------------- | 7983| clientId | number | 是 | 客户端与TLSSocketServer建立连接的id。 | 7984 7985### send<sup>10+</sup> 7986 7987send(data: string \| ArrayBuffer, callback: AsyncCallback\<void\>): void 7988 7989在TLSSocketServer通信连接成功之后，向客户端发送消息，使用callback方式作为异步方法。 7990 7991**系统能力**：SystemCapability.Communication.NetStack 7992 7993**参数：** 7994 7995| 参数名 | 类型 | 必填 | 说明 | 7996| -------- | --------------------- | ---- | ------------------------------------------------ | 7997| data | string \| ArrayBuffer | 是 | TLSSocketServer发送数据所需要的参数。 | 7998| callback | AsyncCallback\<void\> | 是 | 回调函数，成功返回空，失败返回错误码、错误信息。 | 7999 8000**错误码：** 8001 8002| 错误码ID | 错误信息 | 8003| -------- | -------------------------------------- | 8004| 401 | Parameter error. | 8005| 2303501 | SSL is null. | 8006| 2303503 | An error occurred when writing data on the TLS socket.| 8007| 2303505 | An error occurred in the TLS system call.| 8008| 2303506 | Failed to close the TLS connection. | 8009| 2300002 | System internal error. | 8010 8011**示例：** 8012 8013```ts 8014import { socket } from '@kit.NetworkKit'; 8015import { BusinessError } from '@kit.BasicServicesKit'; 8016 8017let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8018let netAddress: socket.NetAddress = { 8019 address: '192.168.xx.xxx', 8020 port: 8080 8021} 8022let tlsSecureOptions: socket.TLSSecureOptions = { 8023 key: "xxxx", 8024 cert: "xxxx", 8025 ca: ["xxxx"], 8026 password: "xxxx", 8027 protocols: socket.Protocol.TLSv12, 8028 useRemoteCipherPrefer: true, 8029 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8030 cipherSuite: "AES256-SHA256" 8031} 8032let tlsConnectOptions: socket.TLSConnectOptions = { 8033 address: netAddress, 8034 secureOptions: tlsSecureOptions, 8035 ALPNProtocols: ["spdy/1", "http/1.1"] 8036} 8037tlsServer.listen(tlsConnectOptions).then(() => { 8038 console.log("listen callback success"); 8039}).catch((err: BusinessError) => { 8040 console.log("failed" + err); 8041}); 8042 8043tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8044 client.send('Hello, client!', (err: BusinessError) => { 8045 if (err) { 8046 console.log('send fail'); 8047 return; 8048 } 8049 console.log('send success'); 8050 }); 8051}); 8052``` 8053 8054### send<sup>10+</sup> 8055 8056send(data: string \| ArrayBuffer): Promise\<void\> 8057 8058在TLSSocketServer通信连接成功之后，向服务端发送消息，使用Promise方式作为异步方法。 8059 8060**系统能力**：SystemCapability.Communication.NetStack 8061 8062**参数：** 8063 8064| 参数名 | 类型 | 必填 | 说明 | 8065| ------ | ------ | ---- | ------------------------------------- | 8066| data | string \| ArrayBuffer | 是 | TLSSocketServer发送数据所需要的参数。 | 8067 8068**返回值：** 8069 8070| 类型 | 说明 | 8071| --------------- | --------------------------------------------------------- | 8072| Promise\<void\> | 以Promise形式返回，成功返回空，失败返回错误码，错误信息。 | 8073 8074**错误码：** 8075 8076| 错误码ID | 错误信息 | 8077| -------- | -------------------------------------- | 8078| 401 | Parameter error. | 8079| 2303501 | SSL is null. | 8080| 2303503 | An error occurred when writing data on the TLS socket.| 8081| 2303505 | An error occurred in the TLS system call.| 8082| 2303506 | Failed to close the TLS connection. | 8083| 2300002 | System internal error. | 8084 8085**示例：** 8086 8087```ts 8088import { socket } from '@kit.NetworkKit'; 8089import { BusinessError } from '@kit.BasicServicesKit'; 8090 8091let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8092let netAddress: socket.NetAddress = { 8093 address: '192.168.xx.xxx', 8094 port: 8080 8095} 8096let tlsSecureOptions: socket.TLSSecureOptions = { 8097 key: "xxxx", 8098 cert: "xxxx", 8099 ca: ["xxxx"], 8100 password: "xxxx", 8101 protocols: socket.Protocol.TLSv12, 8102 useRemoteCipherPrefer: true, 8103 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8104 cipherSuite: "AES256-SHA256" 8105} 8106let tlsConnectOptions: socket.TLSConnectOptions = { 8107 address: netAddress, 8108 secureOptions: tlsSecureOptions, 8109 ALPNProtocols: ["spdy/1", "http/1.1"] 8110} 8111tlsServer.listen(tlsConnectOptions).then(() => { 8112 console.log("listen callback success"); 8113}).catch((err: BusinessError) => { 8114 console.log("failed" + err); 8115}); 8116 8117tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8118 client.send('Hello, client!').then(() => { 8119 console.log('send success'); 8120 }).catch((err: BusinessError) => { 8121 console.log('send fail'); 8122 }); 8123}); 8124``` 8125 8126### close<sup>10+</sup> 8127 8128close(callback: AsyncCallback\<void\>): void 8129 8130在与TLSSocketServer通信连接成功之后，断开连接，使用callback方式作为异步方法。 8131 8132**系统能力**：SystemCapability.Communication.NetStack 8133 8134**参数：** 8135 8136| 参数名 | 类型 | 必填 | 说明 | 8137| -------- | --------------------- | ---- | ------------------------------------------------ | 8138| callback | AsyncCallback\<void\> | 是 | 回调函数，成功返回空，失败返回错误码、错误信息。 | 8139 8140**错误码：** 8141 8142| 错误码ID | 错误信息 | 8143| -------- | -------------------------------------- | 8144| 401 | Parameter error. | 8145| 2303501 | SSL is null. | 8146| 2303505 | An error occurred in the TLS system call. | 8147| 2303506 | Failed to close the TLS connection. | 8148| 2300002 | System internal error. | 8149 8150**示例：** 8151 8152```ts 8153import { socket } from '@kit.NetworkKit'; 8154import { BusinessError } from '@kit.BasicServicesKit'; 8155 8156let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8157let netAddress: socket.NetAddress = { 8158 address: '192.168.xx.xxx', 8159 port: 8080 8160} 8161let tlsSecureOptions: socket.TLSSecureOptions = { 8162 key: "xxxx", 8163 cert: "xxxx", 8164 ca: ["xxxx"], 8165 password: "xxxx", 8166 protocols: socket.Protocol.TLSv12, 8167 useRemoteCipherPrefer: true, 8168 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8169 cipherSuite: "AES256-SHA256" 8170} 8171let tlsConnectOptions: socket.TLSConnectOptions = { 8172 address: netAddress, 8173 secureOptions: tlsSecureOptions, 8174 ALPNProtocols: ["spdy/1", "http/1.1"] 8175} 8176tlsServer.listen(tlsConnectOptions).then(() => { 8177 console.log("listen callback success"); 8178}).catch((err: BusinessError) => { 8179 console.log("failed" + err); 8180}); 8181 8182tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8183 client.close((err: BusinessError) => { 8184 if (err) { 8185 console.log('close fail'); 8186 return; 8187 } 8188 console.log('close success'); 8189 }); 8190}); 8191``` 8192 8193### close<sup>10+</sup> 8194 8195close(): Promise\<void\> 8196 8197在与TLSSocketServer通信连接成功之后，断开连接，使用Promise方式作为异步方法。 8198 8199**系统能力**：SystemCapability.Communication.NetStack 8200 8201**返回值：** 8202 8203| 类型 | 说明 | 8204| --------------- | --------------------------------------------------------- | 8205| Promise\<void\> | 以Promise形式返回，成功返回空。失败返回错误码，错误信息。 | 8206 8207**错误码：** 8208 8209| 错误码ID | 错误信息 | 8210| -------- | -------------------------------------- | 8211| 2303501 | SSL is null. | 8212| 2303505 | An error occurred in the TLS system call. | 8213| 2303506 | Failed to close the TLS connection. | 8214| 2300002 | System internal error. | 8215 8216**示例：** 8217 8218```ts 8219import { socket } from '@kit.NetworkKit'; 8220import { BusinessError } from '@kit.BasicServicesKit'; 8221 8222let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8223let netAddress: socket.NetAddress = { 8224 address: '192.168.xx.xxx', 8225 port: 8080 8226} 8227let tlsSecureOptions: socket.TLSSecureOptions = { 8228 key: "xxxx", 8229 cert: "xxxx", 8230 ca: ["xxxx"], 8231 password: "xxxx", 8232 protocols: socket.Protocol.TLSv12, 8233 useRemoteCipherPrefer: true, 8234 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8235 cipherSuite: "AES256-SHA256" 8236} 8237let tlsConnectOptions: socket.TLSConnectOptions = { 8238 address: netAddress, 8239 secureOptions: tlsSecureOptions, 8240 ALPNProtocols: ["spdy/1", "http/1.1"] 8241} 8242tlsServer.listen(tlsConnectOptions).then(() => { 8243 console.log("listen callback success"); 8244}).catch((err: BusinessError) => { 8245 console.log("failed" + err); 8246}); 8247tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8248 client.close().then(() => { 8249 console.log('close success'); 8250 }).catch((err: BusinessError) => { 8251 console.log('close fail'); 8252 }); 8253}); 8254``` 8255 8256### getRemoteAddress<sup>10+</sup> 8257 8258getRemoteAddress(callback: AsyncCallback\<NetAddress\>): void 8259 8260在TLSSocketServer通信连接成功之后，获取对端Socket地址。使用callback方式作为异步方法。 8261 8262**系统能力**：SystemCapability.Communication.NetStack 8263 8264**参数：** 8265 8266| 参数名 | 类型 | 必填 | 说明 | 8267| -------- | ------------------------------------------- | ---- | ------------------------------------------------------------ | 8268| callback | AsyncCallback\<[NetAddress](#netaddress)\> | 是 | 回调函数。成功返回对端的socket地址，失败返回错误码、错误信息。 | 8269 8270**错误码：** 8271 8272| 错误码ID | 错误信息 | 8273| -------- | ------------------------------- | 8274| 401 | Parameter error. | 8275| 2303188 | Socket operation on non-socket. | 8276| 2300002 | System internal error. | 8277 8278**示例：** 8279 8280```ts 8281import { socket } from '@kit.NetworkKit'; 8282import { BusinessError } from '@kit.BasicServicesKit'; 8283 8284let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8285let netAddress: socket.NetAddress = { 8286 address: '192.168.xx.xxx', 8287 port: 8080 8288} 8289let tlsSecureOptions: socket.TLSSecureOptions = { 8290 key: "xxxx", 8291 cert: "xxxx", 8292 ca: ["xxxx"], 8293 password: "xxxx", 8294 protocols: socket.Protocol.TLSv12, 8295 useRemoteCipherPrefer: true, 8296 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8297 cipherSuite: "AES256-SHA256" 8298} 8299let tlsConnectOptions: socket.TLSConnectOptions = { 8300 address: netAddress, 8301 secureOptions: tlsSecureOptions, 8302 ALPNProtocols: ["spdy/1", "http/1.1"] 8303} 8304tlsServer.listen(tlsConnectOptions).then(() => { 8305 console.log("listen callback success"); 8306}).catch((err: BusinessError) => { 8307 console.log("failed" + err); 8308}); 8309tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8310 client.getRemoteAddress((err: BusinessError, data: socket.NetAddress) => { 8311 if (err) { 8312 console.log('getRemoteAddress fail'); 8313 return; 8314 } 8315 console.log('getRemoteAddress success:' + JSON.stringify(data)); 8316 }); 8317}); 8318``` 8319 8320### getRemoteAddress<sup>10+</sup> 8321 8322getRemoteAddress(): Promise\<NetAddress\> 8323 8324在TLSSocketServer通信连接成功之后，获取对端Socket地址。使用Promise方式作为异步方法。 8325 8326**系统能力**：SystemCapability.Communication.NetStack 8327 8328**返回值：** 8329 8330| 类型 | 说明 | 8331| ----------------------------------- | ----------------------------------------------------------- | 8332| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取对端socket地址的结果。失败返回错误码，错误信息。 | 8333 8334**错误码：** 8335 8336| 错误码ID | 错误信息 | 8337| -------- | ------------------------------- | 8338| 2303188 | Socket operation on non-socket. | 8339| 2300002 | System internal error. | 8340 8341**示例：** 8342 8343```ts 8344import { socket } from '@kit.NetworkKit'; 8345import { BusinessError } from '@kit.BasicServicesKit'; 8346 8347let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8348let netAddress: socket.NetAddress = { 8349 address: '192.168.xx.xxx', 8350 port: 8080 8351} 8352let tlsSecureOptions: socket.TLSSecureOptions = { 8353 key: "xxxx", 8354 cert: "xxxx", 8355 ca: ["xxxx"], 8356 password: "xxxx", 8357 protocols: socket.Protocol.TLSv12, 8358 useRemoteCipherPrefer: true, 8359 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8360 cipherSuite: "AES256-SHA256" 8361} 8362let tlsConnectOptions: socket.TLSConnectOptions = { 8363 address: netAddress, 8364 secureOptions: tlsSecureOptions, 8365 ALPNProtocols: ["spdy/1", "http/1.1"] 8366} 8367tlsServer.listen(tlsConnectOptions).then(() => { 8368 console.log("listen callback success"); 8369}).catch((err: BusinessError) => { 8370 console.log("failed" + err); 8371}); 8372tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8373 client.getRemoteAddress().then((data: socket.NetAddress) => { 8374 console.log('getRemoteAddress success:' + JSON.stringify(data)); 8375 }).catch((err: BusinessError) => { 8376 console.error("failed" + err); 8377 }); 8378}); 8379``` 8380 8381### getRemoteCertificate<sup>10+</sup> 8382 8383getRemoteCertificate(callback: AsyncCallback\<[X509CertRawData](#x509certrawdata9)\>): void 8384 8385在TLSSocketServer通信连接成功之后，获取对端的数字证书，该接口只适用于客户端向服务端发送证书时，使用callback方式作为异步方法。 8386 8387**系统能力**：SystemCapability.Communication.NetStack 8388 8389**参数：** 8390 8391| 参数名 | 类型 | 必填 | 说明 | 8392| -------- | ----------------------------------------------------- | ---- | ---------------------------------------------------- | 8393| callback | AsyncCallback\<[X509CertRawData](#x509certrawdata9)\> | 是 | 回调函数，返回对端的证书。失败返回错误码、错误信息。 | 8394 8395**错误码：** 8396 8397| 错误码ID | 错误信息 | 8398| -------- | ---------------------- | 8399| 401 | Parameter error. | 8400| 2303501 | SSL is null. | 8401| 2300002 | System internal error. | 8402 8403**示例：** 8404 8405```ts 8406import { socket } from '@kit.NetworkKit'; 8407import { BusinessError } from '@kit.BasicServicesKit'; 8408import { util } from '@kit.ArkTS'; 8409 8410let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8411let netAddress: socket.NetAddress = { 8412 address: '192.168.xx.xxx', 8413 port: 8080 8414} 8415let tlsSecureOptions: socket.TLSSecureOptions = { 8416 key: "xxxx", 8417 cert: "xxxx", 8418 ca: ["xxxx"], 8419 password: "xxxx", 8420 protocols: socket.Protocol.TLSv12, 8421 useRemoteCipherPrefer: true, 8422 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8423 cipherSuite: "AES256-SHA256" 8424} 8425let tlsConnectOptions: socket.TLSConnectOptions = { 8426 address: netAddress, 8427 secureOptions: tlsSecureOptions, 8428 ALPNProtocols: ["spdy/1", "http/1.1"] 8429} 8430tlsServer.listen(tlsConnectOptions).then(() => { 8431 console.log("listen callback success"); 8432}).catch((err: BusinessError) => { 8433 console.log("failed" + err); 8434}); 8435tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8436 client.getRemoteCertificate((err: BusinessError, data: socket.X509CertRawData) => { 8437 if (err) { 8438 console.log("getRemoteCertificate callback error: " + err); 8439 } else { 8440 const decoder = util.TextDecoder.create(); 8441 const str = decoder.decodeWithStream(data.data); 8442 console.log("getRemoteCertificate callback: " + str); 8443 } 8444 }); 8445}); 8446``` 8447 8448### getRemoteCertificate<sup>10+</sup> 8449 8450getRemoteCertificate():Promise\<[X509CertRawData](#x509certrawdata9)\> 8451 8452在TLSSocketServer通信连接成功之后，获取对端的数字证书，该接口只适用于客户端向服务端发送证书时，使用Promise方式作为异步方法。 8453 8454**系统能力**：SystemCapability.Communication.NetStack 8455 8456**返回值：** 8457 8458| 类型 | 说明 | 8459| ----------------------------------------------- | ------------------------------------------------------------ | 8460| Promise\<[X509CertRawData](#x509certrawdata9)\> | 以Promise形式返回对端的数字证书的结果。失败返回错误码，错误信息。 | 8461 8462**错误码：** 8463 8464| 错误码ID | 错误信息 | 8465| -------- | ---------------------- | 8466| 2303501 | SSL is null. | 8467| 2300002 | System internal error. | 8468 8469**示例：** 8470 8471```ts 8472import { socket } from '@kit.NetworkKit'; 8473import { BusinessError } from '@kit.BasicServicesKit'; 8474import { util } from '@kit.ArkTS'; 8475 8476let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8477let netAddress: socket.NetAddress = { 8478 address: '192.168.xx.xxx', 8479 port: 8080 8480} 8481let tlsSecureOptions: socket.TLSSecureOptions = { 8482 key: "xxxx", 8483 cert: "xxxx", 8484 ca: ["xxxx"], 8485 password: "xxxx", 8486 protocols: socket.Protocol.TLSv12, 8487 useRemoteCipherPrefer: true, 8488 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8489 cipherSuite: "AES256-SHA256" 8490} 8491let tlsConnectOptions: socket.TLSConnectOptions = { 8492 address: netAddress, 8493 secureOptions: tlsSecureOptions, 8494 ALPNProtocols: ["spdy/1", "http/1.1"] 8495} 8496tlsServer.listen(tlsConnectOptions).then(() => { 8497 console.log("listen callback success"); 8498}).catch((err: BusinessError) => { 8499 console.log("failed" + err); 8500}); 8501tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8502 client.getRemoteCertificate().then((data: socket.X509CertRawData) => { 8503 const decoder = util.TextDecoder.create(); 8504 const str = decoder.decodeWithStream(data.data); 8505 console.log("getRemoteCertificate success: " + str); 8506 }).catch((err: BusinessError) => { 8507 console.error("failed" + err); 8508 }); 8509}); 8510``` 8511 8512### getCipherSuite<sup>10+</sup> 8513 8514getCipherSuite(callback: AsyncCallback\<Array\<string\>\>): void 8515 8516在TLSSocketServer通信连接成功之后，获取通信双方协商后的加密套件，使用callback方式作为异步方法。 8517 8518**系统能力**：SystemCapability.Communication.NetStack 8519 8520**参数：** 8521 8522| 参数名 | 类型 | 必填 | 说明 | 8523| -------- | -------------------------------- | ---- | ------------------------------------------------------------ | 8524| callback | AsyncCallback\<Array\<string\>\> | 是 | 回调函数，返回通信双方支持的加密套件。失败返回错误码、错误信息。 | 8525 8526**错误码：** 8527 8528| 错误码ID | 错误信息 | 8529| -------- | -------------------------------------- | 8530| 401 | Parameter error. | 8531| 2303501 | SSL is null. | 8532| 2303502 | An error occurred when reading data on the TLS socket.| 8533| 2303505 | An error occurred in the TLS system call.| 8534| 2300002 | System internal error. | 8535 8536**示例：** 8537 8538```ts 8539import { socket } from '@kit.NetworkKit'; 8540import { BusinessError } from '@kit.BasicServicesKit'; 8541 8542let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8543let netAddress: socket.NetAddress = { 8544 address: '192.168.xx.xxx', 8545 port: 8080 8546} 8547let tlsSecureOptions: socket.TLSSecureOptions = { 8548 key: "xxxx", 8549 cert: "xxxx", 8550 ca: ["xxxx"], 8551 password: "xxxx", 8552 protocols: socket.Protocol.TLSv12, 8553 useRemoteCipherPrefer: true, 8554 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8555 cipherSuite: "AES256-SHA256" 8556} 8557let tlsConnectOptions: socket.TLSConnectOptions = { 8558 address: netAddress, 8559 secureOptions: tlsSecureOptions, 8560 ALPNProtocols: ["spdy/1", "http/1.1"] 8561} 8562tlsServer.listen(tlsConnectOptions).then(() => { 8563 console.log("listen callback success"); 8564}).catch((err: BusinessError) => { 8565 console.log("failed" + err); 8566}); 8567tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8568 client.getCipherSuite((err: BusinessError, data: Array<string>) => { 8569 if (err) { 8570 console.log("getCipherSuite callback error = " + err); 8571 } else { 8572 console.log("getCipherSuite callback = " + data); 8573 } 8574 }); 8575}); 8576``` 8577 8578### getCipherSuite<sup>10+</sup> 8579 8580getCipherSuite(): Promise\<Array\<string\>\> 8581 8582在TLSSocketServer通信连接成功之后，获取通信双方协商后的加密套件，使用Promise方式作为异步方法。 8583 8584**系统能力**：SystemCapability.Communication.NetStack 8585 8586**返回值：** 8587 8588| 类型 | 说明 | 8589| -------------------------- | ------------------------------------------------------------ | 8590| Promise\<Array\<string\>\> | 以Promise形式返回通信双方支持的加密套件。失败返回错误码，错误信息。 | 8591 8592**错误码：** 8593 8594| 错误码ID | 错误信息 | 8595| -------- | -------------------------------------- | 8596| 2303501 | SSL is null. | 8597| 2303502 | An error occurred when reading data on the TLS socket.| 8598| 2303505 | An error occurred in the TLS system call. | 8599| 2300002 | System internal error. | 8600 8601**示例：** 8602 8603```ts 8604import { socket } from '@kit.NetworkKit'; 8605import { BusinessError } from '@kit.BasicServicesKit'; 8606 8607let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8608let netAddress: socket.NetAddress = { 8609 address: '192.168.xx.xxx', 8610 port: 8080 8611} 8612let tlsSecureOptions: socket.TLSSecureOptions = { 8613 key: "xxxx", 8614 cert: "xxxx", 8615 ca: ["xxxx"], 8616 password: "xxxx", 8617 protocols: socket.Protocol.TLSv12, 8618 useRemoteCipherPrefer: true, 8619 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8620 cipherSuite: "AES256-SHA256" 8621} 8622let tlsConnectOptions: socket.TLSConnectOptions = { 8623 address: netAddress, 8624 secureOptions: tlsSecureOptions, 8625 ALPNProtocols: ["spdy/1", "http/1.1"] 8626} 8627tlsServer.listen(tlsConnectOptions).then(() => { 8628 console.log("listen callback success"); 8629}).catch((err: BusinessError) => { 8630 console.log("failed" + err); 8631}); 8632tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8633 client.getCipherSuite().then((data: Array<string>) => { 8634 console.log('getCipherSuite success:' + JSON.stringify(data)); 8635 }).catch((err: BusinessError) => { 8636 console.error("failed" + err); 8637 }); 8638}); 8639``` 8640 8641### getSignatureAlgorithms<sup>10+</sup> 8642 8643getSignatureAlgorithms(callback: AsyncCallback\<Array\<string\>\>): void 8644 8645在TLSSocketServer通信连接成功之后，获取通信双方协商后签名算法，使用callback方式作为异步方法。 8646 8647**系统能力**：SystemCapability.Communication.NetStack 8648 8649**参数：** 8650 8651| 参数名 | 类型 | 必填 | 说明 | 8652| -------- | -------------------------------- | ---- | ---------------------------------- | 8653| callback | AsyncCallback\<Array\<string\>\> | 是 | 回调函数，返回双方支持的签名算法。 | 8654 8655**错误码：** 8656 8657| 错误码ID | 错误信息 | 8658| -------- | ---------------------- | 8659| 401 | Parameter error. | 8660| 2303501 | SSL is null. | 8661| 2300002 | System internal error. | 8662 8663**示例：** 8664 8665```ts 8666import { socket } from '@kit.NetworkKit'; 8667import { BusinessError } from '@kit.BasicServicesKit'; 8668 8669let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8670let netAddress: socket.NetAddress = { 8671 address: '192.168.xx.xxx', 8672 port: 8080 8673} 8674let tlsSecureOptions: socket.TLSSecureOptions = { 8675 key: "xxxx", 8676 cert: "xxxx", 8677 ca: ["xxxx"], 8678 password: "xxxx", 8679 protocols: socket.Protocol.TLSv12, 8680 useRemoteCipherPrefer: true, 8681 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8682 cipherSuite: "AES256-SHA256" 8683} 8684let tlsConnectOptions: socket.TLSConnectOptions = { 8685 address: netAddress, 8686 secureOptions: tlsSecureOptions, 8687 ALPNProtocols: ["spdy/1", "http/1.1"] 8688} 8689tlsServer.listen(tlsConnectOptions).then(() => { 8690 console.log("listen callback success"); 8691}).catch((err: BusinessError) => { 8692 console.log("failed" + err); 8693}); 8694tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8695 client.getSignatureAlgorithms((err: BusinessError, data: Array<string>) => { 8696 if (err) { 8697 console.log("getSignatureAlgorithms callback error = " + err); 8698 } else { 8699 console.log("getSignatureAlgorithms callback = " + data); 8700 } 8701 }); 8702}); 8703``` 8704 8705### getSignatureAlgorithms<sup>10+</sup> 8706 8707getSignatureAlgorithms(): Promise\<Array\<string\>\> 8708 8709在TLSSocketServer通信连接成功之后，获取通信双方协商后的签名算法，使用Promise方式作为异步方法。 8710 8711**系统能力**：SystemCapability.Communication.NetStack 8712 8713**返回值：** 8714 8715| 类型 | 说明 | 8716| -------------------------- | --------------------------------------------- | 8717| Promise\<Array\<string\>\> | 以Promise形式返回获取到的双方支持的签名算法。 | 8718 8719**错误码：** 8720 8721| 错误码ID | 错误信息 | 8722| -------- | ---------------------- | 8723| 2303501 | SSL is null. | 8724| 2300002 | System internal error. | 8725 8726**示例：** 8727 8728```ts 8729import { socket } from '@kit.NetworkKit'; 8730import { BusinessError } from '@kit.BasicServicesKit'; 8731 8732let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8733let netAddress: socket.NetAddress = { 8734 address: '192.168.xx.xxx', 8735 port: 8080 8736} 8737let tlsSecureOptions: socket.TLSSecureOptions = { 8738 key: "xxxx", 8739 cert: "xxxx", 8740 ca: ["xxxx"], 8741 password: "xxxx", 8742 protocols: socket.Protocol.TLSv12, 8743 useRemoteCipherPrefer: true, 8744 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8745 cipherSuite: "AES256-SHA256" 8746} 8747let tlsConnectOptions: socket.TLSConnectOptions = { 8748 address: netAddress, 8749 secureOptions: tlsSecureOptions, 8750 ALPNProtocols: ["spdy/1", "http/1.1"] 8751} 8752tlsServer.listen(tlsConnectOptions).then(() => { 8753 console.log("listen callback success"); 8754}).catch((err: BusinessError) => { 8755 console.log("failed" + err); 8756}); 8757tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8758 client.getSignatureAlgorithms().then((data: Array<string>) => { 8759 console.log("getSignatureAlgorithms success" + data); 8760 }).catch((err: BusinessError) => { 8761 console.error("failed" + err); 8762 }); 8763}); 8764``` 8765 8766### getLocalAddress<sup>12+</sup> 8767 8768getLocalAddress(): Promise\<NetAddress\> 8769 8770获取TLSSocketConnection连接的本地Socket地址。使用Promise方式作为异步方法。 8771 8772> **说明：** 8773> 在TLSSocketServer通信连接成功之后，才可调用此方法。 8774 8775**系统能力**：SystemCapability.Communication.NetStack 8776 8777**返回值：** 8778 8779| 类型 | 说明 | 8780| -------------- | --------------------------------------------------- | 8781| Promise\<[NetAddress](#netaddress)\> | 以Promise形式返回获取本地socket地址的结果。 | 8782 8783**错误码：** 8784 8785| 错误码ID | 错误信息 | 8786| -------- | ------------------------------------------- | 8787| 2300002 | System internal error. | 8788| 2301009 | Bad file descriptor. | 8789| 2303188 | Socket operation on non-socket. | 8790 8791**示例：** 8792 8793```ts 8794import { socket } from '@kit.NetworkKit'; 8795import { BusinessError } from '@kit.BasicServicesKit'; 8796 8797let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8798let netAddress: socket.NetAddress = { 8799 address: '192.168.xx.xxx', 8800 port: 8080 8801} 8802let tlsSecureOptions: socket.TLSSecureOptions = { 8803 key: "xxxx", 8804 cert: "xxxx", 8805 ca: ["xxxx"], 8806 password: "xxxx", 8807 protocols: socket.Protocol.TLSv12, 8808 useRemoteCipherPrefer: true, 8809 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8810 cipherSuite: "AES256-SHA256" 8811} 8812let tlsConnectOptions: socket.TLSConnectOptions = { 8813 address: netAddress, 8814 secureOptions: tlsSecureOptions, 8815 ALPNProtocols: ["spdy/1", "http/1.1"] 8816} 8817tlsServer.listen(tlsConnectOptions).then(() => { 8818 console.info("listen callback success"); 8819}).catch((err: BusinessError) => { 8820 console.error("failed" + err); 8821}); 8822 8823tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8824 client.getLocalAddress().then((localAddress: socket.NetAddress) => { 8825 console.info("Family IP Port: " + JSON.stringify(localAddress)); 8826 }).catch((err: BusinessError) => { 8827 console.error("TLS Client Get Family IP Port failed, error: " + JSON.stringify(err)); 8828 }) 8829}); 8830``` 8831 8832### on('message')<sup>10+</sup> 8833 8834on(type: 'message', callback: Callback\<SocketMessageInfo\>): void 8835 8836订阅TLSSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 8837 8838**系统能力**：SystemCapability.Communication.NetStack 8839 8840**参数：** 8841 8842| 参数名 | 类型 | 必填 | 说明 | 8843| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 8844| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 8845| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 是 | 回调函数。成功时返回TLSSocketConnection连接信息，失败时返回错误码、错误信息。 | 8846 8847**错误码：** 8848 8849| 错误码ID | 错误信息 | 8850| -------- | ---------------- | 8851| 401 | Parameter error. | 8852 8853**示例：** 8854 8855```ts 8856import { socket } from '@kit.NetworkKit'; 8857import { BusinessError } from '@kit.BasicServicesKit'; 8858 8859let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8860let netAddress: socket.NetAddress = { 8861 address: '192.168.xx.xxx', 8862 port: 8080 8863} 8864let tlsSecureOptions: socket.TLSSecureOptions = { 8865 key: "xxxx", 8866 cert: "xxxx", 8867 ca: ["xxxx"], 8868 password: "xxxx", 8869 protocols: socket.Protocol.TLSv12, 8870 useRemoteCipherPrefer: true, 8871 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8872 cipherSuite: "AES256-SHA256" 8873} 8874let tlsConnectOptions: socket.TLSConnectOptions = { 8875 address: netAddress, 8876 secureOptions: tlsSecureOptions, 8877 ALPNProtocols: ["spdy/1", "http/1.1"] 8878} 8879tlsServer.listen(tlsConnectOptions).then(() => { 8880 console.log("listen callback success"); 8881}).catch((err: BusinessError) => { 8882 console.log("failed" + err); 8883}); 8884 8885tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8886 client.on('message', (value: socket.SocketMessageInfo) => { 8887 let messageView = ''; 8888 for (let i: number = 0; i < value.message.byteLength; i++) { 8889 let uint8Array = new Uint8Array(value.message) 8890 let messages = uint8Array[i] 8891 let message = String.fromCharCode(messages); 8892 messageView += message; 8893 } 8894 console.log('on message message: ' + JSON.stringify(messageView)); 8895 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 8896 }); 8897}); 8898``` 8899 8900### off('message')<sup>10+</sup> 8901 8902off(type: 'message', callback?: Callback\<SocketMessageInfo\>): void 8903 8904取消订阅TLSSocketConnection连接的接收消息事件。使用callback方式作为异步方法。 8905 8906**系统能力**：SystemCapability.Communication.NetStack 8907 8908**参数：** 8909 8910| 参数名 | 类型 | 必填 | 说明 | 8911| -------- | ------------------------------------------------------------ | ---- | ----------------------------------------- | 8912| type | string | 是 | 订阅的事件类型。'message'：接收消息事件。 | 8913| callback | Callback\<[SocketMessageInfo](#socketmessageinfo11)\> | 否 | 回调函数。成功时返回TLSSocketConnection连接信息，失败时返回错误码、错误信息。 | 8914 8915**错误码：** 8916 8917| 错误码ID | 错误信息 | 8918| -------- | ---------------- | 8919| 401 | Parameter error. | 8920 8921**示例：** 8922 8923```ts 8924import { socket } from '@kit.NetworkKit'; 8925import { BusinessError } from '@kit.BasicServicesKit'; 8926 8927let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 8928let netAddress: socket.NetAddress = { 8929 address: '192.168.xx.xxx', 8930 port: 8080 8931} 8932let tlsSecureOptions: socket.TLSSecureOptions = { 8933 key: "xxxx", 8934 cert: "xxxx", 8935 ca: ["xxxx"], 8936 password: "xxxx", 8937 protocols: socket.Protocol.TLSv12, 8938 useRemoteCipherPrefer: true, 8939 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 8940 cipherSuite: "AES256-SHA256" 8941} 8942let tlsConnectOptions: socket.TLSConnectOptions = { 8943 address: netAddress, 8944 secureOptions: tlsSecureOptions, 8945 ALPNProtocols: ["spdy/1", "http/1.1"] 8946} 8947tlsServer.listen(tlsConnectOptions).then(() => { 8948 console.log("listen callback success"); 8949}).catch((err: BusinessError) => { 8950 console.log("failed" + err); 8951}); 8952 8953let callback = (value: socket.SocketMessageInfo) => { 8954 let messageView = ''; 8955 for (let i: number = 0; i < value.message.byteLength; i++) { 8956 let uint8Array = new Uint8Array(value.message) 8957 let messages = uint8Array[i] 8958 let message = String.fromCharCode(messages); 8959 messageView += message; 8960 } 8961 console.log('on message message: ' + JSON.stringify(messageView)); 8962 console.log('remoteInfo: ' + JSON.stringify(value.remoteInfo)); 8963} 8964tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 8965 client.on('message', callback); 8966 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 8967 client.off('message', callback); 8968 client.off('message'); 8969}); 8970``` 8971 8972### on('close')<sup>10+</sup> 8973 8974on(type: 'close', callback: Callback\<void\>): void 8975 8976订阅TLSSocketConnection的关闭事件。使用callback方式作为异步方法。 8977 8978**系统能力**：SystemCapability.Communication.NetStack 8979 8980**参数：** 8981 8982| 参数名 | 类型 | 必填 | 说明 | 8983| -------- | ---------------- | ---- | ----------------------------------- | 8984| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 8985| callback | Callback\<void\> | 是 | 回调函数。成功时返回空，失败时返回错误码、错误信息。 | 8986 8987**错误码：** 8988 8989| 错误码ID | 错误信息 | 8990| -------- | ---------------- | 8991| 401 | Parameter error. | 8992 8993**示例：** 8994 8995```ts 8996import { socket } from '@kit.NetworkKit'; 8997import { BusinessError } from '@kit.BasicServicesKit'; 8998 8999let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 9000let netAddress: socket.NetAddress = { 9001 address: '192.168.xx.xxx', 9002 port: 8080 9003} 9004let tlsSecureOptions: socket.TLSSecureOptions = { 9005 key: "xxxx", 9006 cert: "xxxx", 9007 ca: ["xxxx"], 9008 password: "xxxx", 9009 protocols: socket.Protocol.TLSv12, 9010 useRemoteCipherPrefer: true, 9011 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 9012 cipherSuite: "AES256-SHA256" 9013} 9014let tlsConnectOptions: socket.TLSConnectOptions = { 9015 address: netAddress, 9016 secureOptions: tlsSecureOptions, 9017 ALPNProtocols: ["spdy/1", "http/1.1"] 9018} 9019tlsServer.listen(tlsConnectOptions).then(() => { 9020 console.log("listen callback success"); 9021}).catch((err: BusinessError) => { 9022 console.log("failed" + err); 9023}); 9024tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 9025 client.on('close', () => { 9026 console.log("on close success") 9027 }); 9028}); 9029``` 9030 9031### off('close')<sup>10+</sup> 9032 9033off(type: 'close', callback?: Callback\<void\>): void 9034 9035取消订阅TLSSocketConnection的关闭事件。使用callback方式作为异步方法。 9036 9037**系统能力**：SystemCapability.Communication.NetStack 9038 9039**参数：** 9040 9041| 参数名 | 类型 | 必填 | 说明 | 9042| -------- | ---------------- | ---- | ----------------------------------- | 9043| type | string | 是 | 订阅的事件类型。'close'：关闭事件。 | 9044| callback | Callback\<void\> | 否 | 回调函数。成功时返回空，失败时返回错误码、错误信息。 | 9045 9046**错误码：** 9047 9048| 错误码ID | 错误信息 | 9049| -------- | ---------------- | 9050| 401 | Parameter error. | 9051 9052**示例：** 9053 9054```ts 9055import { socket } from '@kit.NetworkKit'; 9056import { BusinessError } from '@kit.BasicServicesKit'; 9057 9058let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 9059let netAddress: socket.NetAddress = { 9060 address: '192.168.xx.xxx', 9061 port: 8080 9062} 9063let tlsSecureOptions: socket.TLSSecureOptions = { 9064 key: "xxxx", 9065 cert: "xxxx", 9066 ca: ["xxxx"], 9067 password: "xxxx", 9068 protocols: socket.Protocol.TLSv12, 9069 useRemoteCipherPrefer: true, 9070 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 9071 cipherSuite: "AES256-SHA256" 9072} 9073let tlsConnectOptions: socket.TLSConnectOptions = { 9074 address: netAddress, 9075 secureOptions: tlsSecureOptions, 9076 ALPNProtocols: ["spdy/1", "http/1.1"] 9077} 9078tlsServer.listen(tlsConnectOptions).then(() => { 9079 console.log("listen callback success"); 9080}).catch((err: BusinessError) => { 9081 console.log("failed" + err); 9082}); 9083 9084let callback = () => { 9085 console.log("on close success"); 9086} 9087tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 9088 client.on('close', callback); 9089 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 9090 client.off('close', callback); 9091 client.off('close'); 9092}); 9093``` 9094 9095### on('error')<sup>10+</sup> 9096 9097on(type: 'error', callback: ErrorCallback): void 9098 9099订阅TLSSocketConnection连接的error事件。使用callback方式作为异步方法。 9100 9101**系统能力**：SystemCapability.Communication.NetStack 9102 9103**参数：** 9104 9105| 参数名 | 类型 | 必填 | 说明 | 9106| -------- | ------------- | ---- | ------------------------------------ | 9107| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 9108| callback | ErrorCallback | 是 | 回调函数。成功时返回空，失败时返回错误码、错误信息。 | 9109 9110**错误码：** 9111 9112| 错误码ID | 错误信息 | 9113| -------- | ---------------- | 9114| 401 | Parameter error. | 9115 9116**示例：** 9117 9118```ts 9119import { socket } from '@kit.NetworkKit'; 9120import { BusinessError } from '@kit.BasicServicesKit'; 9121 9122let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 9123let netAddress: socket.NetAddress = { 9124 address: '192.168.xx.xxx', 9125 port: 8080 9126} 9127let tlsSecureOptions: socket.TLSSecureOptions = { 9128 key: "xxxx", 9129 cert: "xxxx", 9130 ca: ["xxxx"], 9131 password: "xxxx", 9132 protocols: socket.Protocol.TLSv12, 9133 useRemoteCipherPrefer: true, 9134 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 9135 cipherSuite: "AES256-SHA256" 9136} 9137let tlsConnectOptions: socket.TLSConnectOptions = { 9138 address: netAddress, 9139 secureOptions: tlsSecureOptions, 9140 ALPNProtocols: ["spdy/1", "http/1.1"] 9141} 9142tlsServer.listen(tlsConnectOptions).then(() => { 9143 console.log("listen callback success"); 9144}).catch((err: BusinessError) => { 9145 console.log("failed" + err); 9146}); 9147 9148tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 9149 client.on('error', (err: BusinessError) => { 9150 console.log("on error, err:" + JSON.stringify(err)) 9151 }); 9152}); 9153``` 9154 9155### off('error')<sup>10+</sup> 9156 9157off(type: 'error', callback?: ErrorCallback): void 9158 9159取消订阅TLSSocketConnection连接的error事件。使用callback方式作为异步方法。 9160 9161**系统能力**：SystemCapability.Communication.NetStack 9162 9163**参数：** 9164 9165| 参数名 | 类型 | 必填 | 说明 | 9166| -------- | ------------- | ---- | ------------------------------------ | 9167| type | string | 是 | 订阅的事件类型。'error'：error事件。 | 9168| callback | ErrorCallback | 否 | 回调函数。成功时返回空，失败时返回错误码、错误信息。 | 9169 9170**错误码：** 9171 9172| 错误码ID | 错误信息 | 9173| -------- | ---------------- | 9174| 401 | Parameter error. | 9175 9176**示例：** 9177 9178```ts 9179import { socket } from '@kit.NetworkKit'; 9180import { BusinessError } from '@kit.BasicServicesKit'; 9181 9182let tlsServer: socket.TLSSocketServer = socket.constructTLSSocketServerInstance(); 9183let netAddress: socket.NetAddress = { 9184 address: '192.168.xx.xxx', 9185 port: 8080 9186} 9187let tlsSecureOptions: socket.TLSSecureOptions = { 9188 key: "xxxx", 9189 cert: "xxxx", 9190 ca: ["xxxx"], 9191 password: "xxxx", 9192 protocols: socket.Protocol.TLSv12, 9193 useRemoteCipherPrefer: true, 9194 signatureAlgorithms: "rsa_pss_rsae_sha256:ECDSA+SHA256", 9195 cipherSuite: "AES256-SHA256" 9196} 9197let tlsConnectOptions: socket.TLSConnectOptions = { 9198 address: netAddress, 9199 secureOptions: tlsSecureOptions, 9200 ALPNProtocols: ["spdy/1", "http/1.1"] 9201} 9202tlsServer.listen(tlsConnectOptions).then(() => { 9203 console.log("listen callback success"); 9204}).catch((err: BusinessError) => { 9205 console.log("failed" + err); 9206}); 9207 9208let callback = (err: BusinessError) => { 9209 console.log("on error, err:" + JSON.stringify(err)); 9210} 9211tlsServer.on('connect', (client: socket.TLSSocketConnection) => { 9212 client.on('error', callback); 9213 // 可以指定传入on中的callback取消一个订阅，也可以不指定callback清空所有订阅。 9214 client.off('error', callback); 9215 client.off('error'); 9216}); 9217``` 9218