This page is part of the documentation for the Chrome Apps platform, which was deprecated in 2020. It remains supported for Enterprise and Education customers on ChromeOS until at least Jan 2025. Learn more about migrating your app.

Deze pagina is vertaald door de Cloud Translation API.

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

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