react native tcp socket Download - react native tcp socket Quellcode Download

React-nativ-tcp-socket

React native TCP -Socket -API für Android, iOS & macOS mit SSL/TLS -Unterstützung . Sie können TCP -Client- und Server -Sockets erstellen, wodurch die TLS -API -Funktionen des Knotens und die TLS -API -Funktionen des Knotens imitieren (die verfügbaren API für weitere Informationen finden Sie unter).

Inhaltsverzeichnis

Erste Schritte
- Übergeordnetes net
- Übergeordnete tls
- Unter Verwendung von React Native> = 0,60
- Selbstsignierte SSL (nur für React Native> 0,60 verfügbar)
- Unter Verwendung von React Native <0,60
Reagieren Sie die native Kompatibilität
Verwendung
- Client -Beispiel
- Serverbeispiel
- TLS -Client -Beispiel
- TLS -Serverbeispiel
API
- netto
  - Buchse
  - Server
- tls
  - Tlssocket
  - Tlsserver
Betreuer
Anerkennung
Lizenz

Erste Schritte

Installieren Sie die Bibliothek mit beiden Garns:

 yarn add react-native-tcp-socket

oder NPM:

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

Übergeordnetes `net`

Da react-native-tcp-socket dieselbe API wie Knotennetz bietet, falls Sie dieses Modul als net oder require('net') möchten, müssen Sie in Ihrem JavaScript die folgenden Zeilen zu Ihrem package.json Datei hinzufügen.

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

Um die von diesem Modul bereitgestellten TS -Typen (oder Autocompletion) zu erhalten, müssen Sie auch Ihrer benutzerdefinierten Deklarationsdatei Folgendes hinzufügen.

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

Wenn Sie doppelte net vermeiden möchten, stellen Sie sicher, dass Sie die Standard node_modules/@types in Ihrer Eigenschaft "typeRoots" in tsconfig.json nicht verwenden.

Überprüfen Sie die Beispiel -App für ein Arbeitsbeispiel.

Übergeordnete `tls`

Gleiches gilt für tls -Modul. Sie sollten sich jedoch der Folgendes bewusst sein:

Die standardmäßig exportierte Server ist nicht-TLS. Um den TLS -Server zu verwenden, müssen Sie die TLSServer -Klasse verwenden. Sie können die Standard Server überschreiben ( tls.Server = tls.TLSServer ). Gleiches gilt für createServer() und connect() . Um die TLS -Methoden zu verwenden, müssen Sie die Methoden createTLSServer() bzw. connectTLS() verwenden. Sie können die Standardmethoden überschreiben ( tls.createServer = tls.createTLSServer und tls.connect = tls.connectTLS ).
Das tls -Modul des Knotens erfordert, dass die Schlüssel und Zertifikate als Zeichenfolge bereitgestellt werden. Das react-native-tcp-socket Modul erfordert jedoch, dass sie mit require() importiert werden.

Um die von diesem Modul bereitgestellten TS -Typen (oder Autocompletion) zu erhalten, müssen Sie auch Ihrer benutzerdefinierten Deklarationsdatei Folgendes hinzufügen.

...
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 ;
}

Überprüfen Sie die Beispiel -App für ein Arbeitsbeispiel.

Unter Verwendung von React Native> = 0,60

Das manuelle Verknüpfen des Pakets ist bei Autolinking nicht mehr erforderlich.

iOS -Plattform:
$ cd ios && pod install && cd .. # cocoapods auf iOS braucht diesen zusätzlichen Schritt
Android -Plattform:
Ändern Sie Ihre android/build.gradle -Konfiguration, um minSdkVersion = 21 zu entsprechen:
```
 buildscript {
  ext {
    ...
    minSdkVersion = 21
    ...
  }
```

Selbstsignierte SSL (nur für React Native> 0,60 verfügbar)

Um die erforderlichen Dateien (Schlüssel und Zertifikate) für selbstsignierte SSL zu generieren, können Sie den folgenden Befehl verwenden:

 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

HINWEIS: Der server-keystore.p12 muss kein Passwort haben.

Sie benötigen eine Metro.config.js-Datei, um ein selbstsigniertes SSL-Zertifikat zu verwenden. Sie sollten diese Datei bereits in Ihrem Root -Projektverzeichnis haben, aber wenn Sie dies nicht tun, erstellen Sie sie. Erstellen Sie in einem Objekt aus module.exports einen Schlüssel namens resolver mit einem anderen Objekt namens assetExts . Der Wert von assetExts sollte ein Array der Ressourcendateierweiterungen sein, die Sie unterstützen möchten.

Wenn Sie in der Lage sein möchten, .pem und .p12 -Dateien (plus alle bereits unterstützten Dateien) zu verwenden, sollte Ihre metro.config.js so aussehen:

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

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

Unter Verwendung von React Native <0,60

Anschließend müssen Sie die nativen Teile der Bibliothek für die von Ihnen verwendeten Plattformen verknüpfen. Der einfachste Weg, die Bibliothek zu verknüpfen, besteht darin, das CLI -Tool zu verwenden, indem dieser Befehl aus der Stammwurzel Ihres Projekts ausgeführt wird:

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

Wenn Sie das CLI -Tool nicht verwenden können oder nicht möchten, können Sie die Bibliothek auch mit den folgenden Anweisungen manuell verknüpfen (klicken Sie auf den Pfeil, um sie anzuzeigen):

Verknüpfen Sie die Bibliothek manuell auf iOS

Klicken Sie in Xcode im Projekt Navigator mit der rechten Maustaste Libraries auf Bibliotheken Add Files to [your project's name]
Gehen Sie zu node_modules react-native-tcp-socket und fügen Sie TcpSockets.xcodeproj hinzu
Wählen Sie in Xcode im Projekt Navigator Ihr Projekt aus. Fügen Sie libTcpSockets.a zu Build Phases Ihres Projekts Link Binary With Libraries
Führen Sie Ihr Projekt aus ( Cmd+R ) <

Verknüpfen Sie die Bibliothek manuell auf Android

Öffnen Sie android/app/src/main/java/[...]/MainApplication.java

Hinzufügen import com.asterinet.react.tcpsocket.TcpSocketPackage; zu den Importen oben in der Datei
Fügen Sie der von der getPackages() -Methode zurückgegebenen Liste new TcpSocketPackage() hinzu

Gehen Sie die folgenden Zeilen an android/settings.gradle an:

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

Fügen Sie die folgenden Zeilen in die Abhängigkeiten ein, blockieren Sie android/app/build.gradle :
```
  implementation project(':react-native-tcp-socket')
```

Reagieren Sie die native Kompatibilität

Um diese Bibliothek zu verwenden, müssen Sie sicherstellen, dass Sie die richtige Version von React Native verwenden. Wenn Sie eine Version von React Native verwenden, die niedriger als 0.60 ist, müssen Sie vor dem Versuch, die neueste Version zu verwenden, ein Upgrade durchführen.

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

Verwendung

Importieren Sie die Bibliothek:

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

Client -Beispiel

 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!' ) ;
} ) ;

Serverbeispiel

 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' ) ;
} ) ;

TLS -Client -Beispiel

 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!' ) ;
} ) ;

TLS -Serverbeispiel

 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' ) ;
} ) ;

Hinweis: Um selbstsignierte Zertifikate zu verwenden, achten Sie darauf, Ihre Metro.Config.js-Konfiguration zu aktualisieren.

API

netto

Hier sind alle in react-native-tcp-socket implementierten Methoden, die die Netto-API des Knotens imitieren. Ihre Funktionen entsprechen denen, die von Node's Net bereitgestellt werden (weitere Informationen zu #41). Die Methoden, deren Schnittstelle sich vom Knoten unterscheidet, sind jedoch fett gekennzeichnet .

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

Buchse

Methoden:
- address()
- destroy([error])
- end([data][, encoding][, callback])
- setEncoding([encoding])
- setKeepAlive([enable][, initialDelay]) - initialDelay wird ignoriert
- setNoDelay([noDelay])
- setTimeout(timeout[, callback])
- write(data[, encoding][, callback])
- pause()
- ref() - wird keinen Einfluss haben
- resume()
- unref() - hat keinen Einfluss
Eigenschaften:
- Von Stream.Writable geerbt:
  - writableNeedDrain
- bytesRead
- bytesWritten
- connecting
- destroyed
- localAddress
- localPort
- remoteAddress
- remoteFamily
- remotePort
- pending
- timeout
- readyState
Ereignisse:
- Von Stream.Readable geerbt:
  - 'pause'
  - 'resume'
- 'close'
- 'connect'
- 'data'
- 'drain'
- 'error'
- 'timeout'

`net.createConnection()`

net.createConnection(options[, callback]) erstellt eine TCP -Verbindung mit den angegebenen options . Der options muss ein object mit den folgenden Eigenschaften sein:

Eigentum	Typ	Beschreibung
`port`	`<number>`	Erforderlich . Port Die Sockel sollte eine Verbindung herstellen.
`host`	`<string>`	Host Die Sockel sollte eine Verbindung herstellen. IP -Adresse im IPv4 -Format oder `'localhost'` . Standard : `'localhost'` .
`localAddress`	`<string>`	Lokale Adresse Die Steckdose sollte eine Verbindung herstellen. Wenn nicht angegeben, entscheidet das Betriebssystem. Es wird dringend empfohlen, eine `localAddress` anzugeben, um Überladungsfehler zu vermeiden und die Leistung zu verbessern.
`localPort`	`<number>`	Lokaler Anschluss Die Steckdose sollte eine Verbindung herstellen. Wenn nicht angegeben, entscheidet das Betriebssystem.
`interface`	`<string>`	Schnittstelle der Sockel sollte eine Verbindung herstellen. Wenn nicht angegeben, wird die aktuelle aktive Verbindung verwendet. Die Optionen sind: `'wifi', 'ethernet', 'cellular'` .
`reuseAddress`	`<boolean>`	Aktivieren/deaktivieren Sie die Option für Socket -Sockel. Standard : `true` .

HINWEIS : Die als Standardwert markierten Plattformen.

Server

Methoden:
- address()
- listen(options[, callback])
- close([callback])
- getConnections(callback)
Eigenschaften:
- listening
Ereignisse:
- 'close'
- 'connection'
- 'error'
- 'listening'

`Server.listen()`

Server.listen(options[, callback]) erstellt einen TCP -Server -Socket mit den angegebenen options . Der options muss ein object mit den folgenden Eigenschaften sein:

Eigentum	Typ	Beschreibung
`port`	`<number>`	Erforderlich . Port Die Sockel sollte sich anhören.
`host`	`<string>`	Host Die Sockel sollte sich anhören. IP -Adresse im IPv4 -Format oder `'localhost'` . Standard : `'0.0.0.0'` .
`reuseAddress`	`<boolean>`	Aktivieren/deaktivieren Sie die Option für Socket -Sockel. Standard : `true` .

HINWEIS : Die als Standardwert markierten Plattformen.

tls

Hier sind alle in react-native-tcp-socket implementierten Methoden, die die TLS-API des Knotens imitieren. Die Methoden, deren Schnittstelle sich vom Knoten unterscheidet, sind jedoch fett gekennzeichnet .

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

Tlssocket

Methoden:
- Alle Methoden aus Socket
- getCertificate() nur Android
- getPeerCertificate() nur Android
Eigenschaften:
- Alle Eigenschaften von Socket
Ereignisse:
- Alle Ereignisse aus Socket
- 'secureConnect'

`tls.connectTLS()`

tls.connectTLS(options[, callback]) erstellt eine TLS -Socket -Verbindung mit den angegebenen options . Der options muss ein object mit den folgenden Eigenschaften sein:

Eigentum	Typ	Beschreibung
`ca`	`<import>`	CA -Datei (.PEM -Format) zu vertrauen. Wenn `null` , wird die Standard -SSL -vertrauenswürdige SSL -Liste des Geräts verwendet. Nützlich für selbstsignierte Zertifikate. Überprüfen Sie die Dokumentation zum Generieren einer solchen Datei . Standard : `null` .
`key`	`<import>`	Private Schlüsseldatei (.PEM -Format). Überprüfen Sie die Dokumentation zum Generieren einer solchen Datei .
`cert`	`<import>`	Öffentliche Zertifikatdatei (.PEM -Format). Überprüfen Sie die Dokumentation zum Generieren einer solchen Datei .
`androidKeyStore`	`<string>`	Android Keystore alias.
`certAlias`	`<string>`	Android Keystore Certificate Alias.
`keyAlias`	`<string>`	Android Keystore Private Key Alias.
`...`	`<any>`	Jeder andere `socket.connect()` -Optionen, die noch nicht aufgeführt sind.

Tlsserver

HINWEIS : Der TLS-Server wird in Node's TLS Server ausgezeichnet, aber er wird in react-native-tcp-socket als TLSServer bezeichnet, um Verwirrung mit der Server zu vermeiden.

Methoden:
- Alle Methoden vom Server
- setSecureContext(options)
Eigenschaften:
- Alle Eigenschaften vom Server
Ereignisse:
- Alle Ereignisse vom Server
- 'secureConnection'

`tls.createTLSServer()`

tls.createTLSServer([options][, secureConnectionListener]) erstellt einen neuen tls.TLSServer . Der secureConnectionListener wird, falls bereitgestellt, automatisch als Hörer für das Ereignis 'secureConnection' festgelegt. Der options muss ein object mit den folgenden Eigenschaften sein:

Eigentum	Typ	iOS/macos	Android	Beschreibung
`keystore`	`<import>`			Erforderlich . Schlüsselspeicher im PKCS#12 -Format mit dem Serverzertifikat und dem privaten Schlüssel. Überprüfen Sie die Dokumentation zum Generieren einer solchen Datei .

Betreuer

Rapsssito

Anerkennung

iOS-Teil ursprünglich von @APROCK React-nativ-TCP gegabelt
React-nativ-udp

Lizenz

Die Bibliothek wird unter der MIT -Lizenz veröffentlicht. Weitere Informationen finden Sie LICENSE .

Expandieren

react native tcp socket