Descargar react native tcp socket - Descargar el código fuente react native tcp socket

react-nativo-tcp-socket

React API de socket TCP Native para Android, iOS & MacOS con soporte SSL/TLS . Le permite crear sockets de cliente y servidor TCP, imitando las funcionalidades de la API TLS NET y Node de Node (verifique la API disponible para obtener más información).

Tabla de contenido

Empezando
- net
- Anulación de tls
- Usando React Native> = 0.60
- SSL autofirmado (solo disponible para React Native> 0.60)
- Usando React Native <0.60
Reaccionar la compatibilidad nativa
Uso
- Ejemplo del cliente
- Ejemplo del servidor
- Ejemplo del cliente TLS
- Ejemplo del servidor TLS
API
- neto
  - Enchufe
  - Servidor
- TLS
  - Tlssocket
  - TlsServer
Mantenedores
Expresiones de gratitud
Licencia

Empezando

Instale la biblioteca con cualquier hilo:

 yarn add react-native-tcp-socket

o NPM:

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

`net`

Dado que react-native-tcp-socket ofrece la misma API que la red del nodo, en caso de que desee importar este módulo como net o Usar require('net') en su JavaScript, debe agregar las siguientes líneas a su archivo package.json .

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

Además, para obtener los tipos TS (o autocompletación) proporcionados por este módulo, también debe agregar lo siguiente a su archivo de declaraciones personalizadas.

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

Si desea evitar los tipos net duplicados, asegúrese de no usar los node_modules/@types predeterminados en su propiedad tsconfig.json "typeRoots" .

Verifique la aplicación de ejemplo proporcionada para un ejemplo de trabajo.

Anulación de `tls`

Lo mismo se aplica al módulo tls . Sin embargo, debe conocer lo siguiente:

La clase Server exportada por defecto no es TLS. Para usar el servidor TLS, debe usar la clase TLSServer . Puede anular la clase Server predeterminada ( tls.Server = tls.TLSServer ). Lo mismo ocurre con createServer() y connect() . Para utilizar los métodos TLS, debe usar los métodos createTLSServer() y connectTLS() respectivamente. Puede anular los métodos predeterminados ( tls.createServer = tls.createTLSServer y tls.connect = tls.connectTLS ).
El módulo tls de Node requiere que las teclas y los certificados se proporcionen como una cadena. Sin embargo, el módulo react-native-tcp-socket requiere que se importen con require() .

Además, para obtener los tipos TS (o autocompletación) proporcionados por este módulo, también debe agregar lo siguiente a su archivo de declaraciones personalizadas.

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

Verifique la aplicación de ejemplo proporcionada para un ejemplo de trabajo.

Usando React Native> = 0.60

Ya no se requiere vincular el paquete manualmente con la autoletina.

Plataforma iOS:
$ cd ios && pod install && cd .. # Cocoapods en iOS necesita este paso adicional
Plataforma Android:
Modifique su configuración android/build.gradle para que coincida con minSdkVersion = 21 :
```
 buildscript {
  ext {
    ...
    minSdkVersion = 21
    ...
  }
```

SSL autofirmado (solo disponible para React Native> 0.60)

Para generar los archivos requeridos (claves y certificados) para SSL autofirmado, puede usar el siguiente comando:

 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

Nota: el server-keystore.p12 no debe tener una contraseña.

Necesitará un archivo metro.config.js para usar un certificado SSL autofirmado. Ya debería tener este archivo en su directorio de proyectos raíz, pero si no lo hace, cree. Dentro de un objeto module.exports , cree una clave llamada resolver con otro objeto llamado assetExts . El valor de assetExts debe ser una matriz de las extensiones de archivos de recursos que desea admitir.

Si desea poder usar archivos .pem y .p12 (más todos los archivos ya compatibles), su metro.config.js debería verse así:

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

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

Usando React Native <0.60

Luego debe vincular las partes nativas de la biblioteca para las plataformas que está utilizando. La forma más fácil de vincular la biblioteca es usar la herramienta CLI ejecutando este comando desde la raíz de su proyecto:

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

Si no puede o no desea usar la herramienta CLI, también puede vincular manualmente la biblioteca utilizando las instrucciones a continuación (haga clic en la flecha para mostrarlos):

Vincula manualmente la biblioteca en iOS

En Xcode, en el navegador del proyecto, haga clic derecho en Libraries Add Files to [your project's name]
Vaya a node_modules react-native-tcp-socket y agregue TcpSockets.xcodeproj
En Xcode, en el Proyecto Navegador, seleccione su proyecto. Agregue libTcpSockets.a al binario de enlace Build Phases de su proyecto Link Binary With Libraries
Ejecute su proyecto ( Cmd+R ) <

Vincula manualmente la biblioteca en Android

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

Agregar import com.asterinet.react.tcpsocket.TcpSocketPackage; a las importaciones en la parte superior del archivo
Agregue new TcpSocketPackage() a la lista devuelta por el método getPackages()

Agregue las siguientes líneas a 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')

Inserte las siguientes líneas dentro del bloque de dependencias en android/app/build.gradle :
```
  implementation project(':react-native-tcp-socket')
```

Reaccionar la compatibilidad nativa

Para usar esta biblioteca, debe asegurarse de estar utilizando la versión correcta de React Native. Si está utilizando una versión de React Native que es inferior a 0.60 , deberá actualizar antes de intentar usar la última versión.

versión `react-native-tcp-socket`	Requerir la versión nativa react
`6.XX` , `5.XX` , `4.XX` , `3.XX`	`>= 0.60.0`
`1.4.0`	`>= Unknown`

Uso

Importar la biblioteca:

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

Ejemplo del cliente

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

Ejemplo del servidor

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

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

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

Nota: Para usar certificados autofirmados, asegúrese de actualizar su configuración metro.config.js.

API

neto

Aquí se enumeran todos los métodos implementados en react-native-tcp-socket que imitan la API neta del nodo, sus funcionalidades son equivalentes a las proporcionadas por la red de Node (más información sobre el #41). Sin embargo, los métodos cuya interfaz difiere del nodo se marcan en negrita .

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

Enchufe

Métodos:
- address()
- destroy([error])
- end([data][, encoding][, callback])
- setEncoding([encoding])
- setKeepAlive([enable][, initialDelay]) - initialDelay se ignora
- setNoDelay([noDelay])
- setTimeout(timeout[, callback])
- write(data[, encoding][, callback])
- pause()
- ref() - no tendrá ningún efecto
- resume()
- unref() - no tendrá ningún efecto
Propiedades:
- Heredado de Stream.Writable .
  - writableNeedDrain
- bytesRead
- bytesWritten
- connecting
- destroyed
- localAddress
- localPort
- remoteAddress
- remoteFamily
- remotePort
- pending
- timeout
- readyState
Eventos:
- Heredado de Stream.Readable :
  - 'pause'
  - 'resume'
- 'close'
- 'connect'
- 'data'
- 'drain'
- 'error'
- 'timeout'

`net.createConnection()`

net.createConnection(options[, callback]) crea una conexión TCP utilizando las options dadas. El parámetro options debe ser un object con las siguientes propiedades:

Propiedad	Tipo	Descripción
`port`	`<number>`	Requerido . Puerte el enchufe debe conectarse.
`host`	`<string>`	Host que debe conectarse el enchufe. Dirección IP en formato IPv4 o `'localhost'` . Valor predeterminado : `'localhost'` .
`localAddress`	`<string>`	Dirección local El enchufe debe conectarse. Si no se especifica, el sistema operativo decidirá. Se recomienda especificar un `localAddress` para evitar errores de sobrecarga y mejorar el rendimiento.
`localPort`	`<number>`	Puerto local desde el que debe conectarse. Si no se especifica, el sistema operativo decidirá.
`interface`	`<string>`	Interfaz desde la que debe conectarse el socket. Si no se especifica, usará la conexión activa actual. Las opciones son: `'wifi', 'ethernet', 'cellular'` .
`reuseAddress`	`<boolean>`	Habilitar/deshabilitar la opción ReUSeaddress Socket. Valor predeterminado : `true` .

Nota : Las plataformas marcadas como usan el valor predeterminado.

Servidor

Métodos:
- address()
- listen(options[, callback])
- close([callback])
- getConnections(callback)
Propiedades:
- listening
Eventos:
- 'close'
- 'connection'
- 'error'
- 'listening'

`Server.listen()`

Server.listen(options[, callback]) crea un socket de servidor TCP utilizando las options dadas. El parámetro options debe ser un object con las siguientes propiedades:

Propiedad	Tipo	Descripción
`port`	`<number>`	Requerido . Puerte el enchufe debe escuchar.
`host`	`<string>`	Organizar el enchufe debe escuchar. Dirección IP en formato IPv4 o `'localhost'` . Valor predeterminado : `'0.0.0.0'` .
`reuseAddress`	`<boolean>`	Habilitar/deshabilitar la opción ReUSeaddress Socket. Valor predeterminado : `true` .

Nota : Las plataformas marcadas como usan el valor predeterminado.

TLS

Aquí se enumeran todos los métodos implementados en react-native-tcp-socket que imitan la API TLS del nodo, sus funcionalidades son equivalentes a las proporcionadas por el TLS de Node. Sin embargo, los métodos cuya interfaz difiere del nodo se marcan en negrita .

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

Tlssocket

Métodos:
- Todos los métodos de Socket
- getCertificate() Android solamente
- getPeerCertificate() Android solamente
Propiedades:
- Todas las propiedades de Socket
Eventos:
- Todos los eventos de Socket
- 'secureConnect'

`tls.connectTLS()`

tls.connectTLS(options[, callback]) crea una conexión de socket TLS utilizando las options dadas. El parámetro options debe ser un object con las siguientes propiedades:

Propiedad	Tipo	Descripción
`ca`	`<import>`	Archivo CA (formato .pem) para confiar. Si es `null` , utilizará la lista de confianza SSL predeterminada del dispositivo. Útil para certificados autofirmados. Consulte la documentación para generar dicho archivo . Valor predeterminado : `null` .
`key`	`<import>`	Archivo de clave privada (formato .pem). Consulte la documentación para generar dicho archivo .
`cert`	`<import>`	Archivo de certificado público (formato .pem). Consulte la documentación para generar dicho archivo .
`androidKeyStore`	`<string>`	Alias de la tienda de claves Android.
`certAlias`	`<string>`	Alias de certificado de almacén de claves de Android.
`keyAlias`	`<string>`	Alias de teclas privadas de Android Keystore.
`...`	`<any>`	Cualquier otra opción `socket.connect()` ya no está en la lista.

TlsServer

Nota : El servidor TLS se llama Server en el TLS de Node, pero se llama TLSServer en react-native-tcp-socket para evitar confusiones con la clase Server .

Métodos:
- Todos los métodos del Server
- setSecureContext(options)
Propiedades:
- Todas las propiedades del Server
Eventos:
- Todos los eventos del Server
- 'secureConnection'

`tls.createTLSServer()`

tls.createTLSServer([options][, secureConnectionListener]) crea un nuevo tls.TLSServer . secureConnectionListener , si se proporciona, se establece automáticamente como un oyente para el evento 'secureConnection' . El parámetro options debe ser un object con las siguientes propiedades:

Propiedad	Tipo	iOS/macOS	Androide	Descripción
`keystore`	`<import>`			Requerido . Tienda clave en formato PKCS#12 con el certificado del servidor y la clave privada. Consulte la documentación para generar dicho archivo .

Mantenedores

Rapssito

Expresiones de gratitud

La parte de iOS originalmente bifurcaba de @aprock react-native-tcp
React-Native-UDP

Licencia

La biblioteca se lanza bajo la licencia MIT. Para más información, consulte LICENSE .

Expandir

react native tcp socket