Device Token: यह कैसे काम करता है, APNS टोकन प्राप्त करना और अपडेट करना

Device Token क्या है

Device Token (डिवाइस टोकन) एक hex स्ट्रिंग के रूप में एक अद्वितीय पहचानकर्ता है जिसे APNS (Apple Push Notification Service) प्रत्येक iOS डिवाइस पर प्रत्येक ऐप के लिए उत्पन्न करता है। टोकन वह कुंजी है जिसके द्वारा सर्वर किसी विशिष्ट डिवाइस को पुश नोटिफिकेशन भेजता है। वैध Device Token के बिना, सर्वर पुश नोटिफिकेशन डिलीवर नहीं कर सकता — APNS 400 BadRequest त्रुटि के साथ अनुरोध को अस्वीकार कर देता है।

टोकन कैसे बनता है

Device Token iOS सिस्टम द्वारा तब बनाया जाता है जब ऐप इंस्टॉलेशन के बाद पहली बार APNS से संपर्क करता है। जनरेशन प्रक्रिया में ऐप के bundle ID और डिवाइस के अद्वितीय पहचानकर्ता (UID) के साथ क्रिप्टोग्राफ़िक बाइंडिंग शामिल है, जिसके बाद APNS ऐप को hex प्रारूप (64 वर्ण) में 32-बाइट टोकन लौटाता है। टोकन स्थायी नहीं है — सिस्टम कुछ शर्तों पर नया टोकन उत्पन्न कर सकता है।

पुश नोटिफिकेशन डिलीवरी में टोकन की भूमिका

जब सर्वर पुश नोटिफिकेशन भेजता है, तो वह APNS को HTTP/2 अनुरोध में Device Token शामिल करता है। APNS टोकन को मान्य करता है: यदि टोकन किसी भिन्न वातावरण (production के बजाय sandbox) से है, समाप्त हो गया है या रद्द कर दिया गया है, तो Apple सर्वर 410 Gone या 400 BadRequest त्रुटि लौटाता है। टोकन के सफल मान्यकरण के बाद ही APNS डिवाइस पर नोटिफिकेशन डिलीवर करना शुरू करता है।

Device Token और अन्य पहचानकर्ताओं के बीच अंतर

Device Token को IDFA (Identifier for Advertisers), IDFV (Identifier for Vendor) या UID (Unique Device Identifier) के साथ भ्रमित नहीं करना चाहिए। IDFA और IDFV विज्ञापन और विश्लेषण के लिए उपयोग किए जाते हैं, UID एक हार्डवेयर सीरियल नंबर है। Device Token विशेष रूप से पुश नोटिफिकेशन के लिए मौजूद है और APNS के बाहर उपयोगकर्ता या डिवाइस के बारे में जानकारी प्रकट नहीं करता है।

डिवाइस टोकन कैसे प्राप्त और रजिस्टर करता है

Device Token प्राप्त करने की प्रक्रिया में कई अनिवार्य चरण शामिल हैं, उपयोगकर्ता से अनुमति मांगने से लेकर सर्वर पर टोकन भेजने तक। प्रत्येक चरण महत्वपूर्ण है — उनमें से किसी को भी छोड़ने से डिवाइस पर पुश नोटिफिकेशन भेजने में असमर्थता होती है।

नोटिफिकेशन अनुमति का अनुरोध

पहला कदम ऐप द्वारा UNUserNotificationCenter.current().requestAuthorization के माध्यम से उपयोगकर्ता से नोटिफिकेशन भेजने की अनुमति मांगना है। उपयोगकर्ता सहमत हो सकता है, अस्वीकार कर सकता है या वैकल्पिक विकल्प (alert, badge, sound) चुन सकता है। स्पष्ट उपयोगकर्ता सहमति के बिना, सिस्टम Device Token जारी नहीं करेगा, भले ही ऐप registerForRemoteNotifications को कॉल करे। अनुमति प्राप्त करने के बाद, ऐप UIApplication.shared.registerForRemoteNotifications() को कॉल करता है, जो APNS में रजिस्ट्रेशन प्रक्रिया शुरू करता है।

APNS से टोकन प्राप्त करना

रजिस्ट्रेशन के बाद, APNS AppDelegate के माध्यम से टोकन लौटाता है: application(_:didRegisterForRemoteNotificationsWithDeviceToken:). सफल कॉल में टोकन के साथ एक Data ऑब्जेक्ट होता है, जिसे सर्वर पर ट्रांसमिशन के लिए hex स्ट्रिंग में परिवर्तित किया जाना चाहिए। त्रुटि के मामले में, सिस्टम समस्या के विवरण के साथ application(_:didFailToRegisterForRemoteNotificationsWithError:) को कॉल करता है: गलत प्रमाणपत्र कॉन्फ़िगरेशन, नेटवर्क की अनुपलब्धता, या गलत प्रोजेक्ट कॉन्फ़िगरेशन।

अपने सर्वर पर टोकन भेजना

टोकन प्राप्त करने के बाद, ऐप को इसे डेटाबेस में संग्रहण के लिए तुरंत अपने सर्वर पर भेजना चाहिए। API अनुरोध में टोकन, डिवाइस पहचानकर्ता (मैपिंग के लिए), वातावरण (sandbox/production), और वैकल्पिक रूप से अतिरिक्त डेटा: OS संस्करण, डिवाइस मॉडल, भाषा शामिल है। प्रत्येक ऐप लॉन्च पर टोकन को पुनः भेजने की अनुशंसा की जाती है ताकि सर्वर के पास हमेशा अप-टू-डेट टोकन हो।

// अनुमति का अनुरोध और APNS में रजिस्ट्रेशन
func registerForPushNotifications() {
    UNUserNotificationCenter.current()
        .requestAuthorization(options: [.alert, .sound, .badge]) {
        [weak self] granted, error in
        guard granted else {
            print("अनुमति नहीं मिली")
            return
        }
        DispatchQueue.main.async {
            UIApplication.shared
                .registerForRemoteNotifications()
        }
    }
}

// APNS से Device Token प्राप्त करना
func application(
    _ application: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
) {
    let tokenString = deviceToken
        .map { String(format: "%02.2hhx", $0) }
        .joined()
    print("Device Token: \(tokenString)")

    // सर्वर पर टोकन भेजना
    PushTokenService.shared
        .sendTokenToServer(tokenString) { success in
        if success {
            UserDefaults.standard.set(tokenString,
                forKey: "lastDeviceToken")
        }
    }
}

सर्वर साइड टोकन प्रबंधन

पुश सिस्टम का सर्वर साइड Device Token को डेटाबेस में संग्रहीत करना चाहिए, जो उपयोगकर्ता और वातावरण से जुड़ा हो। नोटिफिकेशन भेजते समय, सर्वर APNS को एक अनुरोध बनाता है, जिसमें URL में टोकन और प्रमाणीकरण के लिए JWT टोकन (या प्रमाणपत्र) शामिल होता है। उचित टोकन प्रबंधन पुश नोटिफिकेशन डिलीवरी दर को महत्वपूर्ण रूप से प्रभावित करता है।

टोकन डेटाबेस संरचना

सर्वर पर टोकन तालिका में कम से कम शामिल होना चाहिए: Device Token (अद्वितीय), उपयोगकर्ता ID, वातावरण (sandbox/production), अंतिम अपडेट तिथि, और स्थिति (सक्रिय/निष्क्रिय)। भेजते समय त्वरित खोज के लिए टोकन पर और किसी उपयोगकर्ता के सभी डिवाइसों की सूची प्राप्त करने के लिए उपयोगकर्ता पर इंडेक्स जोड़ने की अनुशंसा की जाती है। कई ऐप्स एक उपयोगकर्ता को कई डिवाइस रखने की अनुमति देते हैं — प्रत्येक का अपना टोकन।

APNS अनुरोधों का प्राधिकरण

पुश नोटिफिकेशन भेजने के लिए, सर्वर को दो तरीकों से APNS को अनुरोध प्राधिकृत करना होगा। प्रमाणपत्र-आधारित Apple Developer Console में उत्पन्न SSL प्रमाणपत्र का उपयोग करता है। टोकन-आधारित .p8 कुंजी के साथ JWT (JSON Web Token) का उपयोग करता है जो प्रमाणपत्र को नवीनीकृत किए बिना 30 दिनों तक वैध रहता है। टोकन-आधारित प्राधिकरण को अधिक आधुनिक माना जाता है और Apple द्वारा नई परियोजनाओं के लिए अनुशंसित किया जाता है।

HTTP/2 APNS अनुरोध बनाना

APNS को अनुरोध में HTTP/2 POST विधि, पथ /3/device/{device_token} के साथ URL, प्राधिकरण हेडर, और पेलोड के साथ JSON बॉडी शामिल है। apns-topic हेडर में ऐप का bundle ID होना चाहिए। apns-priority डिलीवरी प्राथमिकता इंगित करता है (5 — तुरंत, 10 — बैटरी बचत के साथ)। apns-expiration वह समय सेकंड में निर्धारित करता है जब तक APNS नोटिफिकेशन डिलीवर करने का प्रयास करेगा।

// APNS HTTP/2 के माध्यम से Node.js पर push भेजने का उदाहरण
const http2 = require('http2');
const client = http2.connect('https://api.push.apple.com');

const deviceToken = 'abcdef0123456789...';
const payload = JSON.stringify({
    "aps": { "alert": "Hello!", "sound": "default" }
});

const req = client.request({
    ':method': 'POST',
    ':path': `/3/device/${deviceToken}`,
    'apns-topic': 'com.example.app',
    'apns-priority': '10',
    'apns-expiration': '0',
    'authorization': `bearer ${jwtToken}`
});
req.write(payload);
req.end();
req.on('response', (headers) => {
    if (headers[':status'] === '200') {
        console.log('Push सफलतापूर्वक भेजा गया');
    }
});

बैच भेजना और थ्रॉटलिंग

बड़ी संख्या में डिवाइसों पर पुश नोटिफिकेशन भेजते समय, गति नियंत्रण के साथ बैच भेजने का उपयोग करें। APNS अनुशंसा करता है प्रति कनेक्शन प्रति सेकंड 1500 अनुरोधों से अधिक न करें। सीमा पार होने पर, Apple सर्वर 429 Too Many Requests त्रुटि लौटाता है। बड़े पैमाने के अभियानों के लिए, कई कनेक्शनों का उपयोग करें और डिवाइसों पर लोड समान रूप से वितरित करें।

टोकन अपडेट और अमान्यकरण

Device Token स्थायी नहीं है और कई परिदृश्यों में बदल सकता है, जिसके लिए सर्वर पर एक अपडेट तंत्र की आवश्यकता होती है। यदि सर्वर पुराने टोकन पर पुश भेजना जारी रखता है, तो APNS 410 Gone त्रुटि लौटाता है, जो दर्शाता है कि टोकन दिए गए वातावरण के लिए अब मान्य नहीं है।

टोकन कब बदलता है

Apple कई परिदृश्यों का दस्तावेज़ीकरण करता है जिनमें Device Token बदलता है: उपयोगकर्ता ऐप को पुनः इंस्टॉल करता है, डिवाइस को iCloud बैकअप से पुनर्स्थापित करता है, iOS का नया संस्करण इंस्टॉल करता है, या नेटवर्क या गोपनीयता सेटिंग्स रीसेट करता है। प्रत्येक मामले में, ऐप अपने अगले लॉन्च पर APNS से एक नया टोकन प्राप्त करेगा। सर्वर को डेटाबेस में टोकन अपडेट करना चाहिए, पुराने को हटाकर नए को सहेजना चाहिए।

APNS से 410 Gone त्रुटि को संभालना

जब सर्वर पुराने टोकन पर पुश भेजता है, तो APNS apns-unless-timestamp हेडर के साथ HTTP 410 लौटाता है। यह हेडर उस समय को इंगित करता है जिसके बाद टोकन अमान्य हो गया। सर्वर को डेटाबेस में इस टोकन को तुरंत हटा देना चाहिए या निष्क्रिय कर देना चाहिए ताकि उस पर दोबारा न भेजे। 410 त्रुटि को अनदेखा करने से संसाधन बर्बाद होते हैं और डिलीवरेबिलिटी दर कम हो जाती है।

निष्क्रिय टोकनों की आवधिक सफाई

टोकन डेटाबेस को अप-टू-डेट रखने के लिए, आवधिक सफाई चलाने की अनुशंसा की जाती है। सफाई स्क्रिप्ट पिछले N दिनों के APNS लॉग का विश्लेषण करती है, उन सभी टोकनों को ढूंढती है जिन्हें 410 त्रुटि मिली, और उन्हें डेटाबेस में निष्क्रिय कर देती है। इसके अतिरिक्त, 90 दिनों से अधिक समय तक उपयोगकर्ता गतिविधि न होने वाले टोकन हटाए जा सकते हैं — ये बेकार रिकॉर्ड हैं जो केवल डेटाबेस का आकार बढ़ाते हैं।

सामूहिक भेजने से पहले टोकन मान्यकरण

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

Device Token प्राप्त करने के लिए कोड उदाहरण

आइए Swift में Device Token प्राप्त करने के पूर्ण चक्र पर चलें, जिसमें त्रुटि प्रबंधन और सर्वर को भेजना शामिल है। कोड कवर करता है अनुमति का अनुरोध, APNS में रजिस्ट्रेशन, Data को hex स्ट्रिंग में रूपांतरण, त्रुटि प्रबंधन, और विफलता पर पुनः प्रयास के साथ आपके अपने सर्वर पर टोकन भेजना।

import UIKit
import UserNotifications

final class PushNotificationManager: NSObject {

    static let shared = PushNotificationManager()
    private let apiClient = APIClient()
    private var currentToken: String?

    func register() {
        UNUserNotificationCenter.current()
            .requestAuthorization(
                options: [.alert, .badge, .sound]) {
            [weak self] granted, error in
            guard granted else {
                Analytics.log(
                    "Push permission denied")
                return
            }
            DispatchQueue.main.async {
                UIApplication.shared
                    .registerForRemoteNotifications()
            }
        }
    }

    func handleDeviceToken(_ tokenData: Data) {
        let token = tokenData
            .map { String(format: "%02.2hhx", $0) }
            .joined()

        guard token != currentToken else { return }
        currentToken = token
        sendTokenToServer(token)
    }

    func handleRegistrationError(_ error: Error) {
        Analytics.log(
            "Push registration failed: \(error)")

        // नेटवर्क त्रुटियों पर विलंब के बाद पुनः प्रयास
        if let urlError = error as? URLError,
            urlError.code == .notConnectedToInternet {
            DispatchQueue.main.asyncAfter(
                deadline: .now() + 10) { [weak self] in
                self?.register()
            }
        }
    }

    private func sendTokenToServer(_ token: String) {
        let body = PushTokenRequest(
            token: token,
            environment: Environment.current == .debug
                ? "sandbox" : "production",
            osVersion: UIDevice.current.systemVersion,
            locale: Locale.current.identifier
        )
        apiClient.sendToken(body) { [weak self] result in
            if case .success = result {
                self?.currentToken = token
            }
        }
    }
}

रजिस्ट्रेशन के दौरान त्रुटि प्रबंधन

APNS रजिस्ट्रेशन के दौरान त्रुटियाँ विभिन्न कारणों से हो सकती हैं। सबसे आम में नेटवर्क की अनुपलब्धता, Xcode में गलत प्रमाणपत्र कॉन्फ़िगरेशन (जैसे, Push Notifications क्षमता अक्षम है), सिम्युलेटर का उपयोग (जो पुश का समर्थन नहीं करता), या गलत provisioning profile शामिल है। प्रोडक्शन में, त्रुटियों को लॉग करना और यदि संभव हो, तो अगले ऐप लॉन्च पर रजिस्ट्रेशन को पुनः प्रयास करना महत्वपूर्ण है।

सिम्युलेटर पर Device Token का परीक्षण

iOS सिम्युलेटर वास्तविक Device Token प्राप्त करने का समर्थन नहीं करता है। सिम्युलेटर पर रजिस्ट्रेशन के परीक्षण के लिए, i386 आर्किटेक्चर जाँच का उपयोग करें: डिबग बिल्ड में, टोकन प्राप्ति का अनुकरण किया जा सकता है या मॉक ऑब्जेक्ट के साथ UI परीक्षण का उपयोग किया जा सकता है। वास्तविक पुश नोटिफिकेशन परीक्षण हमेशा Xcode से जुड़े भौतिक डिवाइस पर किया जाता है।