Comunicazioni di rete

Le app di Chrome possono fungere da client di rete per le connessioni TCP e UDP. Questo documento illustra come utilizzare TCP e UDP per inviare e ricevere dati sulla rete. Per ulteriori informazioni, consulta la sezione Socket API UDP, TCP e Server TCP Sockets.

Requisiti dei file manifest

Per le app di Chrome che utilizzano TCP o UDP, aggiungi la voce sockets al manifest e specifica l'IP regole di autorizzazione dell'endpoint. Ad esempio:

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

La sintassi del socket "host-pattern" le voci seguono queste regole:

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

Per una descrizione dettagliata della sintassi, consulta Chiave manifest socket.

Esempi di voci manifest socket:

• { "tcp": { "connect" : "*:23" } }: connessione sulla porta 23 di qualsiasi host
• { "tcp": { "connect" : ["*:23", "*:80"] } }: connessione sulla porta 23 o 80 di qualsiasi host
• { "tcp": { "connect" : "www.example.com:23" } }: porta 23 di www.example.com
• { "tcp": { "connect" : "" } }: collegamento delle porte di qualsiasi host
• { "udp": { "send" : ":99" } }: invio di pacchetto UDP alla porta 99 di qualsiasi host
• { "udp": { "bind" : ":8899" } }: associazione della porta locale 8899 per ricevere pacchetti UDP
• { "tcpServer": { "listen" : ":8080" } }: TCP in ascolto sulla porta locale 8080

Utilizzo di TCP

Le app di Chrome possono stabilire connessioni a qualsiasi servizio che supporti TCP.

Collegamento a una presa

Ecco un esempio che mostra come connettersi (sockets.tcp.connect) a un socket:

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

Mantieni un handle a socketId per poter ricevere e inviare dati in un secondo momento (sockets.tcp.send) a questo socket.

Ricezione e invio su un socket

La ricezione da (sockets.tcp.onReceive) e l'invio a un socket utilizzano gli oggetti Arraybu. A scopri di più su ArrayBuffers, dai un'occhiata alla panoramica, agli array di caratteri JavaScript e al tutorial Come convertire Arraybu in e da una stringa.

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

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

Disconnettersi da una presa

Ecco come disconnettere (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

Utilizzo di UDP

Le app di Chrome possono stabilire connessioni a qualsiasi servizio che supporta UDP.

Invio di dati in corso...

Ecco un esempio che mostra come inviare dati (sockets.udp.send) sulla rete utilizzando 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);
  });
});

Ricezione di dati

Questo esempio è molto simile a "Invio dei dati in corso" Ad esempio, abbiamo configurato un gestore di eventi che ricevono dati.

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

Utilizzo del server TCP

Le app di Chrome possono fungere da server TCP utilizzando l'API sockets.tcpServer.

Creazione di un socket del server TCP

Crea un socket del server TCP con sockets.tcpServer.create.

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

Accettazione delle connessioni client in corso

Ecco un esempio che mostra come accettare connessioni (sockets.tcpServer.listen) su un server TCP socket:

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

Mantieni un handle per socketId per poter accettare nuove connessioni in un secondo momento (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)
}

Quando viene stabilita una nuova connessione, onAccept viene richiamato con il clientSocketId del nuovo TCP connessione. L'ID socket client deve essere utilizzato con l'API sockets.tcp. La presa del nuovo la connessione è in pausa per impostazione predefinita. Riattivalo con sockets.tcp.setPaused per iniziare a ricevere e i dati di Google Cloud.

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

Interrompi l'accettazione di connessioni client

Chiama sockets.tcp.disconnect sull'ID socket del server per interrompere l'accettazione di nuove connessioni.

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