नेटवर्क कम्यूनिकेशन

Chrome ऐप्स टीसीपी और यूडीपी कनेक्शन के लिए नेटवर्क क्लाइंट के तौर पर काम कर सकते हैं. इस दस्तावेज़ में, नेटवर्क पर डेटा भेजने और पाने के लिए टीसीपी और यूडीपी. ज़्यादा जानकारी के लिए, Sockets पर जाएं यूडीपी, Sockets टीसीपी, और Sockets टीसीपी सर्वर एपीआई.

मेनिफ़ेस्ट की ज़रूरी शर्तें

टीसीपी या यूडीपी का इस्तेमाल करने वाले Chrome ऐप्लिकेशन के लिए, मेनिफ़ेस्ट में सॉकेट एंट्री जोड़ें और आईपी की जानकारी दें एंड पॉइंट की अनुमति के नियम बनाएं. उदाहरण के लिए:

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

सॉकेट "होस्ट-पैटर्न" का सिंटैक्स एंट्री के लिए, इन नियमों का पालन किया जाता है:

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

सिंटैक्स की पूरी जानकारी के लिए, Sockets मेनिफ़ेस्ट कुंजी देखें.

सॉकेट मेनिफ़ेस्ट एंट्री के उदाहरण:

• { "tcp": { "connect" : "*:23" } }–किसी भी होस्ट के पोर्ट 23 पर कनेक्ट किया जा रहा है
• { "tcp": { "connect" : ["*:23", "*:80"] } }–किसी भी होस्ट के पोर्ट 23 या 80 पर कनेक्ट किया जा रहा है
• { "tcp": { "connect" : "www.example.com:23" } }–www.example.com के पोर्ट 23 को कनेक्ट करना
• { "tcp": { "connect" : "" } }–किसी भी होस्ट के किसी भी पोर्ट को कनेक्ट करना
• { "udp": { "send" : ":99" } }–किसी भी होस्ट के पोर्ट 99 पर यूडीपी पैकेट भेजा जा रहा है
• यूडीपी पैकेट पाने के लिए, { "udp": { "bind" : ":8899" } } लोकल पोर्ट 8899 ज़रूरी है
• { "tcpServer": { "listen" : ":8080" } }–टीसीपी, लोकल पोर्ट 8080 पर सुन रहा है

टीसीपी का इस्तेमाल करना

Chrome ऐप्स ऐसी किसी भी सेवा से कनेक्शन बना सकते हैं जो टीसीपी के साथ काम करती है.

सॉकेट से कनेक्ट हो रहा है

यहां एक सैंपल दिया गया है, जिसमें सॉकेट से कनेक्ट (sockets.tcp.connect) करने का तरीका बताया गया है:

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

socketId का हैंडल रखें, ताकि आप बाद में डेटा पा सकें और उसे भेज सकें (sockets.tcp.send) के तौर पर इस्तेमाल कर सकते हैं.

से प्राप्त कर रहा है और सॉकेट पर भेज रहा है

(sockets.tcp.onReceive) से मिलने और सॉकेट पर भेजने के लिए ArrayBuffer ऑब्जेक्ट का इस्तेमाल किया जाता है. यहां की यात्रा पर हूं अरेबफ़र के बारे में जानें, खास जानकारी, JavaScript के टाइप किए गए अरे, और ट्यूटोरियल देखें, ArrayBuffer को स्ट्रिंग में और उससे स्ट्रिंग में बदलने का तरीका.

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

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

सॉकेट से डिसकनेक्ट किया जा रहा है

डिसकनेक्ट करने का तरीका यहां बताया गया है (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

UDP का इस्तेमाल किया जा रहा है

Chrome ऐप्स ऐसी किसी भी सेवा से कनेक्शन बना सकते हैं जो यूडीपी के साथ काम करती है.

डेटा भेजा जा रहा है

यहां एक सैंपल दिया गया है, जिसमें यूडीपी का इस्तेमाल करके नेटवर्क पर डेटा (sockets.udp.send) भेजने का तरीका बताया गया है:

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

डेटा मिल रहा है

यह उदाहरण काफ़ी हद तक 'डेटा भेजना' से मिलता-जुलता है उदाहरण के लिए, हम सिर्फ़ डेटा मिलने के बाद.

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

टीसीपी सर्वर का इस्तेमाल करना

Chrome ऐप्स sockets.tcpServer एपीआई का इस्तेमाल करके, टीसीपी सर्वर के तौर पर काम कर सकते हैं.

टीसीपी सर्वर सॉकेट बनाना

sockets.tcpServer.create की मदद से, टीसीपी सर्वर सॉकेट बनाएं.

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

क्लाइंट कनेक्शन स्वीकार करना

यहां एक सैंपल दिया गया है, जिसमें टीसीपी सर्वर पर कनेक्शन (sockets.tcpServer.listen) स्वीकार करने का तरीका बताया गया है सॉकेट:

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

socketId का हैंडल रखें, ताकि आप बाद में नए कनेक्शन स्वीकार कर सकें (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)
}

नया कनेक्शन बनने पर, नए टीसीपी के clientSocketId से onAccept को शुरू किया जाता है कनेक्शन. क्लाइंट सॉकेट आईडी का इस्तेमाल, sockets.tcp एपीआई के साथ किया जाना चाहिए. नए की सॉकेट डिफ़ॉल्ट रूप से, कनेक्शन को रोक दिया जाता है. डेटा पाना शुरू करने के लिए, इसे sockets.tcp.setPaused से चालू करें डेटा शामिल है.

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

क्लाइंट कनेक्शन स्वीकार करना बंद करें

नए कनेक्शन स्वीकार करना बंद करने के लिए, सर्वर सॉकेट आईडी पर sockets.tcp.disconnect को कॉल करें.

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