react native tcp socket react native tcp socket REAT

react-native-tcp-socket

React API de socket TCP Native pour Android, iOS & MacOS avec support SSL / TLS . Il vous permet de créer des sockets clients et de serveurs TCP, imitant les fonctionnalités API TLS de Node et Node (vérifiez l'API disponible pour plus d'informations).

Table des matières

Commencer
- net primordial
- tls dominant
- Utilisation de React Native> = 0,60
- SSL auto-signé (disponible uniquement pour React Native> 0,60)
- Utilisation de React Native <0,60
Réagir la compatibilité native
Usage
- Exemple du client
- Exemple de serveur
- Exemple du client TLS
- Exemple du serveur TLS
API
- filet
  - Douille
  - Serveur
- TLS
  - Tlssocket
  - Tlsserver
Maintient
Remerciements
Licence

Commencer

Installez la bibliothèque à l'aide d'un fil:

 yarn add react-native-tcp-socket

ou npm:

 npm install --save react-native-tcp-socket

`net` primordial

Étant donné que react-native-tcp-socket propose la même API que NET de Node, au cas où vous souhaitez importer ce module en tant que net ou utilisation require('net') dans votre javascript, vous devez ajouter les lignes suivantes à votre fichier package.json .

{
  "react-native" : {
    "net" : " react-native-tcp-socket "
  }
}

De plus, afin d'obtenir les types TS (ou l'assiette automatique) fournis par ce module, vous devez également ajouter ce qui suit à votre fichier de déclarations personnalisées.

...
declare module 'net' {
    import TcpSockets from 'react-native-tcp-socket' ;
    export = TcpSockets ;
}

Si vous souhaitez éviter les types net dupliqués, assurez-vous de ne pas utiliser les node_modules/@types par défaut dans votre propriété tsconfig.json "typeRoots" .

Vérifiez l'exemple de l'application fournie pour un exemple de travail.

`tls` dominant

Il en va de même pour le module tls . Cependant, vous devez être conscient des éléments suivants:

La classe Server exportée par défaut est non-TLS. Pour utiliser le serveur TLS, vous devez utiliser la classe TLSServer . Vous pouvez remplacer la classe Server par défaut ( tls.Server = tls.TLSServer ). Il en va de même avec le createServer() et connect() . Afin d'utiliser les méthodes TLS, vous devez utiliser respectivement les méthodes createTLSServer() et connectTLS() . Vous pouvez remplacer les méthodes par défaut ( tls.createServer = tls.createTLSServer et tls.connect = tls.connectTLS ).
Le module tls de Node nécessite que les clés et les certificats soient fournis sous forme de chaîne. Cependant, le module react-native-tcp-socket exige qu'ils soient importés avec require() .

De plus, afin d'obtenir les types TS (ou l'assiette automatique) fournis par ce module, vous devez également ajouter ce qui suit à votre fichier de déclarations personnalisées.

...
declare module 'tls' {
    import TcpSockets from 'react-native-tcp-socket' ;
    export const Server = TcpSockets . TLSServer ;
    export const TLSSocket = TcpSockets . TLSSocket ;
    export const connect = TcpSockets . connectTLS ;
    export const createServer = TcpSockets . createTLSServer ;
}

Vérifiez l'exemple de l'application fournie pour un exemple de travail.

Utilisation de React Native> = 0,60

Lier le paquet manuellement n'est plus nécessaire avec la mise à feu.

Plateforme iOS:
$ cd ios && pod install && cd .. # cocoapods sur iOS a besoin de cette étape supplémentaire
Plateforme Android:
Modifiez votre configuration android/build.gradle pour correspondre à minSdkVersion = 21 :
```
 buildscript {
  ext {
    ...
    minSdkVersion = 21
    ...
  }
```

SSL auto-signé (disponible uniquement pour React Native> 0,60)

Afin de générer les fichiers requis (clés et certificats) pour SSL auto-signé, vous pouvez utiliser la commande suivante:

 openssl genrsa -out server-key.pem 4096
openssl req -new -key server-key.pem -out server-csr.pem
openssl x509 -req -in server-csr.pem -signkey server-key.pem -out server-cert.pem
openssl pkcs12 -export -out server-keystore.p12 -inkey server-key.pem -in server-cert.pem

Remarque: le server-keystore.p12 ne doit pas avoir de mot de passe.

Vous aurez besoin d'un fichier metro.config.js afin d'utiliser un certificat SSL auto-signé. Vous devriez déjà avoir ce fichier dans votre répertoire de projet racine, mais si vous ne le faites pas, créez-le. À l'intérieur d'un objet module.exports , créez une clé appelée resolver avec un autre objet appelé assetExts . La valeur des assetExts doit être un tableau des extensions de fichiers de ressources que vous souhaitez prendre en charge.

Si vous souhaitez pouvoir utiliser des fichiers .pem et .p12 (plus tous les fichiers déjà pris en charge), votre metro.config.js devrait ressembler à ceci:

 const { getDefaultConfig } = require ( 'metro-config' ) ;
const defaultConfig = getDefaultConfig . getDefaultValues ( __dirname ) ;

module . exports = {
  resolver : {
    assetExts : [ ... defaultConfig . resolver . assetExts , 'pem' , 'p12' ] ,
  } ,
  // ...
} ;

Utilisation de React Native <0,60

Vous devez ensuite relier les parties natives de la bibliothèque pour les plates-formes que vous utilisez. La façon la plus simple de relier la bibliothèque est d'utiliser l'outil CLI en exécutant cette commande à partir de la racine de votre projet:

$ react-native link react-native-tcp-socket

Si vous ne pouvez pas ou ne souhaitez pas utiliser l'outil CLI, vous pouvez également lier manuellement la bibliothèque à l'aide des instructions ci-dessous (cliquez sur la flèche pour les afficher):

Lier manuellement la bibliothèque sur iOS

Dans Xcode, dans le projet Navigator, Libraries de clic droit Add Files to [your project's name]
Allez dans node_modules react-native-tcp-socket et ajoutez TcpSockets.xcodeproj
Dans Xcode, dans le Navigator du projet, sélectionnez votre projet. Ajouter libTcpSockets.a aux Build Phases de votre projet Link Binary With Libraries
Exécutez votre projet ( Cmd+R ) <

Lier manuellement la bibliothèque sur Android

Ouvrez android/app/src/main/java/[...]/MainApplication.java

Ajouter import com.asterinet.react.tcpsocket.TcpSocketPackage; aux importations en haut du fichier
Ajouter new TcpSocketPackage() à la liste renvoyée par la méthode getPackages()

Ajoutez les lignes suivantes à android/settings.gradle :

 include ':react-native-tcp-socket'
project(':react-native-tcp-socket').projectDir = new File(rootProject.projectDir, 	'../node_modules/react-native-tcp-socket/android')

Insérez les lignes suivantes à l'intérieur du bloc des dépendances dans android/app/build.gradle :
```
  implementation project(':react-native-tcp-socket')
```

Réagir la compatibilité native

Pour utiliser cette bibliothèque, vous devez vous assurer que vous utilisez la version correcte de React Native. Si vous utilisez une version de React Native qui est inférieure à 0.60 vous devrez mettre à niveau avant d'essayer d'utiliser la dernière version.

version `react-native-tcp-socket`	Version native react requise
`6.XX` , `5.XX` , `4.XX` , `3.XX`	`>= 0.60.0`
`1.4.0`	`>= Unknown`

Usage

Importer la bibliothèque:

 import TcpSocket from 'react-native-tcp-socket' ;
// const net = require('react-native-tcp-socket');
// const tls = require('react-native-tcp-socket');

Exemple du client

 const options = {
  port : port ,
  host : '127.0.0.1' ,
  localAddress : '127.0.0.1' ,
  reuseAddress : true ,
  // localPort: 20000,
  // interface: "wifi",
} ;

// Create socket
const client = TcpSocket . createConnection ( options , ( ) => {
  // Write on the socket
  client . write ( 'Hello server!' ) ;

  // Close socket
  client . destroy ( ) ;
} ) ;

client . on ( 'data' , function ( data ) {
  console . log ( 'message was received' , data ) ;
} ) ;

client . on ( 'error' , function ( error ) {
  console . log ( error ) ;
} ) ;

client . on ( 'close' , function ( ) {
  console . log ( 'Connection closed!' ) ;
} ) ;

Exemple de serveur

 const server = TcpSocket . createServer ( function ( socket ) {
  socket . on ( 'data' , ( data ) => {
    socket . write ( 'Echo server ' + data ) ;
  } ) ;

  socket . on ( 'error' , ( error ) => {
    console . log ( 'An error ocurred with client socket ' , error ) ;
  } ) ;

  socket . on ( 'close' , ( error ) => {
    console . log ( 'Closed connection with ' , socket . address ( ) ) ;
  } ) ;
} ) . listen ( { port : 12345 , host : '0.0.0.0' } ) ;

server . on ( 'error' , ( error ) => {
  console . log ( 'An error ocurred with the server' , error ) ;
} ) ;

server . on ( 'close' , ( ) => {
  console . log ( 'Server closed connection' ) ;
} ) ;

Exemple du client TLS

 const options = {
  port : port ,
  host : '127.0.0.1' ,
  localAddress : '127.0.0.1' ,
  reuseAddress : true ,
  // localPort: 20000,
  // interface: "wifi",
  ca : require ( 'server-cert.pem' ) ,
} ;

// Create socket
const client = TcpSocket . connectTLS ( options , ( ) => {
  // Write on the socket
  client . write ( 'Hello server!' ) ;

  // Close socket
  client . destroy ( ) ;
} ) ;

client . on ( 'data' , function ( data ) {
  console . log ( 'message was received' , data ) ;
} ) ;

client . on ( 'error' , function ( error ) {
  console . log ( error ) ;
} ) ;

client . on ( 'close' , function ( ) {
  console . log ( 'Connection closed!' ) ;
} ) ;

Exemple du serveur TLS

 const options = {
  keystore : require ( 'server-keystore.p12' ) ,
} ;


const server = TcpSocket . createTLSServer ( options , function ( socket ) {
  socket . on ( 'data' , ( data ) => {
    socket . write ( 'Echo server ' + data ) ;
  } ) ;

  socket . on ( 'error' , ( error ) => {
    console . log ( 'An error ocurred with SSL client socket ' , error ) ;
  } ) ;

  socket . on ( 'close' , ( error ) => {
    console . log ( 'SSL closed connection with ' , socket . address ( ) ) ;
  } ) ;
} ) . listen ( { port : 12345 , host : '0.0.0.0' } ) ;

server . on ( 'error' , ( error ) => {
  console . log ( 'An error ocurred with the server' , error ) ;
} ) ;

server . on ( 'close' , ( ) => {
  console . log ( 'Server closed connection' ) ;
} ) ;

Remarque: Afin d'utiliser des certificats auto-signés, assurez-vous de mettre à jour votre configuration metro.config.js.

API

filet

Voici toutes les méthodes implémentées dans react-native-tcp-socket qui imite l'API NET de Node, leurs fonctionnalités sont équivalentes à celles fournies par le net de Node (plus d'informations sur # 41). Cependant, les méthodes dont l'interface diffère du nœud sont marquées en gras .

net.connect(options[, callback])
net.createConnection(options[, callback])
net.createServer(connectionListener)
net.isIP(input)
net.isIPv4(input)
net.isIPv6(input)

Douille

Méthodes:
- address()
- destroy([error])
- end([data][, encoding][, callback])
- setEncoding([encoding])
- setKeepAlive([enable][, initialDelay]) - initialDelay est ignoré
- setNoDelay([noDelay])
- setTimeout(timeout[, callback])
- write(data[, encoding][, callback])
- pause()
- ref() - n'aura aucun effet
- resume()
- unref() - n'aura aucun effet
Propriétés:
- Hérité de Stream.Writable :
  - writableNeedDrain
- bytesRead
- bytesWritten
- connecting
- destroyed
- localAddress
- localPort
- remoteAddress
- remoteFamily
- remotePort
- pending
- timeout
- readyState
Événements:
- Hérité de Stream.Readable :
  - 'pause'
  - 'resume'
- 'close'
- 'connect'
- 'data'
- 'drain'
- 'error'
- 'timeout'

`net.createConnection()`

net.createConnection(options[, callback]) crée une connexion TCP à l'aide des options données. Le paramètre options doit être un object avec les propriétés suivantes:

Propriété	Taper	Description
`port`	`<number>`	Requis . Port à laquelle le socket doit se connecter.
`host`	`<string>`	Héberger la prise doit se connecter. Adresse IP au format IPv4 ou `'localhost'` . Par défaut : `'localhost'` .
`localAddress`	`<string>`	Adresse locale à partir de la prise doit se connecter. S'il n'est pas spécifié, le système d'exploitation décidera. Il est fortement recommandé de spécifier un `localAddress` pour empêcher les erreurs de surcharge et améliorer les performances.
`localPort`	`<number>`	Port local La prise doit se connecter. S'il n'est pas spécifié, le système d'exploitation décidera.
`interface`	`<string>`	Interface La prise doit se connecter. S'il n'est pas spécifié, il utilisera la connexion active actuelle. Les options sont: `'wifi', 'ethernet', 'cellular'` .
`reuseAddress`	`<boolean>`	Activez / désactivez l'option de socket ReusEaddress. Par défaut : `true` .

Remarque : Les plates-formes marquées utilisent la valeur par défaut.

Serveur

Méthodes:
- address()
- listen(options[, callback])
- close([callback])
- getConnections(callback)
Propriétés:
- listening
Événements:
- 'close'
- 'connection'
- 'error'
- 'listening'

`Server.listen()`

Server.listen(options[, callback]) crée une prise de serveur TCP à l'aide des options données. Le paramètre options doit être un object avec les propriétés suivantes:

Propriété	Taper	Description
`port`	`<number>`	Requis . Port La prise doit écouter.
`host`	`<string>`	Hébergez la prise doit écouter. Adresse IP au format IPv4 ou `'localhost'` . Par défaut : `'0.0.0.0'` .
`reuseAddress`	`<boolean>`	Activez / désactivez l'option de socket ReusEaddress. Par défaut : `true` .

Remarque : Les plates-formes marquées utilisent la valeur par défaut.

TLS

Voici toutes les méthodes implémentées dans react-native-tcp-socket qui imitent l'API TLS de Node, leurs fonctionnalités sont équivalentes à celles fournies par le TLS de Node. Cependant, les méthodes dont l'interface diffère du nœud sont marquées en gras .

tls.connectTLS(options[, callback])
tls.createTLSServer([options][, secureConnectionListener])

Tlssocket

Méthodes:
- Toutes les méthodes de Socket
- getCertificate() Android uniquement
- getPeerCertificate() Android uniquement
Propriétés:
- Toutes les propriétés de Socket
Événements:
- Tous les événements de Socket
- 'secureConnect'

`tls.connectTLS()`

tls.connectTLS(options[, callback]) crée une connexion socket TLS à l'aide des options données. Le paramètre options doit être un object avec les propriétés suivantes:

Propriété	Taper	Description
`ca`	`<import>`	Fichier CA (format .pem) à faire confiance. Si `null` , il utilisera la liste de confiance SSL par défaut de l'appareil. Utile pour les certificats auto-signés. Vérifiez la documentation pour la génération de ce fichier . Par défaut : `null` .
`key`	`<import>`	Fichier de clés privés (format .pem). Vérifiez la documentation pour la génération de ce fichier .
`cert`	`<import>`	Fichier de certificat public (format .pem). Vérifiez la documentation pour la génération de ce fichier .
`androidKeyStore`	`<string>`	Alias du stade de clés Android.
`certAlias`	`<string>`	Android Keystore Certificate Alias.
`keyAlias`	`<string>`	Android Keystore Private Key Alias.
`...`	`<any>`	Toutes les autres options `socket.connect()` non déjà répertoriées.

Tlsserver

Remarque : Le serveur TLS est nommé Server dans TLS de Node, mais il est nommé TLSServer dans react-native-tcp-socket afin d'éviter la confusion avec la classe Server .

Méthodes:
- Toutes les méthodes du Server
- setSecureContext(options)
Propriétés:
- Toutes les propriétés du Server
Événements:
- Tous les événements du Server
- 'secureConnection'

`tls.createTLSServer()`

tls.createTLSServer([options][, secureConnectionListener]) Crée un nouveau tls.TLSServer . Le secureConnectionListener , s'il est fourni, est automatiquement défini en tant qu'auditeur de l'événement 'secureConnection' . Le paramètre options doit être un object avec les propriétés suivantes:

Propriété	Taper	iOS / macOS	Androïde	Description
`keystore`	`<import>`			Requis . Store de clé au format PKCS # 12 avec le certificat de serveur et la clé privée. Vérifiez la documentation pour la génération de ce fichier .

Maintient

Rapssito

Remerciements

pièce iOS à l'origine fourchue de @APRock React-Native-TCP
react-native-udp

Licence

La bibliothèque est publiée sous la licence du MIT. Pour plus d'informations, voir LICENSE .

Développer

react native tcp socket