Netzwerkkommunikation

Chrome-Apps können als Netzwerkclient für TCP- und UDP-Verbindungen fungieren. In diesem Dokument erfahren Sie, wie Sie TCP und UDP zum Senden und Empfangen von Daten über das Netzwerk Weitere Informationen finden Sie im Abschnitt zu Sockets UDP, Sockets TCP und Sockets TCP Server APIs

Manifestanforderungen

Fügen Sie für Chrome-Apps, die TCP oder UDP verwenden, dem Manifest den Eintrag Sockets hinzu und geben Sie die IP-Adresse an. Berechtigungen für Endpunktberechtigungen. Beispiel:

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

Die Syntax von Socket "host-pattern" folgenden Regeln:

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

Eine ausführliche Beschreibung der Syntax finden Sie unter Socket-Manifestschlüssel.

Beispiele für Socket-Manifesteinträge:

• { "tcp": { "connect" : "*:23" } }: Verbindung über Port 23 eines beliebigen Hosts
• { "tcp": { "connect" : ["*:23", "*:80"] } }: Verbindung über Port 23 oder 80 eines beliebigen Hosts
• { "tcp": { "connect" : "www.example.com:23" } }: Verbindung mit Port 23 von www.example.com
• { "tcp": { "connect" : "" } }: Verbindung aller Ports von beliebigen Hosts
• { "udp": { "send" : ":99" } }: UDP-Paket wird an Port 99 aller Hosts gesendet
• { "udp": { "bind" : ":8899" } }: Bindung des lokalen Ports 8899 für den Empfang von UDP-Paketen
• { "tcpServer": { "listen" : ":8080" } }: TCP, der den lokalen Port 8080 überwacht

TCP verwenden

Chrome-Apps können Verbindungen zu jedem Dienst herstellen, der TCP unterstützt.

Verbindung zu einer Steckdose herstellen

Im folgenden Beispiel wird gezeigt, wie Sie (sockets.tcp.connect) mit einem Socket verbinden:

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

Handle für socketId beibehalten, damit du später Daten empfangen und senden kannst (sockets.tcp.send) zu diesem Socket.

Von einem Socket empfangen und an diesen senden

Für den Empfang von (sockets.tcp.onReceive) und das Senden an einen Socket werden ArrayBuffer-Objekte verwendet. Bis Mehr über ArrayBuffers erfahren Sie in der Übersicht, zu JavaScript-typisierten Arrays und im Tutorial. So konvertieren Sie ArrayBuffer in einen String und aus diesem 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.
});

Von einer Steckdose trennen

So trennen Sie die Verbindung (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

UDP verwenden

Chrome-Apps können Verbindungen zu jedem Dienst herstellen, der UDP unterstützt.

Daten werden gesendet

Das folgende Beispiel zeigt, wie Daten (sockets.udp.send) mit UDP über das Netzwerk gesendet werden:

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

Daten werden empfangen

Dieses Beispiel ist dem Feld „Daten senden“ Wir richten jedoch einen Event-Handler für Empfang von Daten.

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 verwenden

Chrome-Apps können mithilfe der API sockets.tcpServer als TCP-Server fungieren.

TCP-Server-Socket erstellen

Erstellen Sie einen TCP-Server-Socket mit sockets.tcpServer.create.

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

Clientverbindungen akzeptieren

Hier ist ein Beispiel, das zeigt, wie Verbindungen (sockets.tcpServer.listen) auf einem TCP-Server akzeptiert werden Socket:

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

Behalte einen Handle für den socketId, damit du später neue Verbindungen annehmen kannst (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)
}

Wenn eine neue Verbindung hergestellt wird, wird onAccept mit dem clientSocketId des neuen TCP aufgerufen. Die Client-Socket-ID muss mit der API sockets.tcp verwendet werden. Der Socket des neuen Verbindung ist standardmäßig pausiert. Heben Sie die Pausierung mit sockets.tcp.setPaused auf, um den Empfang zu empfangen. Daten.

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

Keine Clientverbindungen mehr annehmen

Rufen Sie sockets.tcp.disconnect für die Server-Socket-ID auf, um keine neuen Verbindungen mehr zu akzeptieren.

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