मोबाइल एसडीके ऑप्टिमाइजेशन के माध्यम से मेन थ्रेड ब्लॉकिंग को कैसे रोकें

opoinstall
2026-11-20
5 min read

कोई मोबाइल एट्रिब्यूशन एसडीके मेन थ्रेड इनिशियलाइज़ेशन को क्यों ब्लॉक करता है? एक मोबाइल एट्रिब्यूशन एसडीके मेन थ्रेड को तब ब्लॉक करता है जब यह कोल्ड स्टार्ट के दौरान सिंक्रोनस डिस्क रीड, ईगर ContentProvider ऑटो-इनिशियलाइज़ेशन, रिफ्लेक्शन, या सिंक्रोनस नेटवर्क और क्लिपबोर्ड क्वेरी निष्पादित करता है। UI फ्रेम ड्रॉप्स, Android ANRs और iOS वॉचडॉग टर्मिनेशन को रोकने के लिए StrictMode और Instruments के साथ प्रोफाइलिंग करने, इनिशियलाइज़ेशन को क्रिटिकल पाथ से हटाने और पैरामीटर को एसिंक्रोनस रूप से क्वेरी करने की आवश्यकता होती है.

मोबाइल एसडीके इनिशियलाइज़ेशन के दौरान मेन थ्रेड ब्लॉकिंग तब होती है जब एक सॉफ्टवेयर डेवलपमेंट किट लॉन्च के दौरान सीधे एप्लिकेशन के UI थ्रेड पर लंबे समय तक चलने वाले या सिंक्रोनस ऑपरेशन—जैसे ब्लॉकिंग फाइल I/O, लॉक कंटेंशन, या सिंक्रोनस नेटवर्क कॉल—निष्पादित करता है। चूंकि मोबाइल ऑपरेटिंग सिस्टम सख्त फ्रेम बजट और स्टार्टअप वॉचडॉग सीमाओं को लागू करते हैं, इसलिए लॉन्च स्टॉल को कम करने के लिए भारी इनिशियलाइज़ेशन को बैकग्राउंड थ्रेड्स पर अलग करने और प्रारंभिक UI रेंडरिंग से स्थगित पैरामीटर पुनर्प्राप्ति को अलग करने की आवश्यकता होती है।

मोबाइल एसडीके इनिशियलाइज़ेशन कोल्ड स्टार्ट स्टॉल और क्रैश क्यों ट्रिगर करता है

कोल्ड स्टार्ट के दौरान ईगर इनिशियलाइज़ेशन की लागत

कोल्ड स्टार्ट के दौरान, ऑपरेटिंग सिस्टम एप्लिकेशन प्रोसेस को फोर्क करता है, रनटाइम क्लासेज को इनिशियलाइज़ करता है, एप्लिकेशन इंस्टेंस का निर्माण करता है, और पहला फ्रेम रेंडर करता है। Android पर Application.onCreate() या iOS पर application(_:didFinishLaunchingWithOptions:) के दौरान मेन थ्रेड पर बिताया गया प्रत्येक मिलीसेकंड सीधे तौर पर Android ऐप स्टार्टअप टाइम गाइड में बताए गए अनुसार टाइम टू इनिशियल डिस्प्ले (TTID) और टाइम टू फुल डिस्प्ले (TTFD) में देरी करता है।

भारी एसडीके इनिशियलाइज़ेशन मोबाइल मेन थ्रेड को ब्लॉक करता है और पहले-फ्रेम रेंडरिंग में देरी करता है।

मोबाइल एट्रिब्यूशन और एनालिटिक्स लाइब्रेरी अक्सर चार सामान्य तंत्रों के माध्यम से छिपी हुई स्टार्टअप विलंबता (latency) पेश करती हैं:

  • ईगर ContentProvider इंस्टैंशिएशन (Android): Android प्रक्रिया स्टार्टअप के दौरान, Application.onCreate() से पहले, एप्लिकेशन मेन थ्रेड पर ऐप-घोषित कंटेंट प्रोवाइडर्स को इनिशियलाइज़ करता है। इसलिए ईगर प्रोवाइडर का काम लॉन्च में देरी कर सकता है, और ऐप्स को अनावश्यक इनिशियलाइज़ेशन की पहचान करने के लिए मर्ज किए गए मेनिफेस्ट और स्टार्टअप ट्रेसेज़ का निरीक्षण करना चाहिए।
  • सिंक्रोनस डिस्क I/O: मेन थ्रेड पर SharedPreferences या UserDefaults पढ़ना, SQLite डेटाबेस बनाना, या स्कीमा माइग्रेशन निष्पादित करना तब अप्रत्याशित रूप से रुक सकता है जब फ्लैश स्टोरेज में बैकग्राउंड राइट कंटेंशन का अनुभव होता है।
  • हैवी रिफ्लेक्शन और क्लास लोडिंग: एनोटेशन को स्कैन करना, बड़े कॉन्फ़िगरेशन एसेट को डिसीरियलाइज़ करना, या क्रिप्टोग्राफी प्रोवाइडर्स को सिंक्रोनस रूप से इनिशियलाइज़ करना क्रिटिकल रेंडर पाथ पर क्लास-लोडिंग के समय को बढ़ा देता है।
  • क्लिपबोर्ड और नेटवर्क कंटेंशन: लॉन्च के दौरान सिस्टम पेस्टबोर्ड (iOS पर UIPasteboard या Android पर ClipboardManager) तक पहुँचना या सिंक्रोनस नेटवर्क कॉल की प्रतीक्षा करना UI थ्रेड स्टॉल पेश कर सकता है—जैसे कि iOS उपकरणों पर यूनिवर्सल क्लिपबोर्ड फेच—और समय से पहले OS अनुमति संकेतों को ट्रिगर कर सकता है (iOS 14 के पेस्ट नोटिफिकेशन बैनर को iOS 16+ की क्रॉस-ऐप पेस्ट अनुमति प्रॉम्प्ट से अलग करना)।

ऑपरेटिंग सिस्टम थ्रेशोल्ड: Android ANRs बनाम iOS वॉचडॉग 0x8badf00d

मोबाइल प्लेटफॉर्म Android और iOS पर मेन-थ्रेड कंटेंशन को अलग-अलग तरह से दंडित करते हैं:

  • Android फ्रेम ड्रॉप्स और ANRs: सुचारू रेंडरिंग बनाए रखने के लिए, Android Choreographer 60 Hz पर 16.6 ms (या 120 Hz पर 8.3 ms) के फ्रेम बजट को लक्षित करता है। मेन थ्रेड पर सिंक्रोनस नेटवर्क ऑपरेशन करना लक्ष्य API स्तर, StrictMode नीतियों और कॉल पाथ के आधार पर NetworkOnMainThreadException को ट्रिगर कर सकता है, जबकि लंबे समय तक डिस्क I/O या लॉक कंटेंशन को ब्लॉक करने से इनपुट डिस्पैच फ्रीज हो जाता है और Application Not Responding (ANR) संवाद ट्रिगर हो सकता है (उदाहरण के लिए, विशिष्ट 5-सेकंड इनपुट डिस्पैच टाइमआउट के आसपास)।
  • iOS वॉचडॉग टर्मिनेशन (0x8badf00d): Addressing Watchdog Terminations पर Apple की गाइड में बताए अनुसार, SpringBoard और FrontBoard ऐप लॉन्च (scene-create) और लाइफसाइकेल ट्रांजिशन के दौरान मेन-थ्रेड उत्तरजीविता (responsiveness) की निगरानी करते हैं। यदि कोई ब्लॉकिंग एसडीके कॉल, सिंक्रोनस DispatchSemaphore.wait(), या प्रायोरिटी इनवर्जन डेडलॉक (_dispatch_once_wait) OS वॉचडॉग थ्रेशोल्ड से आगे मेन क्यू को रोकता है, तो iOS 0x8badf00d टर्मिनेशन कोड के साथ EXC_CRASH (SIGKILL) के माध्यम से ऐप को तुरंत समाप्त कर देता है।

नीचे दी गई वैचारिक टाइमलाइन दर्शाती है कि कैसे गैर-UI सेटअप और पैरामीटर पुनर्प्राप्ति को अलग करने से तेज प्रारंभिक रेंडरिंग सुरक्षित रहती है:

EAGER SYNCHRONOUS INITIALIZATION (Delays TTID / Risks Watchdog & ANR):
[Process Start] ──> [ContentProvider Init] ──> [App.onCreate: Sync Disk/Clipboard/Net] ──> [First UI Draw (Delayed)]

DEFERRED ASYNCHRONOUS INITIALIZATION (Protects First Frame):
[Process Start] ──> [Minimal Delegate / Handle] ──> [First UI Draw (Fast TTID)]
                          │
                          └──(Background IO Queue)──> [Context & Cache Prep] ──> [Async Query at Onboarding Milestone]

एक नजर में

  • लॉन्च डेलीगेट्स से सिंक्रोनस I/O को अलग करें: Application.onCreate() और didFinishLaunchingWithOptions को सिंक्रोनस फाइल रीड, SQLite माइग्रेशन और नेटवर्क ब्लॉकिंग लॉक से मुक्त रखें।
  • ContentProvider ऑटो-इनिट को समेकित करें: संगत घटक इनिशियलाइज़र को मर्ज करने और मांग पर गैर-महत्वपूर्ण होस्ट मॉड्यूल को आलसी तरीके से इनिशियलाइज़ करने के लिए Android Jetpack App Startup (androidx.startup) का उपयोग करें।
  • क्लिपबोर्ड और एट्रिब्यूशन क्वेरी को स्थगित करें: कोल्ड स्टार्ट को ब्लॉक करने के बजाय उस व्यावसायिक मील का पत्थर पर स्थगित एट्रिब्यूशन पुनर्प्राप्ति (getInstallParam या getInstallParmsCompleted) शेड्यूल करें जो परिणाम का उपभोग करता है।
  • एकीकरण से पहले और बाद में प्रोफाइल करें: Android StrictMode.ThreadPolicy और Xcode Instruments के टाइम प्रोफाइलर और ऐप लॉन्च टेम्पलेट्स के साथ Perfetto ट्रेसेज़ का उपयोग करके मेन-थ्रेड व्यवहार को सत्यापित करें।

प्लेटफॉर्म प्रोफाइलिंग टूल्स के साथ मेन थ्रेड ब्लॉकिंग का निदान कैसे करें

Android StrictMode के साथ सिंक्रोनस डिस्क और नेटवर्क उल्लंघनों का पता लगाना

एसडीके कॉल को रीफैक्टोर करने से पहले, पहचानें कि स्टार्टअप के दौरान कौन सी लाइब्रेरी UI थ्रेड पर डिस्क या नेटवर्क सॉकेट को छूती हैं। Android डिबग बिल्ड में ब्लॉकिंग मेन-थ्रेड संचालन को फ्लैग करने के लिए StrictMode.ThreadPolicy प्रदान करता है।

उत्पादन बिल्ड को प्रभावित न करने के लिए, ApplicationInfo.FLAG_DEBUGGABLE के पीछे सख्ती से गेटेड, Application.onCreate() के शीर्ष पर StrictMode सक्षम करें:

// Android - StrictModeDiagnosticsApp.kt
// Reference diagnostic setup: enable StrictMode exclusively in debuggable builds
package com.example.hostapp

import android.app.Application
import android.content.pm.ApplicationInfo
import android.os.StrictMode

class StrictModeDiagnosticsApp : Application() {
    override fun onCreate() {
        if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
            StrictMode.setThreadPolicy(
                StrictMode.ThreadPolicy.Builder()
                    .detectDiskReads()
                    .detectDiskWrites()
                    .detectNetwork()
                    .penaltyLog()
                    .build()
            )
        }
        super.onCreate()
    }
}

एक महत्वपूर्ण डायग्नोस्टिक सीमा पर ध्यान दें: चूंकि ContentProvider.onCreate() Application.onCreate() से पहले निष्पादित होता है, इसलिए Application.onCreate() के अंदर StrictMode सक्षम करने से शुरुआती ContentProvider स्टार्टअप के अंदर डिस्क या नेटवर्क उल्लंघन का पता नहीं चलता है। Application और Activity मेन-थ्रेड कार्य के लिए एक सहायक चेक के रूप में StrictMode का उपयोग करें, और bindApplication और ContentProvider इंस्टैंशिएशन विलंबता का निरीक्षण करने के लिए Perfetto या Android Studio CPU प्रोफाइलर सिस्टम ट्रेस कैप्चर करें।

Xcode Instruments में हिच और स्टार्टअप बॉटलनैक की पहचान करना

iOS पर, Apple के Diagnosing Performance Issues Early और Understanding Hitches in Your App पर मार्गदर्शन का पालन करते हुए, बदलाव शिप करने से पहले Xcode Instruments का उपयोग करके स्टार्टअप देरी का निदान करें:

  • ऐप लॉन्च टेम्पलेट: dyld गतिशील लाइब्रेरी लोडिंग, स्थैतिक इनिशियलाइज़र, didFinishLaunchingWithOptions, और पहले कोर एनिमेशन कमिट में लॉन्च समय को विभाजित करने के लिए भौतिक रिलीज-मोड डिवाइस पर App Launch इंस्ट्रूमेंट चलाएं।
  • टाइम प्रोफाइलर निरीक्षण: कॉल ट्री को Main Thread (com.apple.main-thread) द्वारा फ़िल्टर करें और पहले फ्रेम कमिट से पहले निष्पादित होने वाले सिंक्रोनस एसडीके कॉल, JSON पार्सिंग, या UIPasteboard प्रतीक्षा को देखने के लिए कॉल ट्री को इनवर्ट करें या सिस्टम लाइब्रेरी को छिपाएं।
  • क्रैश लॉग ट्राइएज: अपवाद कोड 0x8badf00d के साथ EXC_CRASH (SIGKILL) के लिए Xcode Organizer क्रैश रिपोर्ट का निरीक्षण करें। तृतीय-पक्ष फ़्रेमवर्क इनिशियलाइज़ेशन के अंदर ट्रिगर होने वाली ब्लॉकिंग प्रतीक्षा (__psynch_cvwait, _dispatch_once_wait, या semaphore_wait_trap) के लिए क्रैश हुए मेन-थ्रेड बैकट्र्रेस की जांच करें।

स्टार्टअप प्रदर्शन मापन टेम्पलेट

किसी एसडीके ऑप्टिमाइजेशन को सफल घोषित करने से पहले, समान भौतिक उपकरणों और रिलीज बिल्ड कॉन्फ़िगरेशन के खिलाफ पुनरुत्पादित प्लेटफॉर्म-विशिष्ट बेसलाइन मेट्रिक्स रिकॉर्ड करें:

Android और iOS स्टार्टअप ट्रेसेज़ मुख्य निष्पादन थ्रेड्स पर ब्लॉकिंग ऑपरेशन्स को अलग करते हैं।

प्लेटफॉर्म लक्ष्य मीट्रिक मापन टूल ऑप्टिमाइजेशन से पहले की बेसलाइन ऑप्टिमाइजेशन के बाद का लक्ष्य
Android टाइम टू इनिशियल डिस्प्ले (TTID) Perfetto / Android Vitals कोल्ड-स्टार्ट मीडियन और P95 (ms) रिकॉर्ड करें कोल्ड-स्टार्ट मीडियन और P95 (ms) रिकॉर्ड करें
Android टाइम टू फुल डिस्प्ले (TTFD) reportFullyDrawn() / Perfetto इंटरैक्टिव स्थिति तक रिकॉर्ड करें (ms) इंटरैक्टिव स्थिति तक रिकॉर्ड करें (ms)
Android मेन-थ्रेड इनिशियलाइज़ेशन और ANR दर CPU प्रोफाइलर / Vitals UI थ्रेड समय (ms) और ANR % रिकॉर्ड करें UI थ्रेड समय (ms) और ANR % रिकॉर्ड करें
iOS ऐप लॉन्च अवधि Xcode App Launch Instrument पहले कमिट तक लॉन्च रिकॉर्ड करें (ms) पहले कमिट तक लॉन्च रिकॉर्ड करें (ms)
iOS हिच रेट और वॉचडॉग (0x8badf00d) Xcode Organizer / Time Profiler हिच रेट (ms/s) और क्रैश % रिकॉर्ड करें हिच रेट (ms/s) और क्रैश % रिकॉर्ड करें

Jetpack App Startup और Coroutines के साथ Android SDK इनिशियलाइज़ेशन को ऑप्टिमाइज़ करना

androidx.startup के साथ ईगर ContentProvider ओवरहेड को बदलना

जब कई लाइब्रेरी को एकीकृत किया जाता है, तो प्रत्येक स्टैंडअलोन ContentProvider Application.onCreate() निष्पादित होने से पहले स्टार्टअप ओवरहेड जोड़ता है। Android Jetpack App Startup library संगत Initializer<T> घटकों को एक एकल साझा InitializationProvider में समेकित करती है और लेज़ी, ऑन-डिमांड इनिशियलाइज़ेशन का समर्थन करती है।

Jetpack App Startup का उपयोग करते समय दो महत्वपूर्ण बाधाओं पर ध्यान दें:

  • Initializer<T> केवल androidx.startup में एकीकृत लाइब्रेरी को नियंत्रित करता है; यह विरासत वाले तीसरे पक्ष के एसडीके द्वारा भेजे गए स्वतंत्र ContentProvider घोषणाओं को स्वचालित रूप से अक्षम नहीं करता है (जिन्हें यदि एसडीके विक्रेता द्वारा अनुमति दी जाती है तो मर्ज किए गए मेनिफेस्ट में निरीक्षण किया जाना चाहिए और अलग से हटाया या समायोजित किया जाना चाहिए)।
  • InitializationProvider के अंदर किसी <meta-data> प्रविष्टि में केवल तभी tools:node="remove" जोड़ें जब वह सटीक घटक वास्तव में मर्ज किए गए मेनिफेस्ट में स्वचालित खोज के लिए घोषित किया गया हो—और सत्यापित करें कि कोई अन्य स्वतः-खोजा गया इनिशियलाइज़र इसे dependencies() के भीतर सूचीबद्ध नहीं करता है।
<!-- Manifest Fragment: Merge into your existing AndroidManifest.xml ONLY if OnboardingCacheInitializer is registered for auto-discovery -->
<!-- Requires androidx.startup:startup-runtime:1.2.0+ and xmlns:tools="http://schemas.android.com/tools" -->
<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data
        android:name="com.example.hostapp.startup.OnboardingCacheInitializer"
        android:value="androidx.startup"
        tools:node="remove" />
</provider>

थ्रेड-सेफ लेज़ी इनिशियलाइज़ेशन और getInstallParam शेड्यूलिंग

Android पर एट्रिब्यूशन एसडीके को ऑप्टिमाइज़ करते समय, विक्रेता के लाइफसाइकेल और थ्रेड अनुबंधों का सम्मान करें:

  • कोर एसडीके इनिशियलाइज़ेशन और प्रोसेस गार्ड: एट्रिब्यूशन एसडीके—जैसे OpoInstall, एक मोबाइल एट्रिब्यूशन और डीप लिंकिंग प्लेटफॉर्म—Application.onCreate() के अंदर OpoInstall.initialize(this) और लॉन्चर Activity के अंदर OpoInstall.getInstance().start(this) को कॉल करने का दस्तावेजीकरण करते हैं। मल्टी-प्रोसेस आर्किटेक्चर में, इनिशियलाइज़ेशन मुख्य प्रक्रिया तक सीमित होना चाहिए; नीचे दिया गया OptimizedAttributionApp एक अमूर्त अनुबंध है—होस्ट एप्लिकेशनों को isMainProcess() को लागू करने वाला एक ठोस सबक्लास प्रदान करना चाहिए और उस सबक्लास को AndroidManifest.xml में पंजीकृत करना चाहिए। कोर एसडीके इनिशियलाइज़ेशन को किसी मनमाने बैकग्राउंड थ्रेड पर न ले जाएं या Activity.onCreate() से आगे तब तक स्थगित न करें जब तक कि सटीक एसडीके संस्करण स्पष्ट रूप से थ्रेड-सेफ लेज़ी समर्थन का दस्तावेजीकरण न करता हो।
  • ऐप स्टार्टअप थ्रेड अनुबंध: Initializer.create() को हल्का रखें और घटक के प्रलेखित अनुबंध द्वारा समर्थित थ्रेड पर AppInitializer.initializeComponent() को लागू करें। हर Initializer सुरक्षित रूप से Dispatchers.IO पर निष्पादित हो सकता है यह मानने के बजाय महंगे होस्ट-स्वामित्व वाले डिस्क या CPU कार्य को अलग से प्रबंधित बैकग्राउंड संचालन (Dispatchers.IO या Dispatchers.Default) में ले जाएं।
  • व्यावसायिक मील के पत्थरों पर getInstallParam शेड्यूल करना: परिणाम का उपभोग करने वाले व्यावसायिक मील के पत्थर पर स्थगित एट्रिब्यूशन पुनर्प्राप्ति शेड्यूल करें। एक View.post कॉलबैक यह गारंटी नहीं देता है कि पहला फ्रेम प्रस्तुत किया गया है; यदि पुनर्प्राप्ति प्रारंभिक प्रदर्शन के तुरंत बाद शुरू होनी चाहिए, तो मापा गया फ्रेम-अवेयर शेड्यूलिंग (जैसे Choreographer फ्रेम कॉलबैक के साथ reportFullyDrawn() और Perfetto TTID ट्रेसेज़) का उपयोग करें।
  • इम्यूटेबल स्नैपशॉट और यूनिफाइड थ्रेडिंग: चूंकि एसडीके कॉलबैक थ्रेड सहबद्धता (affinity) और ऑब्जेक्ट परिवर्तनशीलता (mutability) एसडीके रिलीज के अनुसार भिन्न हो सकती है, इसलिए opoData?.data को कॉलबैक सीमा पर ही एक इम्यूटेबल String में सीरियलाइज या स्नैपशॉट करें, इससे पहले कि इसे Dispatchers.Default को पास किया जाए, और राज्य संक्रमण (AttributionFetchState) को स्पष्ट रूप से UI थ्रेड (runOnUiThread / Dispatchers.Main) पर मार्शाल करें। इम्यूटेबल स्नैपशॉट निर्माण से म्यूटेबल डेटा को थ्रेड सीमाओं को पार करने से रोका जा सकता है, लेकिन इसकी सीरियलाइजेशन लागत को अभी भी एसडीके कॉलबैक थ्रेड पर प्रोफाइल किया जाना चाहिए। इसके अतिरिक्त, सत्यापित करें कि तैनात एसडीके कॉलबैक के दौरान डेटा स्थिरता की गारंटी देता है या विक्रेता की प्रलेखित सिंक्रनाइज़ेशन सीमा के भीतर स्नैपशॉटिंग निष्पादित करता है।

जब मोबाइल मेन थ्रेड अपना पहला फ्रेम रेंडर करता है, तो बैकग्राउंड इनिशियलाइज़ेशन अलग से चलता है।

संदर्भ वास्तुकला अस्वीकरण: निम्नलिखित कोटलिन कार्यान्वयन एक रक्षात्मक संदर्भ वास्तुकला है। डायग्नोस्टिक Application (StrictModeDiagnosticsApp) और एट्रिब्यूशन Application (OptimizedAttributionApp) अलग-अलग संदर्भ स्निपेट हैं; उनके व्यवहार को आपके एप्लिकेशन के एकल ठोस Application क्लास में मर्ज करें जो AndroidManifest.xml में पंजीकृत है। प्रोडक्शन रोलआउट से पहले अपने तैनात AAR के खिलाफ सटीक एसडीके पैकेज नाम (com.opoinstall.api), इनिशियलाइज़ेशन थ्रेड बाधाओं, R संसाधन नेमस्पेस आयात, और Jetpack App Startup संस्करणों (androidx.startup:startup-runtime:1.2.0+) को सत्यापित करें।

// Android - AttributionStartupOptimization.kt
// Reference architecture: targets minSdk >= 24 with kotlinx-coroutines-android and androidx.startup:startup-runtime:1.2.0+
package com.example.hostapp.startup

import android.app.Application
import android.content.Context
import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import androidx.startup.AppInitializer
import androidx.startup.Initializer
import com.example.hostapp.R
import com.opoinstall.api.OpoData
import com.opoinstall.api.OpoError
import com.opoinstall.api.OpoInstall
import com.opoinstall.api.ResultCallBack
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.json.JSONObject

// 1. Lazy Jetpack App Startup Initializer for lightweight host onboarding manager creation
// Exclude from automatic discovery via tools:node="remove" in AndroidManifest.xml if auto-merged
class OnboardingCacheInitializer : Initializer<OnboardingCacheManager> {
    override fun create(context: Context): OnboardingCacheManager {
        // Instantiates lightweight handle on caller's supported thread; heavy CPU/IO work runs asynchronously below
        return OnboardingCacheManager(context.applicationContext)
    }

    override fun dependencies(): List<Class<out Initializer<*>>> = emptyList()
}

class OnboardingCacheManager(private val appContext: Context) {
    // Runs CPU-bound JSON parsing solely on an already-copied immutable String snapshot
    suspend fun parsePromoCodeFromImmutableJson(immutableJson: String): String? = withContext(Dispatchers.Default) {
        runCatching {
            JSONObject(immutableJson).optString("promoCode").takeIf { it.isNotBlank() }
        }.getOrNull()
    }
}

// 2. Host-Owned Multi-Process Guard Integration Point
// Provide a concrete subclass implementing isMainProcess(), merge any debug StrictMode checks into it,
// register it in AndroidManifest.xml, and do not return an unconditional `true` in multi-process apps.
abstract class OptimizedAttributionApp : Application() {
    protected abstract fun isMainProcess(): Boolean

    override fun onCreate() {
        super.onCreate()
        if (isMainProcess()) {
            OpoInstall.initialize(this)
        }
    }
}

// 3. Deferred Attribution Activity with Explicit Request State Machine & Immutable Snapshots
class OnboardingActivity : AppCompatActivity() {

    private enum class AttributionFetchState {
        IDLE, LOADING, COMPLETED, RETRYABLE_FAILURE
    }

    // For multi-screen flows, persist fetch state in a lifecycle-surviving ViewModel or Repository
    private var fetchState: AttributionFetchState = AttributionFetchState.IDLE
    private var onboardingCacheManager: OnboardingCacheManager? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_onboarding)

        // Register the SDK lifecycle according to the vendor contract; profile this call to verify its main-thread cost
        OpoInstall.getInstance().start(this)

        // Trigger deferred retrieval at the explicit onboarding business milestone (e.g., button tap)
        findViewById<android.view.View>(R.id.btn_claim_referral)?.setOnClickListener {
            fetchDeferredParametersIfNeeded()
        }
    }

    private fun fetchDeferredParametersIfNeeded() {
        if (fetchState == AttributionFetchState.LOADING || fetchState == AttributionFetchState.COMPLETED) {
            return
        }
        fetchState = AttributionFetchState.LOADING

        // Initialize lightweight host component on main thread per App Startup contract
        val cacheManager = onboardingCacheManager ?: AppInitializer.getInstance(applicationContext)
            .initializeComponent(OnboardingCacheInitializer::class.java)
            .also { onboardingCacheManager = it }

        OpoInstall.getInstance().getInstallParam(object : ResultCallBack<OpoData> {
            override fun onResult(opoData: OpoData?) {
                // Immutable snapshot creation prevents mutable data from crossing thread boundaries,
                // though its serialization cost must still be profiled on the SDK callback thread.
                val immutableJsonSnapshot: String? = snapshotAsImmutableJson(opoData?.data)
                val hasChannel = !opoData?.channelCode.isNullOrBlank()
                Log.d("AttributionPerf", "Async callback resolved: hasData=${immutableJsonSnapshot != null}, hasChannel=$hasChannel")

                runOnUiThread {
                    if (isFinishing || isDestroyed) return@runOnUiThread

                    if (immutableJsonSnapshot == null) {
                        fetchState = AttributionFetchState.COMPLETED
                        return@runOnUiThread
                    }

                    lifecycleScope.launch {
                        // Offload CPU-bound JSON parsing using the immutable String snapshot
                        val promoCode = cacheManager.parsePromoCodeFromImmutableJson(immutableJsonSnapshot)

                        // Update UI and final state safely on Main dispatcher
                        withContext(Dispatchers.Main) {
                            if (!isFinishing && !isDestroyed) {
                                fetchState = AttributionFetchState.COMPLETED
                                if (promoCode != null) {
                                    // Apply promoCode to onboarding UI safely
                                }
                            }
                        }
                    }
                }
            }

            override fun onError(error: OpoError?) {
                runOnUiThread {
                    if (!isFinishing && !isDestroyed) {
                        fetchState = AttributionFetchState.RETRYABLE_FAILURE
                    }
                }
                Log.w("AttributionPerf", "Deferred parameter fetch encountered an error state")
            }
        })
    }

    private fun snapshotAsImmutableJson(rawData: Any?): String? = when (rawData) {
        is String -> rawData.takeIf { it.isNotBlank() }
        is JSONObject -> rawData.toString()
        is Map<*, *> -> runCatching {
            if (rawData.keys.any { it !is String }) null
            else {
                val safeMap = mutableMapOf<String, Any?>()
                rawData.forEach { (k, v) -> safeMap[k as String] = v }
                JSONObject(safeMap).toString()
            }
        }.getOrNull()
        else -> null
    }
}

बैकग्राउंड डिस्पैच कतारों के साथ iOS SDK इनिशियलाइज़ेशन को ऑप्टिमाइज़ करना

Swift में didFinishLaunchingWithOptions को नॉन-ब्लॉकिंग रखना

iOS पर, SpringBoard द्वारा लॉन्च पूरा होने से पहले application(_:didFinishLaunchingWithOptions:) मेन थ्रेड पर सिंक्रोनस रूप से निष्पादित होता है। ध्यान दें कि नीचे दिया गया AppDelegate स्निपेट एक सरलीकृत गैर-दृश्य (non-scene) सेटअप का प्रतिनिधित्व करता है; UIScene / SceneDelegate लाइफसाइकेल को अपनाने वाले एप्लिकेशनों को सक्रिय दृश्य विंडो में एट्रिब्यूशन ट्रिगर का समन्वय करना चाहिए। 0x8badf00d वॉचडॉग टर्मिनेशन से बचने के लिए:

  • सिम्फोर्स या लॉक के साथ कभी ब्लॉक न करें: लॉन्च के दौरान मेन क्यू पर कभी भी DispatchSemaphore.wait(), सिंक्रोनस URLSession डेटा टास्क, या सिंक्रोनस डिस्क लॉक का उपयोग न करें।
  • प्रायोरिटी इनवर्जन से बचें: ऐसे इनिशियलाइज़ेशन कार्यों को .background QoS कतारों (DispatchQueue.global(qos: .background)) में न भेजें जिन पर UI को जल्द ही निर्भर होना पड़ेगा। यदि मेन-थ्रेड ऑपरेशन बाद में कम प्राथमिकता वाली .background कतार की प्रतीक्षा करता है, तो प्रायोरिटी इनवर्जन UI को रोक देता है। होस्ट बैकग्राउंड तैयारी कार्यों के लिए .utility या .userInitiated QoS का उपयोग करें।
  • एक्टर आइसोलेशन का सम्मान करें: Swift 6 सख्त समवर्तीता (concurrency) में, बैकग्राउंड कतार क्लोजर के अंदर @MainActor-आइसोलेटेड AppDelegate इंस्टेंस (self) को कैप्चर करने से बचें; होस्ट-स्वामित्व वाले कैश वार्मिंग को एक आइसोलेटेड, नॉन-मेन-एक्टर सेवा (HostCacheService) को प्रत्यायोजित करें जिसमें कोई UIKit कॉल या अनसिंक्रनाइज़्ड म्यूटेबल स्टेट नहीं है, और @MainActor पर स्विच करने से पहले नॉन-आइसोलेटेड ऑब्जेक्टिव-सी डेलीगेट कॉलबैक को स्पष्ट रूप से (nonisolated) चिह्नित करें।

iOS पर UIPasteboard, इम्यूटेबल स्नैपशॉट और अनुरोध स्थिति को प्रबंधित करना

iOS 14 और बाद के संस्करणों पर, UIPasteboard.general को पढ़ने से एक सिस्टम पेस्ट नोटिफिकेशन बैनर प्रदर्शित होता है, और iOS 16+ पर, क्रॉस-ऐप पेस्टबोर्ड रीड उपयोगकर्ता को स्पष्ट पेस्ट अनुमति के लिए संकेत देते हैं। इसके अतिरिक्त, यदि यूनिवर्सल क्लिपबोर्ड (Handoff) सक्रिय है, तो ब्लूटूथ या वाई-फाई पर रिमोट पेलोड फेच करते समय सिंक्रोनस क्लिपबोर्ड निरीक्षण विलंबता पेश कर सकता है।

एक रेंडर किया गया मोबाइल इंटरफ़ेस एक एसिंक्रोनस कॉलबैक के माध्यम से स्थगित एट्रिब्यूशन संदर्भ प्राप्त करता है।

रूट व्यू कंट्रोलर के रेंडर होने से पहले एट्रिब्यूशन पैरामीटर पढ़ने के बजाय, getInstallParmsCompleted को तब तक के लिए टाल दें जब तक कि ऑनबोर्डिंग व्यू दिखाई न दे (और Instruments के माध्यम से अलग से वास्तविक TTID को मापें)। स्पष्ट AttributionFetchState (idle, loading, completed, retryableFailure) के साथ अनुरोध लाइफसाइकेल को सुचारू रूप से प्रबंधित करें, .loading पर जाने से पहले सत्यापित करें कि OpoInstallSDK.defaultManager() नॉन-निल है ताकि एक निल मैनेजर व्यू कंट्रोलर को कभी भी स्थायी .loading स्थिति में लॉक न करे। एसडीके कॉलबैक के भीतर, समवर्ती सीमाओं को पार करने से पहले केवल इम्यूटेबल Sendable प्रिमिटिव (hadResponse, rawPromoSnapshot) निकालें—नॉन-Sendable appData ऑब्जेक्ट को बैकग्राउंड या बाद के एसिंक्रोनस क्लोजर में कभी भी कैप्चर न करें—और isViewLoaded, view.window != nil, और activeRequestGeneration की जाँच करते हुए Task { @MainActor ... } के माध्यम से साफ-सुथरे तरीके से वापस लौटें।

संदर्भ वास्तुकला अस्वीकरण: निम्नलिखित स्विफ्ट कार्यान्वयन एक रक्षात्मक संदर्भ वास्तुकला है। अपने तैनात फ्रेमवर्क संस्करण के खिलाफ सटीक एसडीके मॉड्यूल आयात (libOpoInstallSDK), डेलीगेट प्रोटोकॉल (OpoInstallDelegate), डेटा-मॉडल क्लास नाम (OpoinstallData बनाम OpoInstallData), और Swift 5.9/6.0 सख्त समवर्तीता अनुपालन को सत्यापित करें।

// iOS - NonBlockingAttributionStartup.swift
// Reference architecture: compile and test against your specific iOS target (iOS 15.0–18.0)
// Simplified AppDelegate example; adapt lifecycle triggers if using UIScene / SceneDelegate.
import UIKit
import libOpoInstallSDK

// Isolated host cache service free of @MainActor self captures for Swift 6 compatibility
private enum HostCacheService {
    static func prepareLocalCaches() {
        // Host-owned background configuration or cache preparation; ensure implementations
        // avoid UIKit, @MainActor-isolated properties, and unsynchronized mutable globals.
    }
}

@main
final class AppDelegate: UIResponder, UIApplicationDelegate, OpoInstallDelegate {

    var window: UIWindow?

    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        // 1. Register SDK delegate cleanly without synchronous network or disk locks
        OpoInstallSDK.initWith(self)

        // 2. Offload host-owned non-UI startup preparation without capturing @MainActor self
        DispatchQueue.global(qos: .utility).async {
            HostCacheService.prepareLocalCaches()
        }

        return true
    }

    // Marked nonisolated to satisfy Swift 6 concurrency if invoked off the main actor
    nonisolated func getWakeUpParams(_ appData: OpoinstallData?) {
        let hasData = (appData?.data != nil)
        let hasChannel = (appData?.channelCode != nil)
        print("[AttributionPerf] Wakeup params resolved (hasData: \(hasData), hasChannel: \(hasChannel))")

        Task { @MainActor in
            // Route to target scene safely on MainActor
        }
    }
}

@MainActor
final class OnboardingViewController: UIViewController {

    private enum AttributionFetchState {
        case idle
        case loading
        case completed
        case retryableFailure
    }

    private var fetchState: AttributionFetchState = .idle
    private var activeRequestGeneration: UInt64 = 0

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        // Trigger deferred parameter retrieval after the onboarding view appears
        // (measure exact cold-start TTID separately using Xcode Instruments)
        fetchDeferredAttributionIfNeeded()
    }

    private func fetchDeferredAttributionIfNeeded() {
        // Prevent duplicate concurrent requests across repeated viewDidAppear calls
        guard fetchState == .idle || fetchState == .retryableFailure else {
            return
        }

        // Verify SDK manager availability BEFORE entering .loading to prevent permanent state starvation
        guard let manager = OpoInstallSDK.defaultManager() else {
            fetchState = .retryableFailure
            return
        }

        fetchState = .loading
        activeRequestGeneration &+= 1
        let requestGeneration = activeRequestGeneration

        manager.getInstallParmsCompleted { [weak self] appData in
            // Snapshot immutable Sendable values immediately inside callback; do NOT capture appData across queues
            let hadResponse = (appData != nil)
            let hasData = (appData?.data != nil)
            let hasChannel = (appData?.channelCode != nil)
            let rawPromoSnapshot = appData?.data?["promoCode"] as? String
            print("[AttributionPerf] Deferred params resolved (hasData: \(hasData), hasChannel: \(hasChannel))")

            DispatchQueue.global(qos: .userInitiated).async { [weak self, hadResponse, rawPromoSnapshot] in
                // Perform any expensive host normalization solely on the immutable String snapshot
                let normalizedPromo = rawPromoSnapshot?.trimmingCharacters(in: .whitespacesAndNewlines)

                Task { @MainActor [weak self, hadResponse, normalizedPromo] in
                    guard let self = self else { return }

                    // Ignore stale callbacks if superseded by a newer request
                    guard self.activeRequestGeneration == requestGeneration else { return }

                    if !hadResponse {
                        self.fetchState = .retryableFailure
                        return
                    }

                    self.fetchState = .completed
                    guard self.isViewLoaded,
                          self.view.window != nil,
                          let code = normalizedPromo,
                          !code.isEmpty else {
                        return
                    }
                    self.applyOnboardingPromo(code)
                }
            }
        }
    }

    private func applyOnboardingPromo(_ code: String) {
        // Update onboarding UI on MainActor
    }
}

मोबाइल एसडीके इनिशियलाइज़ेशन रणनीतियों का तुलनात्मक विश्लेषण

कोल्ड-स्टार्ट विलंबता, कार्यान्वयन जटिलता और एट्रिब्यूशन readiness का मूल्यांकन

इष्टतम इनिशियलाइज़ेशन पैटर्न का चयन करना कोल्ड-स्टार्ट फ्रेम बजट को उस समय के विरुद्ध संतुलित करता है जब उपयोगकर्ता यात्रा में एट्रिब्यूशन पैरामीटर की आवश्यकता होती है:

इनिशियलाइज़ेशन रणनीति मेन-थ्रेड ब्लॉकिंग जोखिम कोल्ड-स्टार्ट TTID प्रभाव एट्रिब्यूशन Readiness कार्यान्वयन जटिलता सबसे उपयुक्त परिदृश्य
ईगर ContentProvider ऑटो-इनिट उच्च जब प्रोवाइडर Application.onCreate से पहले I/O करते हैं प्रदानकर्ता के कार्य के समानुपातिक रूप से लॉन्च में देरी करता है लॉन्च होने पर तुरंत न्यूनतम (शून्य कोड) मैन्युअल इनिट API की कमी वाले लिगेसी मॉड्यूल
सिंक्रोनस Application.onCreate इनिट मध्यम से उच्च यदि डिस्क या नेटवर्क कार्य सिंक्रोनस रूप से चलता है भारी होने पर पहली गतिविधि ड्रा में देरी करता है लॉन्च होने पर तुरंत कम शून्य डिस्क/नेटवर्क I/O करने वाले पतले पंजीकरण रैपर
बैकग्राउंड कतार / कोरोटीन ऑफलोडिंग कम जब महंगा काम थ्रेड-सुरक्षित हो, महत्वपूर्ण पथ से बाहर ले जाया गया हो, और ब्लॉकिंग निर्भरता से बचा जाता हो तेज TTID संरक्षित करता है एसिंक्रोनस (इनिट के बाद तैयार) मध्यम प्रोडक्शन एट्रिब्यूशन और एनालिटिक्स एसडीके एकीकरण
Jetpack App Startup लेज़ी Initializer कम जब घटक निर्माण हल्का और स्थगित हो जब इनिशियलाइज़र गैर-महत्वपूर्ण हो और लॉन्च पथ से परे वास्तव में स्थगित हो तो TTID को कम कर सकता है; स्टार्टअप ट्रेसेज़ के साथ सत्यापित करें सुविधा प्रविष्टि तक स्थगित मध्यम होस्ट ऑनबोर्डिंग कैश और गैर-महत्वपूर्ण द्वितीयक मॉड्यूल

OpoInstall जैसे प्लेटफॉर्म एसिंक्रोनस कॉलबैक API (getInstallParam और getInstallParmsCompleted) के चारों ओर पैरामीटर पुनर्प्राप्ति की संरचना करते हैं ताकि एप्लिकेशन प्रारंभिक UI रेंडरिंग को स्थगित पैरामीटर समाधान से अलग कर सकें।

अक्सर पूछे जाने वाले प्रश्न (FAQ)

Android StrictMode Application onCreate में मोबाइल एसडीके इनिशियलाइज़ेशन को क्यों फ्लैग करता है?
Android `StrictMode.ThreadPolicy` इनिशियलाइज़ेशन कोड को तब फ्लैग करता है जब यह `Application.onCreate()` के अंदर मुख्य UI थ्रेड पर सिंक्रोनस रूप से `SharedPreferences` को पढ़ता या लिखता है, SQLite डेटाबेस खोलता है, फ़ाइल सिस्टम गुणों को पढ़ता है, या नेटवर्क सॉकेट खोलता है। होस्ट-स्वामित्व वाले I/O को बैकग्राउंड कोरोटीन डिस्पैचर्स (`Dispatchers.IO`) पर ऑफलोड करना और Jetpack App Startup (`androidx.startup`) के माध्यम से भारी द्वितीयक होस्ट मॉड्यूल को स्थगित करना होस्ट-स्वामित्व वाले उल्लंघनों को समाप्त कर सकता है और स्टार्टअप के दौरान मेन-थ्रेड कार्य को कम कर सकता है।
iOS डेवलपर्स तीसरे पक्ष के एसडीके के कारण होने वाले 0x8badf00d वॉचडॉग क्रैश से कैसे बच सकते हैं?
लॉन्च के दौरान `0x8badf00d` वॉचडॉग टर्मिनेशन को रोकने के लिए, सुनिश्चित करें कि `application(_:didFinishLaunchingWithOptions:)` और `scene(_:willConnectTo:options:)` सिंक्रोनस नेटवर्क अनुरोधों, `DispatchSemaphore.wait()`, भारी JSON पार्सिंग, या सिंक्रोनस `UIPasteboard` रीड पर मुख्य कतार को कभी ब्लॉक न करें। हल्के डेलीगेट्स को साफ-सुथरे तरीके से पंजीकृत करें, होस्ट तैयारी को `.utility` बैकग्राउंड कतारों में ऑफलोड करें, और ऑनबोर्डिंग UI दिखाई देने के बाद एट्रिब्यूशन पैरामीटर को एसिंक्रोनस रूप से क्वेरी करें।
स्टार्टअप लैग से बचने के लिए किसी ऐप को getInstallParam या getInstallParmsCompleted कब कॉल करना चाहिए?
`Application.onCreate()` के अंदर या पहले फ्रेम के कमिट होने से पहले कोल्ड स्टार्ट को ब्लॉक करने के बजाय, जब उपयोगकर्ता विशिष्ट ऑनबोर्डिंग या रेफरल मील के पत्थर में प्रवेश करता है जो पैरामीटर का उपभोग करता है, तो `getInstallParam` (Android) या `getInstallParmsCompleted` (iOS) को एसिंक्रोनस रूप से लागू करें। क्वेरी को स्थगित करने से एसिंक्रोनस नेटवर्क उपलब्धता और अनुमति राज्यों को साफ-सुथरे तरीके से संभालते हुए कोल्ड-स्टार्ट रेंडर पाथ अनब्लॉक रहता है।

सारांश और निर्णय फ्रेमवर्क

मोबाइल एसडीके इनिशियलाइज़ेशन के दौरान मेन थ्रेड ब्लॉकिंग को रोकने के लिए स्टार्टअप ट्रेसेज़ को मापने और गैर-UI कार्यों को एप्लिकेशन के महत्वपूर्ण लॉन्च पाथ से अलग करने की आवश्यकता होती है। Android StrictMode और Xcode Instruments के साथ कोल्ड स्टार्ट को प्रोफाइल करके, लेज़ी Jetpack App Startup इनिशियलाइज़र या आइसोलेटेड बैकग्राउंड कतारों के साथ गैर-महत्वपूर्ण होस्ट घटकों को समेकित करके, और सक्रिय व्यावसायिक मील के पत्थरों पर स्पष्ट राज्य मशीनों और इम्यूटेबल स्नैपशॉट के साथ एसिंक्रोनस रूप से स्थगित पैरामीटर क्वेरी (getInstallParam / getInstallParmsCompleted) को ट्रिगर करके, ये पैटर्न कोल्ड स्टार्ट के दौरान रोके जाने योग्य मेन-थ्रेड कंटेंशन को कम कर सकते हैं; हालांकि, TTID, TTFD, ANR घटनाओं और iOS वॉचडॉग टर्मिनेशन पर उनका सटीक प्रभाव प्लेटफॉर्म प्रोफाइलिंग और डिवाइस प्रतिगमन परीक्षणों के साथ स्थापित किया जाना चाहिए।

मोबाइल एट्रिब्यूशन लाइफसाइकेल और स्थगित डीप-लिंकिंग ऑनबोर्डिंग प्रवाह को ऑप्टिमाइज़ करने वाली टीमें एसिंक्रोनस एसडीके एकीकरण पैटर्न के लिए OpoInstall प्लेटफॉर्म ओवरव्यू से परामर्श कर सकती हैं।

इकाई शब्दावली (Entity Glossary)

शब्द परिभाषा संबंधित इकाई खोज इरादा भूमिका
Mobile SDK एट्रिब्यूशन, एनालिटिक्स या रूटिंग के लिए मोबाइल ऐप्स में एकीकृत एक संकलित सॉफ्टवेयर डेवलपमेंट किट। Android SDK / iOS SDK सूचनात्मक / तकनीकी
Main Thread UI रेंडरिंग और उपयोगकर्ता इनपुट घटनाओं को संभालने के लिए जिम्मेदार प्राथमिक निष्पादन थ्रेड। DispatchQueue.main / Looper तकनीकी
StrictMode एक एंड्रॉइड डेवलपर टूल जो मुख्य थ्रेड पर आकस्मिक डिस्क या नेटवर्क संचालन का पता लगाता है। StrictMode.ThreadPolicy तकनीकी
Watchdog Termination iOS पर एक OS-आरंभित क्रैश (0x8badf00d) जो तब ट्रिगर होता है जब कोई ऐप लॉन्च या लाइफसाइकेल ट्रांजिशन के दौरान मुख्य थ्रेड को ब्लॉक करता है। SpringBoard / FrontBoard तकनीकी
Jetpack App Startup लेज़ी-लोडिंग समर्थन के साथ घटक इनिशियलाइज़र को एक एकल ContentProvider में समेकित करने वाली एक AndroidX लाइब्रेरी। androidx.startup तकनीकी

संगतता बेसलाइन और सत्यापन स्थिति

  • अभीष्ट संगतता लक्ष्य: Android minSdk 24, compileSdk 34/35, targetSdk 34/35 (Android 14/15), androidx.startup:startup-runtime:1.2.0+, Kotlin Coroutines; iOS 15.0–18.0, Xcode 15/16, Swift 5.9/6.0.

  • सत्यापन स्थिति:

    • स्टेटिक API और विनिर्देश समीक्षा: Android Developers और Apple Developer दस्तावेज़ीकरण के विरुद्ध पूर्ण।

    • संकलन और डिवाइस सत्यापन: इस समीक्षा चक्र में अभी तक निष्पादित नहीं किया गया है। प्रोडक्शन रिलीज से पहले आपकी इंजीनियरिंग टीम द्वारा संकलन-समय के निर्माण (Swift 6 सख्त समवर्तीता जाँच और सटीक AAR एकीकरण सहित) और भौतिक-डिवाइस स्टार्टअप प्रोफाइलिंग (Android Perfetto / StrictMode और Xcode App Launch Instruments) को निष्पादित किया जाना चाहिए।

संदर्भ

Share this article