Comunicaciones de red

Las Apps de Chrome pueden actuar como cliente de red para conexiones TCP y UDP. En este documento, se muestra cómo usar TCP y UDP para enviar y recibir datos a través de la red Para obtener más información, consulta la documentación de Sockets APIs de UDP, Sockets TCP y Sockets TCP Server.

Requisitos del manifiesto

Para las Apps de Chrome que usan TCP o UDP, agrega la entrada sockets al manifiesto y especifica la IP. reglas de permisos de extremos. Por ejemplo:

"sockets": {
    "udp": {
      "send": ["host-pattern1", ...],
      "bind": ["host-pattern2", ...],
      ...
    },
    "tcp" : {
      "connect": ["host-pattern1", ...],
      ...
    },
    "tcpServer" : {
      "listen": ["host-pattern1", ...],
      ...
    }
  }

La sintaxis del socket “host-pattern” entradas de video sigue estas reglas:

<host-pattern> := <host> | ':' <port> | <host> ':' <port>
<host> := '*' | '*.' <anychar except '/' and '*'>+
<port> := '*' | <port number between 1 and 65535>)

Consulta Clave de manifiesto de sockets para obtener una descripción detallada de la sintaxis.

Ejemplos de entradas de manifiesto de socket:

  • { "tcp": { "connect" : "*:23" } }: conexión en el puerto 23 de cualquier host
  • { "tcp": { "connect" : ["*:23", "*:80"] } }: conexión en el puerto 23 u 80 de cualquier host
  • { "tcp": { "connect" : "www.example.com:23" } }: puerto de conexión 23 de www.example.com
  • { "tcp": { "connect" : "" } }: conexión de cualquier puerto de cualquier host
  • { "udp": { "send" : ":99" } } envía el paquete UDP al puerto 99 de cualquier host
  • { "udp": { "bind" : ":8899" } }: vincula el puerto local 8899 para recibir paquetes UDP
  • { "tcpServer": { "listen" : ":8080" } }: TCP escucha en el puerto local 8080

Usa TCP

Las Apps de Chrome pueden realizar conexiones a cualquier servicio que admita TCP.

Conexión a un tomacorriente

A continuación, se muestra un ejemplo de cómo conectar (sockets.tcp.connect) a un socket:

chrome.sockets.tcp.create({}, function(createInfo) {
  chrome.sockets.tcp.connect(createInfo.socketId,
    IP, PORT, onConnectedCallback);
});

Mantén un identificador para socketId de modo que más adelante puedas recibir y enviar datos (sockets.tcp.send) para este socket.

Recibe y envía a un socket

La recepción de (sockets.tcp.onReceive) y el envío a un socket usa objetos ArrayBuffer. Para para obtener más información sobre ArrayBuffers, consulta la descripción general, los arrays escritos en JavaScript y el instructivo. Cómo convertir ArrayBuffer en y desde String.

chrome.sockets.tcp.send(socketId, arrayBuffer, onSentCallback);

chrome.sockets.tcp.onReceive.addListener(function(info) {
  if (info.socketId != socketId)
    return;
  // info.data is an arrayBuffer.
});

Desconectarse de un enchufe

A continuación, te indicamos cómo desconectarlo (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

Usa UDP

Las Apps de Chrome pueden realizar conexiones a cualquier servicio que admita UDP.

Enviando datos

En el siguiente ejemplo, se muestra cómo enviar datos (sockets.udp.send) a través de la red mediante UDP:

// Create the Socket
chrome.sockets.udp.create({}, function(socketInfo) {
  // The socket is created, now we can send some data
  var socketId = socketInfo.socketId;
  chrome.sockets.udp.send(socketId, arrayBuffer,
    '127.0.0.1', 1337, function(sendInfo) {
      console.log("sent " + sendInfo.bytesSent);
  });
});

Recibir datos

Este ejemplo es muy similar al caso de “Cómo enviar datos” ejemplo, excepto que configuramos un controlador de eventos para la recepción de datos.

var socketId;

// Handle the "onReceive" event.
var onReceive = function(info) {
  if (info.socketId !== socketId)
    return;
  console.log(info.data);
};

// Create the Socket
chrome.sockets.udp.create({}, function(socketInfo) {
  socketId = socketInfo.socketId;
  // Setup event handler and bind socket.
  chrome.sockets.udp.onReceive.addListener(onReceive);
  chrome.sockets.udp.bind(socketId,
    "0.0.0.0", 0, function(result) {
      if (result < 0) {
        console.log("Error binding socket.");
        return;
      }
      chrome.sockets.udp.send(socketId, arrayBuffer,
        '127.0.0.1', 1337, function(sendInfo) {
          console.log("sent " + sendInfo.bytesSent);
      });
  });
});

Usa el servidor TCP

Las Apps de Chrome pueden actuar como servidores TCP con la API sockets.tcpServer.

Crea un socket de servidor TCP

Crea un socket de servidor TCP con sockets.tcpServer.create.

chrome.sockets.tcpServer.create({}, function(createInfo) {
  listenAndAccept(createInfo.socketId);
});

Acepta conexiones de clientes

En el siguiente ejemplo, se muestra cómo aceptar conexiones (sockets.tcpServer.listen) en un servidor TCP socket:

function listenAndAccept(socketId) {
  chrome.sockets.tcpServer.listen(socketId,
    IP, PORT, function(resultCode) {
      onListenCallback(socketId, resultCode)
  });
}

Controla el socketId para que luego puedas aceptar nuevas conexiones (sockets.tcpServer.onAccept) .

var serverSocketId;
function onListenCallback(socketId, resultCode) {
  if (resultCode < 0) {
    console.log("Error listening:" +
      chrome.runtime.lastError.message);
    return;
  }
  serverSocketId = socketId;
  chrome.sockets.tcpServer.onAccept.addListener(onAccept)
}

Cuando se establece una conexión nueva, se invoca onAccept con el clientSocketId del TCP nuevo. conexión. El ID de socket de cliente se debe usar con la API de sockets.tcp. El socket del nuevo conexión está pausada de forma predeterminada. Reanúdalo con sockets.tcp.setPaused para comenzar de datos no estructurados.

function onAccept(info) {
  if (info.socketId != serverSocketId)
    return;

  // A new TCP connection has been established.
  chrome.sockets.tcp.send(info.clientSocketId, data,
    function(resultCode) {
      console.log("Data sent to new TCP client connection.")
  });
  // Start receiving data.
  chrome.sockets.tcp.onReceive.addListener(function(recvInfo) {
    if (recvInfo.socketId != info.clientSocketId)
      return;
    // recvInfo.data is an arrayBuffer.
  });
  chrome.sockets.tcp.setPaused(false);
}

Deja de aceptar conexiones de clientes

Llama a sockets.tcp.disconnect en el ID de socket de servidor para dejar de aceptar conexiones nuevas.

chrome.sockets.tcpServer.onAccept.removeListener(onAccept);
chrome.sockets.tcpServer.disconnect(serverSocketId);