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 mengetahui informasi selengkapnya, lihat Socket UDP, Socket TCP, dan Sockets TCP Server API.

Persyaratan manifes

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

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

Sintaks entri "host-pattern" soket 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 deskripsi mendetail tentang sintaksis.

Contoh entri manifes soket:

• { "tcp": { "connect" : "*:23" } }–menghubungkan pada port 23 dari host apa pun
• { "tcp": { "connect" : ["*:23", "*:80"] } }–menghubungkan pada port 23 atau 80 dari host apa pun
• { "tcp": { "connect" : "www.example.com:23" } }–menghubungkan port 23 dari www.example.com
• { "tcp": { "connect" : "" } }–menghubungkan port dari host apa 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 yang memproses di port lokal 8080

Menggunakan TCP

Aplikasi Chrome dapat terhubung ke layanan apa pun yang mendukung TCP.

Menghubungkan ke soket

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

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

Simpan handle ke socketId sehingga nantinya Anda 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. Untuk mempelajari ArrayBuffers, lihat ringkasan, array berjenis JavaScript, serta 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 cara memutuskan koneksi (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

Menggunakan UDP

Aplikasi Chrome dapat terhubung ke layanan apa pun yang mendukung UDP.

Mengirim data

Berikut adalah 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 contoh 'Mengirim data', kecuali kami menyiapkan 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 sockets.tcpServer API.

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 soket server TCP:

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

Pertahankan handle ke socketId sehingga Anda dapat menerima koneksi baru (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 koneksi TCP baru. ID soket klien harus digunakan dengan API sockets.tcp. Soket koneksi baru dijeda secara default. Lanjutkan dengan sockets.tcp.setPaused untuk mulai menerima data.

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