👨‍👩‍👧‍👦 👩🏻‍🚒 🔘 IOS पर चैट करें: सॉकेट्स का उपयोग करना 🥡 🐰 ☦️

चित्र rawpixel.com द्वारा बनाया गया

इस प्रकाशन में, हम टीसीपी परत पर जाएंगे, चैट एप्लीकेशन विकसित करने के उदाहरण का उपयोग करके कोर फाउंडेशन के सॉकेट्स और टूल्स के बारे में जानें।

अनुमानित पढ़ने का समय: 25 मिनट।

सॉकेट क्यों?

आप सोच रहे होंगे: "मुझे URLSession से एक स्तर कम क्यों जाना चाहिए?" यदि आप काफी चतुर हैं और यह सवाल नहीं पूछते हैं, तो सीधे अगले अनुभाग पर जाएं।

इतना स्मार्ट नहीं होने का जवाब

बड़ा अच्छा सवाल! तथ्य यह है कि URLSession का उपयोग HTTP प्रोटोकॉल पर आधारित है, अर्थात्, संचार अनुरोध-प्रतिक्रिया की शैली में होता है, लगभग इस प्रकार है:

JSON प्रारूप में सर्वर से कुछ डेटा का अनुरोध
यह डेटा, प्रक्रिया, प्रदर्शन आदि प्राप्त करें।

लेकिन क्या होगा अगर हमें आपके एप्लिकेशन पर डेटा स्थानांतरित करने के लिए स्वयं की पहल पर एक सर्वर की आवश्यकता है? यहाँ HTTP काम से बाहर है।

बेशक, हम सर्वर को लगातार खींच सकते हैं और देख सकते हैं कि हमारे लिए डेटा है (उर्फ पोलिंग )। या हम अधिक परिष्कृत हो सकते हैं और लंबे मतदान का उपयोग कर सकते हैं । लेकिन इन सभी बैसाखी इस मामले में थोड़ा अनुचित हैं।

आखिरकार, अपने आप को अनुरोध-प्रतिक्रिया प्रतिमान तक सीमित क्यों करें यदि यह हमारे कार्य को कुछ भी नहीं से कम फिट बैठता है?

इस गाइड में, आप सीखेंगे कि एब्सट्रैक्शन के निचले स्तर पर कैसे जाएं और चैट एप्लिकेशन में सीधे सॉकेट का उपयोग करें।

नए संदेशों के लिए सर्वर की जांच करने के बजाय, हमारा एप्लिकेशन उन धाराओं का उपयोग करेगा जो चैट सत्र के दौरान खुली रहती हैं।

शुरुआत हो रही है

स्रोत सामग्री डाउनलोड करें। एक मॉक क्लाइंट एप्लिकेशन और गो में लिखा गया एक साधारण सर्वर है।

आपको गो में लिखने की ज़रूरत नहीं है, लेकिन आपको सर्वर एप्लिकेशन को चलाने की आवश्यकता होगी ताकि क्लाइंट एप्लिकेशन इससे जुड़ सकें।

सर्वर एप्लिकेशन लॉन्च करें

स्रोत सामग्री में संकलित अनुप्रयोग और स्रोत दोनों हैं। यदि आपके पास स्वस्थ व्यामोह है और किसी और के संकलित कोड पर भरोसा नहीं है, तो आप स्वयं स्रोत कोड संकलित कर सकते हैं।

यदि आप बहादुर हैं, तो टर्मिनल खोलें, डाउनलोड की गई सामग्री के साथ निर्देशिका में जाएं और कमांड चलाएं:

sudo ./server

संकेत दिए जाने पर, अपना पासवर्ड दर्ज करें। उसके बाद आपको एक संदेश देखना चाहिए

127.0.0.1:80 पर सुन रहे हैं।

नोट: सर्वर एप्लिकेशन विशेषाधिकार प्राप्त मोड ("sudo" कमांड) में शुरू होता है क्योंकि यह पोर्ट 80 पर सुनता है। 1024 से कम संख्या वाले सभी पोर्ट्स को विशेष पहुंच की आवश्यकता होती है।

आपका चैट सर्वर तैयार है! आप अगले भाग पर जा सकते हैं।

यदि आप सर्वर स्रोत कोड को स्वयं संकलित करना चाहते हैं,

फिर इस मामले में आपको होमब्रे का उपयोग करके गो स्थापित करना होगा।

यदि आपके पास Homebrew नहीं है, तो आपको पहले इसे स्थापित करने की आवश्यकता है। टर्मिनल खोलें और वहां निम्न पंक्ति चिपकाएँ:

/usr/bin/ruby -e \
"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

फिर Go को स्थापित करने के लिए इस कमांड का उपयोग करें:

brew install go

अंत में, डाउनलोड की गई स्रोत सामग्री के साथ निर्देशिका में जाएं और सर्वर एप्लिकेशन के स्रोत कोड को संकलित करें:

go build server.go

अंत में, आप इस खंड की शुरुआत में कमांड के साथ सर्वर शुरू कर सकते हैं।

हम ग्राहक में जो कुछ भी है उसे देखते हैं

अब DogeChat प्रोजेक्ट खोलें, इसे संकलित करें और देखें कि क्या है।

जैसा कि आप देख सकते हैं, DogeChat अब आपको एक उपयोगकर्ता नाम दर्ज करने और स्वयं चैट अनुभाग में जाने की अनुमति देता है।

ऐसा लगता है कि इस परियोजना के डेवलपर को यह पता नहीं था कि चैट कैसे की जाती है। तो हम सब एक बुनियादी यूआई और नेविगेशन है। हम एक नेटवर्क लेयर लिखेंगे। हुर्रे!

एक चैट रूम बनाएं

विकास के लिए सीधे जाने के लिए, ChatRoomViewController.swift पर जाएं । यह एक दृश्य नियंत्रक है जो उपयोगकर्ता द्वारा दर्ज किए गए पाठ को प्राप्त कर सकता है और प्राप्त संदेशों को एक टेबलव्यू में प्रदर्शित कर सकता है।

चूँकि हमारे पास एक ChatRoomViewController है , यह एक ChatRoom वर्ग को विकसित करने के लिए समझ में आता है जो सभी मोटे काम करेगा।

आइए विचार करें कि नया वर्ग क्या प्रदान करेगा:

सर्वर अनुप्रयोग के लिए एक कनेक्शन खोलना;
किसी उपयोगकर्ता को चैट के लिए उसके द्वारा निर्दिष्ट नाम से जोड़ना;
संदेश भेजना और प्राप्त करना;
अंत में कनेक्शन बंद करना।

अब जब हम जानते हैं कि हम इस वर्ग से क्या चाहते हैं, कमांड-एन दबाएं, स्विफ्ट फाइल चुनें और इसे चैटरूम कहें ।

I / O स्ट्रीम बनाना

इसके साथ ChatRoom.swift की सामग्री को बदलें :

 import UIKit class ChatRoom: NSObject { //1 var inputStream: InputStream! var outputStream: OutputStream! //2 var username = "" //3 let maxReadLength = 4096 }

यहाँ हम ChatRoom वर्ग को परिभाषित करते हैं और उन गुणों की घोषणा करते हैं जिनकी हमें आवश्यकता है।

पहले हम इनपुट / आउटपुट स्ट्रीम को परिभाषित करते हैं। एक जोड़ी के रूप में उनका उपयोग करने से हमें एप्लिकेशन और चैट सर्वर के बीच सॉकेट कनेक्शन बनाने की अनुमति मिलेगी। बेशक, हम आउटपुट स्ट्रीम का उपयोग करके संदेश भेजेंगे, और इनपुट स्ट्रीम का उपयोग करके प्राप्त करेंगे।
अगला, हम उपयोगकर्ता नाम को परिभाषित करते हैं।
और अंत में, हम वैरिएबल मैक्सरेलड्रीमिटी को परिभाषित करते हैं, जो किसी एक संदेश की अधिकतम लंबाई को सीमित करता है।

अब ChatRoomViewController.swift फाइल पर जाएं और इस लाइन को इसके गुणों की सूची में जोड़ें:

 let chatRoom = ChatRoom()

अब जब हमने कक्षा की मूल संरचना बनाई है, तो यह योजनाबद्ध कार्यों में से पहला करने का समय है: आवेदन और सर्वर के बीच कनेक्शन खोलना।

कनेक्शन खोलें

हम ChatRoom.swift पर लौटते हैं और संपत्ति परिभाषाओं के लिए इस विधि को जोड़ते हैं:

 func setupNetworkCommunication() { // 1 var readStream: Unmanaged<CFReadStream>? var writeStream: Unmanaged<CFWriteStream>? // 2 CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, "localhost" as CFString, 80, &readStream, &writeStream) }

हम यहाँ क्या करते हैं:

पहले हम स्वचालित मेमोरी प्रबंधन का उपयोग किए बिना सॉकेट धाराओं के लिए दो चर निर्धारित करते हैं
फिर, हम इन समान चर का उपयोग करते हुए, सीधे स्ट्रीम बनाते हैं जो होस्ट और पोर्ट नंबर के लिए बाध्य हैं।

फ़ंक्शन के चार तर्क हैं। पहला मेमोरी एलोकेटर का प्रकार है जिसका उपयोग हम थ्रेड्स को इनिशियलाइज़ करते समय करेंगे। आपको kCFAllocatorDefault का उपयोग करना चाहिए, हालाँकि यदि आप थ्रेड्स के व्यवहार को बदलना चाहते हैं तो अन्य संभावित विकल्प हैं।

अनुवादक का नोट

CFStreamCreatePairWithSocketToHost फ़ंक्शन के लिए दस्तावेज़ कहता है: NULL या kCFAllocatorDefault का उपयोग करें। और kCFAllocatorDefault का वर्णन कहता है कि यह NULL का पर्याय है । सर्कल बंद हो गया है!

फिर हमने होस्ट नाम सेट किया। हमारे मामले में, हम स्थानीय सर्वर से जुड़ रहे हैं। यदि आपका सर्वर दूसरी जगह स्थित है, तो आप उसका आईपी पता सेट कर सकते हैं।

फिर सर्वर जिस पोर्ट नंबर पर सुन रहा है।

अंत में, हम अपने I / O स्ट्रीम को पॉइंटर्स पास करते हैं ताकि फंक्शन उन्हें इनिशियलाइज़ कर सके और उन्हें उन स्ट्रीम से कनेक्ट कर सके जो इसे बनाता है।

अब जब हमारे पास प्रारंभिक प्रवाह है, हम इन पंक्तियों को setupNetworkCommunication () विधि के अंत में जोड़ सकते हैं:

 inputStream = readStream!.takeRetainedValue() outputStream = writeStream!.takeRetainedValue()

एक अप्रबंधित वस्तु पर लागू होने के रूप में takeRetainedValue () का उपयोग करना हमें एक संदर्भ बनाए रखने की अनुमति देता है और, एक ही समय में, भविष्य की मेमोरी लीक से बचें। अब हम जहां चाहें वहां अपने धागों का इस्तेमाल कर सकते हैं।

अब हमें इन थ्रेड्स को रन लूप में जोड़ना होगा ताकि हमारा एप्लिकेशन नेटवर्क घटनाओं को सही ढंग से संसाधित कर सके। ऐसा करने के लिए, setupNetworkCommunication () के अंत में इन दो पंक्तियों को जोड़ें:

 inputStream.schedule(in: .current, forMode: .common) outputStream.schedule(in: .current, forMode: .common)

अंत में यह पाल करने का समय है! आरंभ करने के लिए, इसे setupNetworkCommunication () विधि के बहुत अंत में जोड़ें:

 inputStream.open() outputStream.open()

अब हमारे पास हमारे क्लाइंट और सर्वर एप्लिकेशन के बीच एक खुला संबंध है।

हम अपने एप्लिकेशन को संकलित और चला सकते हैं, लेकिन आपको अभी तक कोई बदलाव नहीं दिखेगा, क्योंकि हम अपने क्लाइंट-सर्वर कनेक्शन के साथ कुछ भी नहीं कर रहे हैं।

चैट से कनेक्ट करें

अब जब हमारे पास सर्वर के साथ एक स्थापित कनेक्शन है, तो इसके बारे में कुछ करना शुरू करने का समय है! चैट के मामले में, आपको पहले अपना परिचय देना होगा, और फिर आप वार्ताकारों को संदेश भेज सकते हैं।

यह हमें एक महत्वपूर्ण निष्कर्ष पर ले जाता है: चूंकि हमारे पास दो प्रकार के संदेश हैं, इसलिए हमें किसी तरह उनके बीच अंतर करने की आवश्यकता है।

चैट प्रोटोकॉल

टीसीपी परत का उपयोग करने का एक लाभ यह है कि हम संचार के लिए अपने स्वयं के "प्रोटोकॉल" को परिभाषित कर सकते हैं।

अगर हमने HTTP का उपयोग किया है, तो हमें इन विभिन्न शब्दों GET , PUT , PATCH का उपयोग करना होगा। हमें URL बनाने और सही हेडर और सभी का उपयोग करने की आवश्यकता होगी।

हमारे पास केवल दो प्रकार के संदेश हैं। हम भेज देंगे

iam:Luke

चैट दर्ज करने और अपना परिचय देने के लिए।

और हम भेज देंगे

msg:Hey, how goes it, man?

सभी उत्तरदाताओं को चैट संदेश भेजने के लिए।

यह बहुत सरल है, लेकिन बिल्कुल अप्रत्याशित है, इसलिए महत्वपूर्ण परियोजनाओं में इस पद्धति का उपयोग न करें।

अब हमें पता है कि हमारा सर्वर क्या उम्मीद करता है और हम चैटरूम क्लास में एक विधि लिख सकते हैं जो उपयोगकर्ता को चैट से कनेक्ट करने की अनुमति देगा। एकमात्र तर्क उपयोगकर्ता का उपनाम है।

इस विधि को ChatRoom.swift के अंदर जोड़ें :

 func joinChat(username: String) { //1 let data = "iam:\(username)".data(using: .utf8)! //2 self.username = username //3 _ = data.withUnsafeBytes { guard let pointer = $0.baseAddress?.assumingMemoryBound(to: UInt8.self) else { print("Error joining chat") return } //4 outputStream.write(pointer, maxLength: data.count) } }

पहले हम अपने "प्रोटोकॉल" का उपयोग करके अपना संदेश बनाते हैं
भविष्य के संदर्भ के लिए नाम सहेजें।
withUnsafeBytes (_ :) एक क्लोजर के अंदर असुरक्षित पॉइंटर के साथ काम करने का एक सुविधाजनक तरीका प्रदान करता है।
अंत में, हम अपना संदेश आउटपुट स्ट्रीम में भेजते हैं। यह आपकी अपेक्षा से अधिक जटिल लग सकता है, हालांकि लिखें (_: maxLength :) पिछले चरण में बनाए गए असुरक्षित पॉइंटर का उपयोग करता है।

अब हमारी विधि तैयार है, ChatRoomViewController.swift खोलें और viewWillAppear (_ :) के अंत में इस विधि में एक कॉल जोड़ें।

 chatRoom.joinChat(username: username)

अब एप्लिकेशन को संकलित करें और चलाएं। अपना उपनाम दर्ज करें और देखने के लिए वापसी पर टैप करें ...

... कि फिर से कुछ भी नहीं बदला है!

रुको, यह सब ठीक है! टर्मिनल विंडो पर जाएं। वहाँ आप देखेंगे कि संदेश वास्या में शामिल हो गया है या कुछ ऐसा है कि यदि आपका नाम वास्या नहीं है।

यह बहुत अच्छा है, लेकिन अपने फोन की स्क्रीन पर एक सफल कनेक्शन का संकेत देना अच्छा होगा।

आने वाले संदेशों का जवाब

सर्वर क्लाइंट को संदेश भेज रहा है जो आपके साथ चैट में शामिल सभी लोगों को भेजता है। सौभाग्य से, हमारे आवेदन में पहले से ही ChatRoomViewController की संदेश तालिका में कोशिकाओं के रूप में किसी भी आने वाले संदेशों को प्रदर्शित करने के लिए सब कुछ है।

आपको केवल इन संदेशों को "पकड़ने" के लिए इनपुटस्ट्रीम का उपयोग करना है, उन्हें संदेश वर्ग के उदाहरणों में परिवर्तित करें और उन्हें प्रदर्शन के लिए तालिका में पास करें।

आने वाले संदेशों का जवाब देने में सक्षम होने के लिए, आपको StreamDelegate प्रोटोकॉल का पालन करने के लिए ChatRoom की आवश्यकता है।

ऐसा करने के लिए, इस एक्सटेंशन को ChatRoom.swift फ़ाइल के नीचे जोड़ें:

 extension ChatRoom: StreamDelegate { }

अब घोषित करें कि कौन इनपुटस्ट्रीम का प्रतिनिधि बन जाएगा।

शेड्यूल करने के लिए कॉल करने से पहले setupNetworkCommunication () विधि में इस लाइन को जोड़ें: (forMode :):

 inputStream.delegate = self

अब धारा जोड़ें (_: संभाल :) विस्तार के लिए विधि कार्यान्वयन:

 func stream(_ aStream: Stream, handle eventCode: Stream.Event) { switch eventCode { case .hasBytesAvailable: print("new message received") case .endEncountered: print("The end of the stream has been reached.") case .errorOccurred: print("error occurred") case .hasSpaceAvailable: print("has space available") default: print("some other event...") } }

हम आने वाले संदेशों को संसाधित करते हैं

इसलिए, हम आने वाले संदेशों को संसाधित करना शुरू करने के लिए तैयार हैं। वह घटना जो हमें रुचती है .hasBytesAvailable , जो इंगित करता है कि एक आने वाला संदेश आ गया है।

हम एक विधि लिखेंगे जो इन संदेशों को संसाधित करती है। नई गयी विधि के नीचे, हम निम्नलिखित लिखते हैं:

 private func readAvailableBytes(stream: InputStream) { //1 let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: maxReadLength) //2 while stream.hasBytesAvailable { //3 let numberOfBytesRead = inputStream.read(buffer, maxLength: maxReadLength) //4 if numberOfBytesRead < 0, let error = stream.streamError { print(error) break } // Construct the Message object } }

हम बफर सेट करते हैं जिसमें हम आने वाले बाइट्स को पढ़ेंगे।
हम एक लूप में घूमते हैं, जबकि इनपुट स्ट्रीम में कुछ पढ़ना है।
हम रीड (_: maxLength :) कहते हैं, जो स्ट्रीम से बाइट्स को पढ़ता है और उन्हें बफर में डालता है।
यदि कॉल एक नकारात्मक मान लौटाता है, तो हम एक त्रुटि लौटाते हैं और लूप से बाहर निकलते हैं।

हमें इस पद्धति को कॉल करना होगा जैसे ही हमारे पास आने वाली स्ट्रीम में डेटा होगा, इसलिए हम स्ट्रीम के अंदर स्विच स्टेटमेंट पर जाएं (_: हैंडल :) विधि, .hasBytesAvailable स्विच ढूंढें और प्रिंट स्टेटमेंट के तुरंत बाद इस विधि को कॉल करें:

 readAvailableBytes(stream: aStream as! InputStream)

इस स्थान पर हमारे पास प्राप्त आंकड़ों का एक तैयार बफर है!

लेकिन हमें अभी भी इस बफर को संदेश तालिका की सामग्री में बदलना होगा।

इस विधि को readAvailableBytes (स्ट्रीम :) पर रखें ।

 private func processedMessageString(buffer: UnsafeMutablePointer<UInt8>, length: Int) -> Message? { //1 guard let stringArray = String( bytesNoCopy: buffer, length: length, encoding: .utf8, freeWhenDone: true)?.components(separatedBy: ":"), let name = stringArray.first, let message = stringArray.last else { return nil } //2 let messageSender: MessageSender = (name == self.username) ? .ourself : .someoneElse //3 return Message(message: message, messageSender: messageSender, username: name) }

सबसे पहले, हम बफर और आकार का उपयोग करके स्ट्रिंग को आरंभीकृत करते हैं जो हम इस विधि से गुजरते हैं।

पाठ UTF-8 में होगा, अंत में हम बफर को मुक्त करेंगे, और संदेश को ':' को प्रेषक के नाम और संदेश को अलग करने के लिए विभाजित करेंगे।

अब हम विश्लेषण कर रहे हैं कि क्या यह संदेश दूसरे प्रतिभागी से आया है। उत्पाद पर, आप एक अद्वितीय टोकन जैसा कुछ बना सकते हैं, यह डेमो के लिए पर्याप्त है।

अंत में, इस सभी अर्थव्यवस्था में, हम संदेश का एक उदाहरण बनाते हैं और इसे वापस करते हैं।

इस विधि का उपयोग करने के लिए, रीड-अवेलेबल बिट्स (स्ट्रीम :) विधि में अंतिम लूप के अंत में निम्नलिखित इफ-लेट को अंतिम टिप्पणी के तुरंत बाद जोड़ें:

 if let message = processedMessageString(buffer: buffer, length: numberOfBytesRead) { // Notify interested parties }

अब सब कुछ किसी को संदेश देने के लिए तैयार है ... लेकिन किससे?

ChatRoomDelegate प्रोटोकॉल बनाएँ

इसलिए, हमें ChatRoomViewController.swift को नए संदेश के बारे में सूचित करना होगा, लेकिन हमारे पास इसके लिए लिंक नहीं है। चूंकि इसमें एक मजबूत चैटरूम लिंक शामिल है, हम एक मजबूत लिंक चक्र के जाल में गिर सकते हैं।

यह एक प्रतिनिधि प्रोटोकॉल बनाने के लिए सही जगह है। ChatRoom परवाह नहीं करता है जो नए पदों के बारे में जानने की जरूरत है।

ChatRoom.swift के शीर्ष पर , एक नई प्रोटोकॉल परिभाषा जोड़ें:

 protocol ChatRoomDelegate: class { func received(message: Message) }

अब ChatRoom वर्ग के अंदर , स्टोर करने के लिए एक कमजोर लिंक जोड़ें जो प्रतिनिधि बन जाएगा:

 weak var delegate: ChatRoomDelegate?

चलिए अब readAvailableBytes (स्ट्रीम :) मेथड को जोड़ते हैं, अगर-लेट कंस्ट्रक्शन के अंदर निम्न लाइन को जोड़ते हैं, तो विधि में अंतिम टिप्पणी के तहत:

 delegate?.received(message: message)

ChatRoomViewController.swift पर वापस जाएं और निम्न वर्ग एक्सटेंशन जोड़ें, जो ChatRoomDelegate प्रोटोकॉल का अनुपालन सुनिश्चित करता है, MessageInputDelegate के तुरंत बाद:

 extension ChatRoomViewController: ChatRoomDelegate { func received(message: Message) { insertNewMessageCell(message) } }

मूल परियोजना में पहले से ही आवश्यक है, इसलिए सम्मिलित करेंमेनेसेजसेल (_ :) आपके संदेश को स्वीकार करेगा और तालिका में सही सेल प्रदर्शित करेगा।

अब viewWillAppear (_ :) को super.viewWillearear () कॉल करने के तुरंत बाद इसे जोड़कर एक दृश्य के रूप में दृश्य नियंत्रक असाइन करें

 chatRoom.delegate = self

अब एप्लिकेशन को संकलित करें और चलाएं। एक नाम दर्ज करें और वापसी पर टैप करें।

आप चैट के लिए अपने कनेक्शन के बारे में एक सेल देखेंगे। हुर्रे, आपने सफलतापूर्वक सर्वर को एक संदेश भेजा और इसे एक प्रतिक्रिया मिली!

संदेश पोस्ट कर रहा है

अब जब ChatRoom संदेश भेज और प्राप्त कर सकता है, तो उपयोगकर्ता को अपने वाक्यांश भेजने की क्षमता प्रदान करने का समय आ गया है।

ChatRoom.swift में, कक्षा की परिभाषा के अंत में निम्नलिखित विधि जोड़ें:

 func send(message: String) { let data = "msg:\(message)".data(using: .utf8)! _ = data.withUnsafeBytes { guard let pointer = $0.baseAddress?.assumingMemoryBound(to: UInt8.self) else { print("Error joining chat") return } outputStream.write(pointer, maxLength: data.count) } }

यह विधि joinChat (उपयोगकर्ता नाम :) के समान है, जिसे हमने पहले लिखा था, सिवाय इसके कि इसमें टेक्स्ट के सामने msg उपसर्ग है (यह इंगित करने के लिए कि यह एक वास्तविक चैट संदेश है)।

चूँकि हम Send बटन द्वारा संदेश भेजना चाहते हैं, हम ChatRoomViewController.swift पर लौटते हैं और वहां MessageInputDoggate खोजें।

यहां हम खाली SendWasTapped (संदेश :) विधि देखते हैं। एक संदेश भेजने के लिए, इसे chatRoom पर भेजें:

 chatRoom.send(message: message)

असल में, वह सब है! चूंकि सर्वर संदेश प्राप्त करेगा और इसे सभी को अग्रेषित करेगा, चैट में शामिल होने के दौरान उसी तरह से चैटरूम को नए संदेश के बारे में सूचित किया जाएगा।

एप्लिकेशन को संकलित करें और चलाएं।

यदि आपके पास अब किसी से चैट करने के लिए नहीं है, तो एक नई टर्मिनल विंडो लॉन्च करें और दर्ज करें:

nc localhost 80

यह आपको सर्वर से कनेक्ट करेगा। अब आप उसी "प्रोटोकॉल" का उपयोग करके चैट से जुड़ सकते हैं:

iam:gregg

और इसलिए - एक संदेश भेजें:

msg:Ay mang, wut's good?

बधाई हो, आपने चैट के लिए क्लाइंट लिखा है!

हम खुद को साफ करते हैं

यदि आप कभी ऐसे एप्लिकेशन विकसित कर रहे हैं जो सक्रिय रूप से फ़ाइलों को पढ़ते / लिखते हैं, तो आपको पता होना चाहिए कि अच्छे डेवलपर्स फाइलों को बंद कर देते हैं जब वे उनके साथ काम करते हैं। तथ्य यह है कि सॉकेट के माध्यम से कनेक्शन फ़ाइल डिस्क्रिप्टर द्वारा प्रदान किया जाता है। इसका मतलब है कि काम पूरा होने पर आपको इसे किसी अन्य फ़ाइल की तरह बंद करने की आवश्यकता है।

ऐसा करने के लिए, Send (संदेश :) : को परिभाषित करने के बाद ChatRoom.swift में निम्न विधि जोड़ें:

 func stopChatSession() { inputStream.close() outputStream.close() }

जैसा कि आपने शायद अनुमान लगाया था, यह विधि थ्रेड को बंद कर देती है ताकि आप अब संदेश प्राप्त न कर सकें और संदेश न भेज सकें। इसके अलावा, थ्रेड्स को रन लूप से हटा दिया जाता है जिसमें हमने पहले उन्हें रखा था।

इस विधि में एक कॉल जोड़ें। धारा के अंदर स्विच स्टेटमेंट के .Encountered सेक्शन (_: हैंडल :) :

 stopChatSession()

इसके बाद ChatRoomViewController.swift पर जाएं और viewWillDisappear (_ :) : में भी ऐसा ही करें

 chatRoom.stopChatSession()

यह बात है! अब पक्का!

निष्कर्ष

अब जब आपने सॉकेट्स के साथ नेटवर्किंग की मूल बातों में महारत हासिल कर ली है, तो आप अपने ज्ञान को गहरा कर सकते हैं।

यूडीपी सॉकेट्स

यह एप्लिकेशन टीसीपी का उपयोग करके नेटवर्क संचार का एक उदाहरण है, जो गंतव्य तक पैकेट के वितरण की गारंटी देता है।

हालांकि, आप यूडीपी सॉकेट्स का उपयोग कर सकते हैं। इस प्रकार का कनेक्शन पैकेज के वितरण को उनके इच्छित उद्देश्य की गारंटी नहीं देता है, लेकिन यह बहुत तेज़ है।

यह खेलों में विशेष रूप से उपयोगी है। कभी एक अंतराल अनुभव किया? इसका मतलब था कि आपके संबंध खराब थे और यूडीपी के कई पैकेट खो गए थे।

WebSockets

अनुप्रयोगों में HTTP का एक अन्य विकल्प एक तकनीक है जिसे वेब सॉकेट कहा जाता है।

नियमित टीसीपी सॉकेट्स के विपरीत, वेब सॉकेट संचार स्थापित करने के लिए HTTP का उपयोग करते हैं। उनकी मदद से, आप साधारण सॉकेट के साथ ही प्राप्त कर सकते हैं, लेकिन आराम और सुरक्षा के साथ, जैसे कि ब्राउज़र में।

IOS पर चैट करें: सॉकेट्स का उपयोग करना