Komunikasi Jaringan

Aplikasi Chrome dapat berfungsi sebagai klien jaringan untuk koneksi TCP dan UDP. Dokumen ini menunjukkan cara menggunakan TCP dan UDP untuk mengirim dan menerima data melalui jaringan. Untuk informasi selengkapnya, lihat Soket UDP, Sockets TCP, dan Sockets TCP Server API.

Persyaratan manifes

Untuk Aplikasi Chrome yang menggunakan TCP atau UDP, tambahkan entri sockets ke manifes dan tentukan IP aturan izin akses endpoint. Contoh:

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

Sintaks soket "host-pattern" entri mengikuti aturan berikut:

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

Lihat Kunci Manifes Soket untuk mengetahui deskripsi mendetail tentang sintaksis.

Contoh entri manifes soket:

  • { "tcp": { "connect" : "*:23" } }–terhubung di port 23 dari host mana pun
  • { "tcp": { "connect" : ["*:23", "*:80"] } }–terhubung di port 23 atau 80 host apa pun
  • { "tcp": { "connect" : "www.example.com:23" } }–porta penghubung 23 dari www.example.com
  • { "tcp": { "connect" : "" } }–menghubungkan port mana pun dari host mana pun
  • { "udp": { "send" : ":99" } }–mengirim paket UDP ke port 99 dari host apa pun
  • { "udp": { "bind" : ":8899" } }–mengikat port lokal 8899 untuk menerima paket UDP
  • { "tcpServer": { "listen" : ":8080" } }–TCP memproses port lokal 8080

Menggunakan TCP

Aplikasi Chrome dapat membuat koneksi ke layanan apa pun yang mendukung TCP.

Menyambungkan ke soket

Berikut adalah contoh yang menunjukkan cara menghubungkan (sockets.tcp.connect) ke sebuah soket:

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

Simpan nama sebutan channel di socketId agar Anda nantinya dapat menerima dan mengirim data (sockets.tcp.send) ke soket ini.

Menerima dari dan mengirim ke soket

Menerima dari (sockets.tcp.onReceive) dan mengirim ke soket menggunakan objek ArrayBuffer. Kepada pelajari tentang ArrayBuffer, lihat ringkasan, array berjenis JavaScript, dan tutorial, Cara mengonversi ArrayBuffer ke dan dari 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.
});

Memutuskan sambungan dari soket

Berikut ini cara memutuskan koneksi (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

Menggunakan UDP

Aplikasi Chrome dapat membuat koneksi ke layanan apa pun yang mendukung UDP.

Mengirim data

Berikut ini contoh yang menunjukkan cara mengirim data (sockets.udp.send) melalui jaringan menggunakan 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);
  });
});

Menerima data

Contoh ini sangat mirip dengan proses 'Mengirim data' Misalnya, kita menyiapkan sebuah pengendali peristiwa untuk menerima data.

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

Menggunakan Server TCP

Aplikasi Chrome dapat bertindak sebagai server TCP menggunakan API sockets.tcpServer.

Membuat soket server TCP

Buat soket server TCP dengan sockets.tcpServer.create.

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

Menerima koneksi klien

Berikut adalah contoh yang menunjukkan cara menerima koneksi (sockets.tcpServer.listen) di server TCP soket:

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

Simpan nama sebutan channel socketId agar Anda dapat menerima koneksi baru nanti (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)
}

Saat koneksi baru dibuat, onAccept dipanggil dengan clientSocketId dari TCP baru koneksi jarak jauh. ID soket klien harus digunakan dengan API sockets.tcp. Soket dari akan dijeda secara default. Batalkan jeda dengan sockets.tcp.setPaused untuk mulai menerima layanan otomatis dan data skalabel.

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

Berhenti menerima koneksi klien

Panggil sockets.tcp.disconnect pada ID soket server untuk berhenti menerima koneksi baru.

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