कनेक्शन का जीवनचक्र और पुनः कनेक्शन

एक Realtime कनेक्शन एक WebSocket होता है। नेटवर्क में बदलाव, स्लीप मोड में गए डिवाइस और इंफ्रास्ट्रक्चर के रीस्टार्ट इसे बंद कर सकते हैं। क्लाइंट अपने आप दोबारा जुड़ जाता है, और आपका ऐप कनेक्शन की मौजूदा स्थिति दिखा सकता है।

छह स्थितियाँ

ब्राउज़र क्लाइंट में bird.connection.state और Swift व Kotlin में bird.connectionState हमेशा इनमें से किसी एक स्थिति में होता है (Kotlin इन्हें ConnectionState कॉन्स्टेंट के रूप में लिखता है, इसलिए unavailable को ConnectionState.UNAVAILABLE लिखा जाता है):

हर बदलाव देखने के लिए state_change बाइंड करें, या जब केवल एक स्थिति मायने रखती हो तो उसी स्थिति का नाम बाइंड करें:

import { BirdRealtime } from "@messagebird/realtime";

const bird = new BirdRealtime({ appKey: "your-app-key", region: "us1" });

bird.connection.bind("state_change", ({ previous, current }) => {
  console.log(previous, "->", current);
});

bird.connection.bind("unavailable", () => showReconnectingBanner());
bird.connection.bind("connected", () => hideReconnectingBanner());

import BirdRealtime

let bird = BirdRealtime(options: .init(appKey: "your-app-key", region: "us1"))

bird.onConnectionStateChange { previous, current in
    print(previous, "->", current)
    if current == .unavailable { showReconnectingBanner() }
    if current == .connected { hideReconnectingBanner() }
}

import com.bird.realtime.BirdRealtime
import com.bird.realtime.BirdRealtimeOptions
import com.bird.realtime.ConnectionState

val bird = BirdRealtime(BirdRealtimeOptions(appKey = "your-app-key", region = "us1"))

bird.onConnectionStateChange { previous, current ->
    println("$previous -> $current")
    if (current == ConnectionState.UNAVAILABLE) showReconnectingBanner()
    if (current == ConnectionState.CONNECTED) hideReconnectingBanner()
}

Swift और Kotlin हर बदलाव के लिए एक ही ऑब्ज़र्वर इस्तेमाल करते हैं, इसलिए current के आधार पर ब्रांच करें। Swift में हैंडलर मुख्य क्यू पर चलते हैं, और Kotlin में उपलब्ध होने पर Android के मुख्य लूपर पर। किसी दूसरे एक्ज़ीक्यूशन कॉन्टेक्स्ट का इस्तेमाल करने के लिए deliveryQueue या Executor पास करें।

खुला सॉकेट तब तक connecting में रहता है जब तक सर्वर का हैंडशेक नहीं आ जाता। स्थिति के connected बनने से पहले हैंडशेक bird.connection.connectionId सेट करता है, ताकि ऑथराइज़ेशन उस ID पर हस्ताक्षर कर सके। अगर हैंडशेक में ID नहीं होती, तो क्लाइंट एक त्रुटि रिपोर्ट करता है और सॉकेट बंद कर देता है।

अपने-आप दोबारा कनेक्ट होना

अप्रत्याशित रूप से कनेक्शन टूटने के बाद, क्लाइंट नया सॉकेट खोलने से पहले इंतज़ार करता है। यह देरी फुल-जिटर एक्सपोनेंशियल बैकऑफ़ से तय होती है, जिसका आधार एक सेकंड और अधिकतम सीमा 30 सेकंड है। हर सफल हैंडशेक बैकऑफ़ को रीसेट कर देता है।

क्लोज़ कोड तय करता है कि इन तीन में से क्या होगा:

नेटवर्क विफलताएँ बैकऑफ़ वाला रास्ता अपनाती हैं। अस्वीकृति कोड को अपने UI में संभालें, क्योंकि ये अंतिम विफलताएँ अपने आप दोबारा कनेक्ट नहीं होतीं।

निष्क्रिय कनेक्शन की जाँच

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

आपके चैनलों का क्या होता है

सब्सक्रिप्शन कनेक्शन से जुड़े होते हैं, इसलिए कनेक्शन टूटने पर वे हट जाते हैं। क्लाइंट हर चैनल ऑब्जेक्ट को बनाए रखता है, अगली connected स्थिति के बाद फिर से सब्सक्राइब करता है और उसके मौजूदा हैंडलर रखता है।

क्लाइंट हर प्राइवेट और प्रेज़ेंस चैनल के लिए नई कनेक्शन ID के साथ आपके authEndpoint को फिर से कॉल करता है। वह पुराने सिग्नेचर का दोबारा उपयोग नहीं कर सकता, क्योंकि उस सिग्नेचर में पिछली कनेक्शन ID शामिल होती है। एक बार signin() कॉल होने के बाद, क्लाइंट हर नए कनेक्शन पर साइन इन भी करता है और बाद की विफलताओं की रिपोर्ट signin_error के ज़रिए देता है।

bird.connection.bind("signin_error", ({ message }) => {
  console.warn("connection has no identity:", message);
});

bird.onSigninError { error in
    print("connection has no identity:", error.message)
}

bird.onSigninError { error ->
    println("connection has no identity: ${error.message}")
}

जब कोई चैनल फिर से कनेक्ट हो रहा होता है, तब channel.trigger क्लाइंट इवेंट भेजे बिना false लौटाता है। channel.subscribed जाँचें, या bird:subscription_succeeded के बाद भेजें, जो हर सफल पुनः सब्सक्रिप्शन के बाद चलता है।

const room = bird.subscribe("presence-room-1");

room.bind("bird:subscription_succeeded", ({ members }) => {
  renderMembers(members);
});

guard let room = bird.subscribe("presence-room-1") as? PresenceChannel else { return }

room.bind(BirdProtocol.Event.subscriptionSucceeded) { _ in
    renderMembers(room.members)
}

val room = bird.subscribe("presence-room-1")
if (room is PresenceChannel) {
    room.bind(BirdProtocol.Event.SUBSCRIPTION_SUCCEEDED) {
        renderMembers(room.members)
    }
}

क्लाइंट के डिस्कनेक्ट रहने के दौरान प्रकाशित इवेंट Realtime दोबारा नहीं चलाता। अगर किसी व्यू को अंतराल के बाद अपनी स्थिति वापस पानी है, तो bird:subscription_succeeded पर उसकी मौजूदा स्थिति प्राप्त करें और वहाँ से बाद के इवेंट लागू करें।

जानबूझकर डिस्कनेक्ट करना

bird.disconnect() फिर से कनेक्ट करने का समय तय किए बिना सॉकेट बंद करता है। इसका उपयोग तब करें जब साइन आउट हो चुके या निष्क्रिय क्लाइंट को अब लाइव डेटा की ज़रूरत न हो। क्लाइंट चैनलों को बनाए रखता है, इसलिए बाद में bird.connect() सॉकेट को फिर से खोलता है और फिर से सब्सक्राइब करता है।

bird.disconnect(); // state: disconnected, no reconnect
bird.connect(); // reopens and re-subscribes

bird.disconnect() // state: disconnected, no reconnect
bird.connect() // reopens and re-subscribes

bird.disconnect() // state: DISCONNECTED, no reconnect
bird.connect() // reopens and re-subscribes

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

कनेक्शन की त्रुटियाँ और चैनल की त्रुटियाँ

किसी एक चैनल से जुड़ी सर्वर त्रुटियाँ उसी चैनल पर आती हैं। आम तौर पर यह अस्वीकृत सब्सक्रिप्शन होता है, और 403 लौटाने वाला ऑथराइज़र यहीं दिखता है:

room.bind("bird:subscription_error", (err) => {
  console.warn("could not join:", err);
});

room.bind(BirdProtocol.Event.subscriptionError) { error in
    print("could not join:", error ?? "")
}

room.bind(BirdProtocol.Event.SUBSCRIPTION_ERROR) { error ->
    println("could not join: $error")
}

वायर जिसे किसी चैनल से नहीं जोड़ता, वह सब इसके बजाय कनेक्शन पर आता है:

bird.connection.bind("error", ({ code, message }) => {
  console.warn(code, message);
});

bird.onError { error in
    print(error.code ?? 0, error.message)
}

bird.onError { error ->
    println("${error.code} ${error.message}")
}

क्लोज़ कोड 4009 को हैंडल करें

कोड 4009 उस श्रेणी में आता है जिसमें फिर से प्रयास नहीं किया जाता, इसलिए कनेक्शन failed स्थिति में चला जाता है। इन स्थितियों में अंतर करने के लिए कारण देखें:

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

क्लाइंट अपने आप दोबारा कनेक्ट नहीं होता, इसलिए आगे क्या होगा, यह आपका ऐप तय करता है:

bird.connection.bind("error", ({ code }) => {
  if (code === 4009) showSignedOutScreen();
});

bird.onError { error in
    if error.code == 4009 { showSignedOutScreen() }
}

bird.onError { error ->
    if (error.code == 4009) showSignedOutScreen()
}

प्रमाणीकरण समाप्त हो जाने पर साइन-आउट स्थिति दिखाना उचित है। bird.connect() को कॉल करने से नया कनेक्शन शुरू होता है और प्राधिकरण दोबारा होता है, इसलिए कॉलर की प्राधिकरण स्थिति बदलने के बाद ही दोबारा कनेक्ट करें।

अगले कदम

• चैनलों को अधिकृत करना वह अनुबंध है जिसे आपका बैकएंड लागू करता है, और वही अनुरोध है जिसे क्लाइंट हर बार दोबारा कनेक्ट होने पर दोहराता है।
• अधिकृत कनेक्शन अनिवार्य करना अनधिकृत कनेक्शन को बंद कर देता है।
• सदस्य कनेक्शन समाप्त करना बताता है कि किसी कनेक्शन को जानबूझकर 4009 के साथ कैसे बंद किया जाता है।
• Realtime अवलोकन चैनलों, सदस्यों और कनेक्शनों को एक मॉडल के रूप में समझाता है।