Komunikacja sieciowa

Aplikacje Chrome mogą działać jako klient sieci dla połączeń TCP i UDP. Z tego dokumentu dowiesz się, jak korzystać TCP i UDP do wysyłania i odbierania danych przez sieć. Więcej informacji znajdziesz w artykule Sockets (Gniazda) Interfejsy API UDP, Socket TCP i Socket TCP Server.

Wymagania dotyczące pliku manifestu

W przypadku aplikacji Chrome, które używają TCP lub UDP, dodaj wpis sockets do pliku manifestu i podaj adres IP. reguły uprawnień do punktu końcowego. Na przykład:

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

Składnia gniazda „host-pattern” wpisy są zgodne z tymi regułami:

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

Szczegółowy opis składni znajdziesz w sekcji Klucz pliku manifestu Sockets.

Przykłady wpisów manifestu gniazda:

• { "tcp": { "connect" : "*:23" } } – łączenie przez port 23 dowolnego hosta
• { "tcp": { "connect" : ["*:23", "*:80"] } } – łączenie przez port 23 lub 80 dowolnego hosta
• { "tcp": { "connect" : "www.example.com:23" } } – port 23 w domenie www.example.com
• { "tcp": { "connect" : "" } } – połączenie dowolnych portów dowolnego hosta
• { "udp": { "send" : ":99" } } – wysyłanie pakietu UDP na port 99 dowolnego hosta
• { "udp": { "bind" : ":8899" } } – powiązanie lokalnego portu 8899 do odbierania pakietów UDP
• { "tcpServer": { "listen" : ":8080" } } – nasłuchiwanie TCP na lokalnym porcie 8080

Korzystanie z TCP

Aplikacje Chrome mogą nawiązywać połączenia z dowolną usługą obsługującą TCP.

Podłączanie gniazdka

Oto przykład połączenia (sockets.tcp.connect) z gniazdem:

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

Zachowaj nick dla: socketId, aby móc później odbierać i wysyłać dane (sockets.tcp.send) do tego gniazda.

Odbieranie i wysyłanie z gniazda

Odbieranie z (sockets.tcp.onReceive) i wysyłanie do gniazda korzysta z obiektów ArrayBuffer. Do dowiedz się więcej o SlateBuffer, zapoznaj się z jego omówieniem, tablicami JavaScript z kodem JavaScript i samouczkiem, Jak konwertować obiekt ArrayBuffer na i z ciągu znaków

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

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

Odłączanie od gniazdka

Aby odłączyć konto (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

Używanie protokołu UDP

Aplikacje Chrome mogą nawiązywać połączenia z dowolną usługą obsługującą UDP.

Wysyłam dane

Oto przykład wysyłania danych (sockets.udp.send) przez sieć przy użyciu 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);
  });
});

Odbieram dane

Ten przykład jest bardzo podobny do ustawienia „Wysyłanie danych” Jedyna różnica polega na tym, że dla instrukcji obsługi zdarzeń do odbierania danych.

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

Korzystanie z serwera TCP

Aplikacje Chrome mogą działać jako serwery TCP przy użyciu interfejsu API sockets.tcpServer.

Tworzenie gniazda serwera TCP

Utwórz gniazdo serwera TCP za pomocą polecenia sockets.tcpServer.create.

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

Akceptowanie połączeń z klientem

Oto przykład akceptowania połączeń (sockets.tcpServer.listen) na serwerze TCP gniazdo:

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

Zachowaj nick dla socketId, aby móc później zaakceptować nowe połączenia (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)
}

Po ustanowieniu nowego połączenia usługa onAccept jest wywoływana z parametrem clientSocketId nowego protokołu TCP. połączenia. Identyfikator gniazda klienta musi być używany z interfejsem API sockets.tcp. Nowe gniazdko połączenie jest domyślnie wstrzymane. Cofnij wstrzymanie przy użyciu polecenia sockets.tcp.setPaused, aby zacząć odbierać i skalowalnych danych.

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

Przestań akceptować połączenia z klientami

Wywołaj polecenie sockets.tcp.disconnect dla identyfikatora gniazda serwera, aby przestać akceptować nowe połączenia.

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