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

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

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

टीसीपी या यूडीपी का इस्तेमाल करने वाले 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>)

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

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

• { "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 ऑब्जेक्ट का इस्तेमाल किया जाता है. arrayBuffers के बारे में जानने के लिए, खास जानकारी, JavaScript की मदद से टाइप की गई कैटगरी, और ट्यूटोरियल देखें. इसके अलावा, अरे को स्ट्रिंग से स्ट्रिंग में बदलने का तरीका लेख भी पढ़ें.

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

यूडीपी का इस्तेमाल करना

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