ربط قيم تحويل SKAdNetwork: أتمتة مخططات SKAN الديناميكية

كيف يقوم شريك القياس المحمول (MMP) بربط مخططات SKAdNetwork تلقائياً؟ يقوم شريك القياس المحمول (MMP) أو خلفية الإسناد بأتمتة ربط مخططات SKAdNetwork عن طريق ترجمة الأحداث داخل التطبيق ومستويات الإيرادات إلى مخططات تكوين JSON ديناميكية ومؤرخة الإصدارات على وحدة تحكم مركزية. تسترجع حزمة تطوير البرامج (SDK) للهاتف المحمول هذا التكوين عند الإطلاق وتقيم قواعد التحويل محلياً وقت التشغيل، مما يسمح للتغييرات المدعومة في قواعد التحويل بالدخول حيز التنفيذ دون الحاجة إلى إصدار ثنائي جديد للتطبيق.

مخطط قيمة تحويل SKAdNetwork هو مجموعة قواعد على مستوى البائع أو التطبيق تربط سلوكيات المستخدم داخل التطبيق—مثل معاملات الإيرادات، أو مراحل الإعداد، أو تفاعل الميزات—بقيمة آapple الدقيقة ذات 6 بت (من 0 إلى 63) والقيم الإجمالية ذات 3 مستويات (low، medium، high). تقوم بنيات الربط الديناميكي بتوزيع ملفات التكوين المؤرخة من السحابة الخلفية إلى حزمة SDK للعميل، مما يلغي الحاجة إلى برمجة منطق التحويل ثابتاً داخل ملفات ثنائية لتطبيقات iOS المجمعة.

بنية ربط قيم تحويل SKAdNetwork الآلي

فصل طبقة منصة Apple عن طبقة مخطط البائع

لتصميم محرك قوي لقيم التحويل، يجب على فرق الهندسة فصل قواعد إطار عمل Apple الأصلي عن تجريدات مخططات مستوى البائع:

• طبقة منصة Apple: تتحكم في العناصر الأساسية لنظام التشغيل، بما في ذلك نوافذ التحويل الثلاث المتتالية (اليوم 0–2، اليوم 3–7، اليوم 8–35 بعد الإطلاق الأول)، والقيم الدقيقة ذات 6 بت (0–63)، والقيم الإجمالية (low، medium، high)، ومستويات بيانات الإرجاع (postback)، وواجهة برمجة التطبيقات SKAdNetwork.updatePostbackConversionValue.
• طبقة مخطط البائع: تشمل قواعد العمل المحددة بواسطة التطبيق، مثل تجميع الإيرادات، وتطور مسار الإعداد، وتخصيصات العلامات ثنائية الاتجاه، والمزامنة عن بعد لملفات JSON، وتقييم القواعد من جانب العميل.

┌────────────────────────────────────────┐
│                           Vendor Schema Layer                                  │
│  [MMP / Analytics Console] ──► [Publishes Versioned JSON Configuration]     │
│                                              │                                │
│  [Client Mobile SDK]       ──► [Evaluates In-App Events Locally in Memory]  │
└──────────────────────────────────────┬─┘
                                       │ (Calculates Fine, Coarse, & Lock)
                                       ▼
┌────────────────────────────────────────┐
│                           Apple Platform Layer                                 │
│  [StoreKit Framework]      ──► [SKAdNetwork.updatePostbackConversionValue]  │
│  [Operating System]        ──► [Manages Conversion Windows & Timers]        │
│  [System]                  ──► [Prepares and Sends Signed Postback]         │
└────────────────────────────────────────┘

مخاطر منطق التحويل الثابت

إن برمجة منطق التحويل بشكل ثابت مباشرة داخل هدف تطبيق iOS يخلق قيوداً تشغيلية كبيرة:

• الاعتماد على مراجعة متجر التطبيقات (App Store Review): أي تعديل على حدود الإيرادات، أو أوزان الأحداث، أو مشغلات قفل النافذة يتطلب دورة إصدار ثنائية كاملة.
• تجزئة الإصدارات: تقوم إصدارات التطبيقات التاريخية المتعددة في الإنتاج بنقل دلالات تحويل متضاربة، مما يؤدي إلى إפסاد نماذج التقارير اللاحقة.
• عدم مرونة التحسين: لا يمكن لفرق النمو تعديل استراتيجيات التحويل بين الحملات التي تركز على التفاعل وتلك التي تركز على تحقيق الدخل استجابة لأداء التسويق في الوقت الفعلي.

خط تسليم التكوين الديناميكي

تفصل بنيات الربط الآلي منطق التحويل عن الملف الثنائي المجمّع من خلال خط أنابيب متعدد المراحل:

1. تكوين وحدة التحكم: يقوم المسوقون والمحللون بتكوين أوزان الأحداث، ومستويات العملات، وقواعد قفل النافذة على لوحة تحكم مركزية.
2. إصدار المخططات وتثبيتها: تنشر الخلفية حمولة تكوين JSON مؤرخة. لمنع الانحراف الدلالي أثناء دورة حياة تحويل المستخدم التي تبلغ 35 يوماً، يقوم تنفيذ قوي للبائع بتثبيت تكوين المخطط النشط الذي تم إنشاؤه خلال نافذة التحويل الأولية، مما يضمن بقاء قواعد الربط الدقيقة متاحة حتى عبر عمليات إعادة تشغيل التطبيق.
3. الاستيعاب والتخزين المؤقت للعميل: تقوم حزمة SDK للجوال بتنزيل المخطط النشط عند تهيئة التطبيق وتقوم بتخزين كل من حمولة التكوين وبيانات الإصدار مؤقتاً في التخزين المحلي الدائم.
4. تقييم القواعد المحلية: عند حدوث أحداث داخل التطبيق، تقيمها حزمة SDK مقابل مجموعة القواعد المخزنة مؤقتاً محلياً، دون إضافة طلب تكوين عن بعد متزامن إلى مسار تنفيذ الأحداث.

انظر أيضاً: SKAdNetwork ──> بنية الإسناد المحمول

تصميم مخططات قيمة التحويل الديناميكية عبر نوافذ SKAN 4.0

تقسيم المخططات متعددة النوافذ

ينظم SKAdNetwork 4.0 قياس التحويل عبر ثلاث نوافذ متتالية مثبتة بالإطلاق الأول للتطبيق:

• النافذة 1 (اليوم 0–2): أول 48 ساعة بعد الإطلاق الأول.
• النافذة 2 (اليوم 3–7): الساعات من 48 إلى 168 بعد الإطلاق الأول.
• النافذة 3 (اليوم 8–35): الساعات من 168 إلى 840 بعد الإطلاق الأول.

يقوم محرك المخططات الديناميكي بتقسيم القواعد عبر هذه النوافذ، وينفذ حسابات القيم المناسبة بناءً على الوقت المنقضي منذ الإطلاق الأولي للتطبيق.

النافذة 1 (اليوم 0–2): هيكلة القيم الدقيقة والإجمالية

النافذة 1 هي نافذة التحويل الوحيدة المؤهلة للإفصاح عن قيم تحويل دقيقة. يحدد التكوين الخاص بالنافذة 1 عمليتي ربط متزامنتين:

• الربط الدقيق (0–63): قواعد عالية الدقة تلتقط مستويات تحقيق الدخل الأولية، أو مراحل الإعداد، أو درجات التفاعل المركبة.
• الربط الإجمالي (low، medium، high): حالات احتياطية منخفضة الدقة يتم الإفصاح عنها عندما لا يسمح مستوى بيانات الإرجاع المعين بالتقارير دقيقة التفاصيل.

النوافذ 2 (اليوم 3–7) و3 (اليوم 8–35): تتبع دورة الحياة الإجمالية

لا تعرض عمليات الإرجاع الثانية والثالثة قيم تحويل دقيقة؛ بل تعرض للطبقات البيانية المؤهلة قيمًا إجمالية فقط.

تركز مخططات النوافذ 2 و3 على الاحتفاظ على المدى الطويل ومراحل تحقيق الدخل:

• الربط الإجمالي للنافذة 2: يقيم الاحتفاظ بمنتصف مسار التحويل (على سبيل المثال: low = نشط في اليوم 3–7؛ medium = أكمل 3 جلسات؛ high = عملية شراء متكررة أو تحويل تجريبي).
• الربط الإجمالي للنافذة 3: يقيم الاحتفاظ على المدى الطويل وتجديدات الاشتراكات (على سبيل المثال: low = محتفظ به في اليوم 8–35؛ medium = تم الوصول إلى مرحلة مستوى معينة؛ high = مشترك مدفوع نشط).

يمكن للمطورين الذين يقومون بتكوين مخططات التحويل الرجوع إلى وثائق ربط تحويل SKAN للحصول على إرشادات تقنية حول هياكل القواعد متعددة النوافذ.

نماذج الترميز المحددة بواسطة البائع: تجميع الإيرادات، ومسارات التحويل، والمنطق الثنائي (Bitwise)

تمثل نماذج الترميز هذه أنماط تصميم على مستوى البائع والتطبيق بدلاً من أنواع المخططات التي تفرضها Apple.

المخططات القائمة على الإيرادات

تخصص مخططات الإيرادات القيم الدقيقة المتاحة عبر مبالغ الشراء التراكمية:

• التجميع الخطي: يقسم نطاق الإيرادات إلى فترات متساوية (على سبيل المثال، 64 فئة بزيادات قدرها 1.50 دولار حتى 96.00 دولاراً). مثالي للتبيقات ذات أحجام المعاملات المتوقعة.
• التجميع اللوغاريتمي: يخصص فئات مفصلة للمشتريات منخفضة التكلفة بينما يوسع نطاق الفئات للمعاملات عالية القيمة (على سبيل المثال، القيم 1–20 تغطي 0.99–$19.99 دولاراً؛ القيم 21–50 تغطي 20.00–$100.00 دولاراً؛ القيم 51–63 تغطي 100.00–$1000.00+ دولار).
• التجميع القائم على النسب المئوية: يربط توزيعات شراء المستخدمين التاريخية بشرائح الأتراب بناءً على منحنيات تحقيق الدخل التجريبية.

مخططات تقدم مسار التحويل واتجاه القيمة

في SKAdNetwork 3 والإصدارات السابقة، طلبت Apple أن تزيد قيم التحويل بشكل رتيب (تصاعدي). في SKAdNetwork 4.0، أزالت Apple هذا القيد، مما يسمح لقيم التحويل في النافذة 1 بالزيادة أو النقصان عبر مكالمات واجهة برمجة التطبيقات اللاحقة.

ومع ذلك، تفرض العديد من مخططات الإسناد عن قصد التقدم الرتيب كعرف تصميم على مستوى البائع لضمان أن القيم الأعلى تمثل نتائج تجارية أقوى تدريجياً:

• القيمة 0: تم تثبيت التطبيق وفتحه.
• القيمة 10: اكتمل التسجيل.
• القيمة 20: انتهى البرنامج التعليمي للإعداد.
• القيمة 30: تمت إضافة طريـقة الدفع.
• القيمة 45: تمت إضافة عنصر إلى سلة التسوق.
• القيمة 63: اكتمل الشراء الأولي.

المخططات التصنيفية الثنائية (Bitwise)

تعامل المخططات الثنائية العدد الصحيح ذو 6 بت ($2^6 = 64$) كست علامات منطقية مستقلة ($b_5 b_4 b_3 b_2 b_1 b_0$):

توضح حمولة JSON المؤرخة أدناه وثيقة تكوين ديناميكية متعددة النوافذ:

{
  "schema_version": "4.0.1",
  "app_id": "1234567890",
  "currency": "USD",
  "windows": {
    "window_1": {
      "mode": "hybrid_revenue_and_funnel",
      "fine_mapping": [
        { "event": "app_open", "min_revenue_cents": 0, "fine_value": 0, "lock": false },
        { "event": "registration_complete", "min_revenue_cents": 0, "fine_value": 10, "lock": false },
        { "event": "tutorial_complete", "min_revenue_cents": 0, "fine_value": 20, "lock": false },
        { "event": "purchase", "min_revenue_cents": 99, "fine_value": 30, "lock": false },
        { "event": "purchase", "min_revenue_cents": 999, "fine_value": 45, "lock": false },
        { "event": "purchase", "min_revenue_cents": 4999, "fine_value": 63, "lock": true }
      ],
      "coarse_mapping": {
        "low": { "events": ["app_open", "registration_complete"] },
        "medium": { "events": ["tutorial_complete"] },
        "high": { "events": ["purchase"] }
      }
    },
    "window_2": {
      "mode": "coarse_retention_and_monetization",
      "coarse_mapping": {
        "low": { "events": ["app_open"], "lock": false },
        "medium": { "events": ["session_milestone"], "lock": false },
        "high": { "events": ["repeat_purchase"], "lock": true }
      }
    },
    "window_3": {
      "mode": "coarse_long_tail_ltv",
      "coarse_mapping": {
        "low": { "events": ["app_open"], "lock": false },
        "medium": { "events": ["level_milestone"], "lock": false },
        "high": { "events": ["subscription_active"], "lock": true }
      }
    }
  }
}

تكوين SDK الديناميكي: استيعاب وتقييم التكوينات البعيدة وقت التشغيل

آليات تقييم القواعد من جانب العميل

تقوم حزم تطوير برامج الإسناد بتقييم قواعد التحويل محلياً داخل وقت تشغيل التطبيق:

• لا يوجد جلب للتكوين عن بعد بشكل متزامن على مسار الحدث: تؤدي إجراءات داخل التطبيق إلى تشغيل تقييمات محلية في الذاكرة مقابل مجموعة قواعد نشطة، مما يستدعي واجهات برمجة تطبيقات StoreKit على الفور دون حظر تنفيذ التطبيق.
• تقليل البيانات: بالنسبة لمسار تحديث تحويل SKAdNetwork المعروض هنا، يمكن تقييم مدخلات الحدث الخام محلياً ومرور قيم التحويل الناتجة فقط إلى StoreKit. هذا لا يصف أو يحد بحد ذاته تدفقات بيانات التحليلات الأخرى التي تنفذها حزمة SDK.

التعامل مع حالة عدم الاتصال بالإنترنت والاستمرار المحلي

عندما يتم تشغيل التطبيق دون اتصال بالإنترنت أو في ظروف شبكة متدهورة:

1. تقوم حزمة SDK بتهيئة مرساة طابع زمن الإطلاق الأول بشكل مستقل في الذاكرة الدائمة المحلية.
2. تقوم حزمة SDK بتحميل مخطط التكوين المثبت من التخزين المحلي الدائم، مع التحقق من أن الحمولة المخزنة مؤقتاً تتطابق مع إصدار المخطط المثبت.
3. إذا حدثت أحداث داخل التطبيق أثناء عدم الاتصال، تقيّمها حزمة SDK مقابل مجموعة القواعد المخزنة مؤقتاً وتستدعي واجهة برمجة تطبيقات تحديث StoreKit على الفور.
4. يظل إعداد الإرجاع والتسليم مدارين بواسطة النظام وغير متزامنين؛ ولا يحتاج التطبيق إلى إرسال عمليات الإرجاع بنفسه.

يوضح تنفيذ Swift أدناه محرك تقييم مخطط متعدد النوافذ يحسب القيم الدقيقة والإجمالية، ويدير حالات القفل الخاصة بالنافذة، ويحفظ تكوينات المخططات المثبتة، ويثبت تحديثات الحالة فقط عند نجاح تنفيذ StoreKit:

import Foundation
import StoreKit

// MARK: - Schema Configuration Models

struct SKANSchemaConfig: Codable {
    let schemaVersion: String
    let appId: String
    let currency: String
    let windows: SchemaWindows

    enum CodingKeys: String, CodingKey {
        case schemaVersion = "schema_version"
        case appId = "app_id"
        case currency, windows
    }
}

struct SchemaWindows: Codable {
    let window1: Window1Config
    let window2: WindowCoarseConfig
    let window3: WindowCoarseConfig

    enum CodingKeys: String, CodingKey {
        case window1 = "window_1"
        case window2 = "window_2"
        case window3 = "window_3"
    }
}

struct Window1Config: Codable {
    let mode: String
    let fineMapping: [FineRule]
    let coarseMapping: CoarseRuleGroup

    enum CodingKeys: String, CodingKey {
        case mode
        case fineMapping = "fine_mapping"
        case coarseMapping = "coarse_mapping"
    }
}

struct FineRule: Codable {
    let event: String
    let minRevenueCents: Int
    let fineValue: Int
    let lock: Bool

    enum CodingKeys: String, CodingKey {
        case event
        case minRevenueCents = "min_revenue_cents"
        case fineValue = "fine_value"
        case lock
    }
}

struct WindowCoarseConfig: Codable {
    let mode: String
    let coarseMapping: [String: CoarseRule]

    enum CodingKeys: String, CodingKey {
        case mode
        case coarseMapping = "coarse_mapping"
    }
}

struct CoarseRuleGroup: Codable {
    let low: CoarseRule
    let medium: CoarseRule
    let high: CoarseRule
}

struct CoarseRule: Codable {
    let events: [String]?
    let lock: Bool?
}

// MARK: - Multi-Window SKAN 4.0 Schema Engine

final class SKANSchemaEngine {

    static let shared = SKANSchemaEngine()
    private init() {}

    private var activeSchema: SKANSchemaConfig?
    private var firstLaunchDate: Date?
    private var lockedWindows = Set<Int>()
    private var lastRecordedFineValue: Int = 0
    private var pinnedSchemaVersion: String?

    /// Initializes the first-launch timestamp anchor independently of remote configuration fetches
    func initializeLifecycleAnchor() {
        let defaults = UserDefaults.standard
        if let storedLaunch = defaults.object(forKey: "skan_first_launch_date") as? Date {
            self.firstLaunchDate = storedLaunch
        } else {
            let now = Date()
            self.firstLaunchDate = now
            defaults.set(now, forKey: "skan_first_launch_date")
        }

        let lockedArray = defaults.array(forKey: "skan_locked_windows") as? [Int] ?? []
        self.lockedWindows = Set(lockedArray)
        self.lastRecordedFineValue = defaults.integer(forKey: "skan_last_fine_value")
        self.pinnedSchemaVersion = defaults.string(forKey: "skan_pinned_schema_version")

        // Restore previously cached schema payload if it matches the pinned version
        if let pinnedVersion = self.pinnedSchemaVersion,
           let cachedData = defaults.data(forKey: "skan_cached_schema_payload"),
           let cachedSchema = try? JSONDecoder().decode(SKANSchemaConfig.self, from: cachedData),
           cachedSchema.schemaVersion == pinnedVersion {
            self.activeSchema = cachedSchema
        }
    }

    /// Loads active schema, persisting the pinned payload to maintain consistency across the 35-day lifecycle
    func configure(schema: SKANSchemaConfig) {
        let defaults = UserDefaults.standard
        if let pinned = pinnedSchemaVersion {
            // If already pinned, accept only schemas matching the pinned version
            if pinned == schema.schemaVersion {
                self.activeSchema = schema
                if let data = try? JSONEncoder().encode(schema) {
                    defaults.set(data, forKey: "skan_cached_schema_payload")
                }
            }
        } else {
            // Pin the initial schema version for this lifecycle
            self.activeSchema = schema
            self.pinnedSchemaVersion = schema.schemaVersion
            defaults.set(schema.schemaVersion, forKey: "skan_pinned_schema_version")
            if let data = try? JSONEncoder().encode(schema) {
                defaults.set(data, forKey: "skan_cached_schema_payload")
            }
        }
    }

    /// Determines the active conversion window based on elapsed time from first launch
    private var currentWindowIndex: Int {
        guard let firstLaunch = firstLaunchDate else { return 0 }
        let elapsedHours = Date().timeIntervalSince(firstLaunch) / 3600.0

        switch elapsedHours {
        case 0.0..<48.0:
            return 1
        case 48.0..<168.0:
            return 2
        case 168.0...840.0:
            return 3
        default:
            return 0 // Window closed (>35 days)
        }
    }

    /// Evaluates an in-app event against the active schema for the current window
    func trackEvent(name: String, revenueCents: Int = 0) {
        guard #available(iOS 16.1, *),
              let schema = activeSchema else { return }

        let window = currentWindowIndex
        guard window >= 1 && window <= 3, !lockedWindows.contains(window) else { return }

        var targetFineValue: Int?
        var targetCoarseValue: SKAdNetwork.CoarseConversionValue?
        var shouldLock = false
        var matchedRule = false

        if window == 1 {
            // Window 1: Evaluate fine-grained rules with highest-threshold precedence
            let matchingFineRules = schema.windows.window1.fineMapping
                .filter { $0.event == name && revenueCents >= $0.minRevenueCents }
                .sorted { $0.minRevenueCents < $1.minRevenueCents }

            if let highestRule = matchingFineRules.last {
                targetFineValue = highestRule.fineValue
                if highestRule.lock { shouldLock = true }
                matchedRule = true
            }

            // Window 1: Evaluate coarse-grained rules explicitly
            if schema.windows.window1.coarseMapping.high.events?.contains(name) == true {
                targetCoarseValue = .high
                matchedRule = true
            } else if schema.windows.window1.coarseMapping.medium.events?.contains(name) == true {
                targetCoarseValue = .medium
                matchedRule = true
            } else if schema.windows.window1.coarseMapping.low.events?.contains(name) == true {
                targetCoarseValue = .low
                matchedRule = true
            }
        } else {
            // Windows 2 & 3: Evaluate coarse rules only
            let coarseConfig = (window == 2) ? schema.windows.window2 : schema.windows.window3
            
            if let highRule = coarseConfig.coarseMapping["high"], highRule.events?.contains(name) == true {
                targetCoarseValue = .high
                if highRule.lock == true { shouldLock = true }
                matchedRule = true
            } else if let medRule = coarseConfig.coarseMapping["medium"], medRule.events?.contains(name) == true {
                targetCoarseValue = .medium
                if medRule.lock == true { shouldLock = true }
                matchedRule = true
            } else if let lowRule = coarseConfig.coarseMapping["low"], lowRule.events?.contains(name) == true {
                targetCoarseValue = .low
                if lowRule.lock == true { shouldLock = true }
                matchedRule = true
            }
        }

        // If no explicit rule matched for this event, do not trigger a StoreKit update
        guard matchedRule else { return }

        let fineToSubmit = targetFineValue ?? (window == 1 ? lastRecordedFineValue : 0)
        let clampedFine = max(0, min(63, fineToSubmit))
        let coarseToSubmit = targetCoarseValue ?? .low

        // Dispatch StoreKit conversion update
        // Note: StoreKit ignores the fineValue parameter after Window 1
        SKAdNetwork.updatePostbackConversionValue(
            clampedFine,
            coarseValue: coarseToSubmit,
            lockWindow: shouldLock
        ) { [weak self] error in
            guard let self = self else { return }
            if let error = error {
                print("StoreKit conversion update failed: \(error.localizedDescription)")
            } else {
                // Commit local state only after StoreKit successfully accepts the update
                DispatchQueue.main.async {
                    if window == 1 {
                        self.lastRecordedFineValue = clampedFine
                        UserDefaults.standard.set(clampedFine, forKey: "skan_last_fine_value")
                    }
                    if shouldLock {
                        self.lockedWindows.insert(window)
                        UserDefaults.standard.set(Array(self.lockedWindows), forKey: "skan_locked_windows")
                    }
                    print("SKAN 4.0 update succeeded: Window=\(window), Fine=\(clampedFine), Coarse=\(coarseToSubmit.rawValue), Locked=\(shouldLock)")
                }
            }
        }
    }
}

أتمتة تنفيذ lockWindow لتسريع إعداد الإرجاع

الآليات التشغيلية لمعلمة lockWindow

عندما يستدعي التطبيق updatePostbackConversionValue(_:coarseValue:lockWindow:) باستخدام المعلمة lockWindow: true، يصبح التحديث هو التحديث النهائي لقيمة التحويل للنافذة النشطة. يجهز نظام التشغيل الإرجاع على الفور ويتجاهل تحديثات قيمة التحويل الإضافية لبقية تلك النافذة.

Default Window 1 (No Lock):
[First Launch] ─────────────── 48 Hours Open ───────────────► [Closes] ──► Delay (24-48h) ──► Postback 1

Locked Window 1 (Purchase at Hour 6):
[First Launch] ── 6h (Lock: true) ──► [Conversion Locked / Postback Prepared] ──► Delay (24-48h) ──► Postback 1 Sent Sooner

المقايضات الاستراتيجية في قفل النافذة التلقائي

• إرسال الإرجاع المتسارع: تتيح إنهاء التحويل مبكراً بدء تأخير الإرجاع العشوائي لشركة Apple فوراً، مما يوفر بيانات التحويل لشبكات الإعلانات بشكل أسرع.
• استقلال النافذة: قفل النافذة الحالية لا ينقل بداية النافذة التالية إلى الأمام؛ تظل النافذة 2 تبدأ في اليوم 3 بغض النظر عن وقت قفل النافذة 1.
• اقتصار المراقبة: بمجرد قفل النافذة، يتجاهل النظام مكالمات تحديث قيمة التحويل اللاحقة لبقية نافذة التحويل تلك. قد تستمر الأحداث داخل التطبيق في الحدوث، ولكن لم يعد بإمكانها تغيير حالة تحويل SKAdNetwork الخاصة بتلك النافذة.

تنسيق مخططات SKAN مع AdAttributionKit

مكدس الإسناد المتطور من Apple

توصي Apple الآن باستخدام AdAttributionKit لحملات الإعلان عن التطبيقات عبر متجر التطبيقات وأسواق التطبيقات البديلة. يظل SKAdNetwork ملائماً عمليات التكامل الحالية وقابلية التشغيل البيني، لذلك يجب على محركات الربط الديناميكي إبقاء طبقة قواعد العمل الخاصة بها منفصلة عن واجهات برمجة تطبيقات التحويل الخاصة بإطار العمل:

• أبعاد القيمة المشتركة: تقيم كلتا الإطارين قيم دقيقة ذات 6 بت (0 إلى 63) وقيم إجمالية ذات 3 مستويات (low، medium، high).
• طبقات واجهة برمجة التطبيقات المتميزة: يستخدم SKAdNetwork الدالة SKAdNetwork.updatePostbackConversionValue، بينما يستخدم AdAttributionKit الدالة Postback.updateConversionValue.
• سلوك الربط (Bridging): إذا كان التكامل يدعم كلا الإطارين، فتوصي Apple باستدعاء واجهات برمجة تطبيقات تحديث التحويل لكلا الإطارين، مع مراعاة سلوك ربط SKAdNetwork بـ AdAttributionKit الموثق.

مصفوفة القرار المقارنة: منطق العميل الثابت مقابل التكوين الديناميكي

الملخص وإطار القرار

تؤدي أتمتة ربط قيم تحويل SKAdNetwork إلى فصل تجارب النمو عن دورات إصدار الملفات الثنائية للجوال. من خلال تووزيع المخططات الديناميكية من لوحة تحكم إسناد مركزية وتقييمها محلياً داخل حزمة SDK، يمكن للفرق الهندسية ضبط حزم الإيرادات بدقة، وتحسين مراحل مسار التحويل، وتكوين أقفال النوافذ التلقائية، مما يسمح للتغييرات المدعومة في قواعد التحويل بالدخول حيز التنفيذ دون إعادة إرسال الملفات الثنائية للتطبيق إلى App Store Connect.

يمكن أن يعمل توجيه الروابط العميقة على مستوى التطبيق جنباً إلى جنب مع إطارات إسناد Apple الحفاظ على الخصوصية كطبقة قياس وإعداد منفصلة. توفر منصات مثل OpoInstall البنية التحتية للتوجيه السياقي للطرف الأول والربط العميق المؤجل، مما يسمح للفرق بالحفاظ على نية المستخدم عبر مسارات تحويل الويب إلى التطبيق.

لمعرفة المزيد حول تكوين إسناد متوافق مع الخصوصية وخطوط ربط الروابط العميقة، راجع وثائق OpoInstall.

المواد ذات الصلة

• المفاهيم: مخططات قيم التحويل، ربط المخططات الديناميكية، تجميع الإيرادات، قفل النوافذ، الرتابة

• التقنيات: Apple SKAdNetwork، وApple AdAttributionKit، وإطار عمل StoreKit، وحزمة تطوير البرامج (SDK) للجوال من OpoInstall

• المعايير: مواصفات JSON لـ IETF RFC 8259

• واجهات برمجة التطبيقات: واجهة برمجة التطبيقات StoreKit updatePostbackConversionValue، وواجهة برمجة التطبيقات AdAttributionKit Postback.updateConversionValue

الوثائق الرسمية

• وثائق مطوري Apple حول تحديث قيم تحويل الإرجاع

• وثائق مطوري Apple حول SKAdNetwork

• وثائق مطوري Apple حول AdAttributionKit

• وثائق مطوري Apple حول تلقي عمليات الإرجاع في نوافذ تحويل متعددة

• فهم قابلية التشغيل البيني بين AdAttributionKit وSKAdNetwork