Netwerkcommunicatie

Chrome Apps kunnen fungeren als netwerkclient voor TCP- en UDP-verbindingen. In dit document ziet u hoe u TCP en UDP kunt gebruiken om gegevens via het netwerk te verzenden en te ontvangen. Zie de API's Sockets UDP , Sockets TCP en Sockets TCP Server voor meer informatie.

Duidelijke eisen

Voor Chrome-apps die TCP of UDP gebruiken, voegt u de sockets- vermelding toe aan het manifest en geeft u de toestemmingsregels voor het IP-eindpunt op. Bijvoorbeeld:

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

De syntaxis van socket "host-pattern" -items volgt deze regels:

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

Zie Sockets Manifest Key voor een gedetailleerde beschrijving van de syntaxis.

Voorbeelden van socketmanifestvermeldingen:

  • { "tcp": { "connect" : "*:23" } } –verbinden op poort 23 van een willekeurige host
  • { "tcp": { "connect" : ["*:23", "*:80"] } } –verbinden op poort 23 of 80 van een willekeurige host
  • { "tcp": { "connect" : "www.example.com:23" } } –poort 23 van www.example.com verbinden
  • { "tcp": { "connect" : "" } } – alle poorten van alle hosts aansluiten
  • { "udp": { "send" : ":99" } } – UDP-pakket verzenden naar poort 99 van een willekeurige host
  • { "udp": { "bind" : ":8899" } } – lokale poort 8899 binden om UDP-pakketten te ontvangen
  • { "tcpServer": { "listen" : ":8080" } } –TCP luistert op lokale poort 8080

TCP gebruiken

Chrome-apps kunnen verbindingen maken met elke service die TCP ondersteunt.

Aansluiten op een stopcontact

Hier is een voorbeeld dat laat zien hoe u verbinding maakt ( sockets.tcp.connect ) met een socket:

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

Houd een handvat bij de socketId zodat u later gegevens ( sockets.tcp.send ) naar deze socket kunt ontvangen en verzenden.

Ontvangen van en verzenden naar een stopcontact

Bij het ontvangen van ( sockets.tcp.onReceive ) en het verzenden naar een socket worden ArrayBuffer-objecten gebruikt. Voor meer informatie over ArrayBuffers kunt u het overzicht, JavaScript-getypeerde arrays en de tutorial Hoe ArrayBuffer van en naar String converteren bekijken.

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

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

Loskoppelen van een stopcontact

Zo kunt u de verbinding verbreken ( sockets.tcp.disconnect ):

chrome.sockets.tcp.disconnect(socketId);

UDP gebruiken

Chrome-apps kunnen verbindingen maken met elke service die UDP ondersteunt.

Gegevens verzenden

Hier is een voorbeeld dat laat zien hoe u gegevens ( sockets.udp.send ) via het netwerk kunt verzenden met behulp van 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);
  });
});

Gegevens ontvangen

Dit voorbeeld lijkt erg op het voorbeeld 'Gegevens verzenden', behalve dat we een gebeurtenishandler hebben ingesteld voor het ontvangen van gegevens.

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

TCP-server gebruiken

Chrome-apps kunnen fungeren als TCP-servers met behulp van de sockets.tcpServer API.

Een TCP-serversocket maken

Maak een TCP-serversocket met sockets.tcpServer.create .

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

Clientverbindingen accepteren

Hier is een voorbeeld dat laat zien hoe u verbindingen ( sockets.tcpServer.listen ) op een TCP-serversocket kunt accepteren: 

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

Bewaar een handle voor de socketId zodat u later nieuwe verbindingen kunt accepteren ( 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)
}

Wanneer een nieuwe verbinding tot stand wordt gebracht, wordt onAccept aangeroepen met de clientSocketId van de nieuwe TCP-verbinding. De client-socket-ID moet worden gebruikt met de sockets.tcp API. De socket van de nieuwe verbinding wordt standaard gepauzeerd. Onderbreek het programma met sockets.tcp.setPaused om het ontvangen van gegevens te starten. 

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

Stop met het accepteren van clientverbindingen

Roep sockets.tcp.disconnect aan op de server-socket-ID om te stoppen met het accepteren van nieuwe verbindingen. 

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