@bigcrunch/react-native-ads 0.4.0 → 0.5.0

package/android/bigcrunch-ads/com/bigcrunch/ads/core/AnalyticsClient.kt

@@ -0,0 +1,719 @@
+package com.bigcrunch.ads.core
+
+import android.content.Context
+import android.os.Build
+import com.bigcrunch.ads.BigCrunchAds
+import com.bigcrunch.ads.internal.BCLogger
+import com.bigcrunch.ads.internal.HttpClient
+import com.bigcrunch.ads.models.*
+import com.squareup.moshi.Moshi
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Analytics client for tracking ad events
+ *
+ * AnalyticsClient sends all ad-related events to the BigCrunch pipeline:
+ * - Page/screen views → `/pageviews`
+ * - Ad impressions (includes request + auction + revenue) → `/impressions`
+ * - Ad clicks → `/clicks`
+ * - Ad viewability → `/viewability`
+ * - User engagement → `/engagement`
+ *
+ * All events are fire-and-forget (non-blocking) and sent asynchronously.
+ * Failures are logged but do not propagate to the caller.
+ */
+internal class AnalyticsClient(
+    private val context: Context,
+    private val httpClient: HttpClient,
+    private val moshi: Moshi,
+    private val baseUrl: String,
+    dispatcher: CoroutineDispatcher = Dispatchers.IO
+) {
+    companion object {
+        private const val TAG = "AnalyticsClient"
+        // Nil UUID for fields that require UUID format but have no value
+        private const val NIL_UUID = "00000000-0000-0000-0000-000000000000"
+    }
+
+    private val scope = CoroutineScope(dispatcher)
+    private val pageViewAdapter = moshi.adapter(PageViewEvent::class.java)
+    private val impressionBatchAdapter = moshi.adapter(ImpressionBatchEvent::class.java)
+    private val clickAdapter = moshi.adapter(ClickEvent::class.java)
+    private val viewabilityAdapter = moshi.adapter(ViewabilityEvent::class.java)
+    private val engagementAdapter = moshi.adapter(EngagementEvent::class.java)
+
+    /** Track impression contexts for correlating events */
+    private val impressionContexts = ConcurrentHashMap<String, ImpressionContext>()
+
+    /** Batching for viewability events */
+    private val viewabilityBatch = mutableListOf<ViewabilityEvent>()
+    private var viewabilityBatchHandler: android.os.Handler? = null
+    private val batchLock = Any()
+    private val BATCH_DELAY_MS = 250L
+
+    /** Previous screen name for referrer tracking */
+    @Volatile
+    private var previousScreenName: String? = null
+
+    // MARK: - Session Context
+
+    private val sessionManager: SessionManager
+        get() = SessionManager.getInstance()
+
+    private val propertyId: String
+        get() = BigCrunchAds.propertyId
+
+    private val configVersion: String?
+        get() = null  // TODO: Get from ConfigManager when available
+
+    // MARK: - Event Sending
+
+    /**
+     * Send an event to a specific endpoint (fire-and-forget)
+     * Wraps single event in an array as required by server
+     */
+    private fun <T> sendEvent(event: T, adapter: com.squareup.moshi.JsonAdapter<T>, endpoint: String) {
+        scope.launch {
+            try {
+                // Wrap single event in array as server expects arrays
+                val eventArray = listOf(event)
+                val listAdapter = moshi.adapter<List<T>>(
+                    com.squareup.moshi.Types.newParameterizedType(List::class.java, event!!::class.java)
+                )
+                val json = listAdapter.toJson(eventArray)
+                val url = "$baseUrl/$endpoint"
+
+                BCLogger.d(TAG, "Sending event to: $endpoint")
+
+                val result = httpClient.post(url, json)
+
+                if (result.isSuccess) {
+                    BCLogger.v(TAG, "Event sent successfully: $endpoint")
+                } else {
+                    BCLogger.w(TAG, "Failed to send event: $endpoint - ${result.exceptionOrNull()?.message}")
+                }
+            } catch (e: Exception) {
+                BCLogger.e(TAG, "Error sending event", e)
+            }
+        }
+    }
+
+    /**
+     * Send a batch of events to a specific endpoint (fire-and-forget)
+     */
+    private fun <T> sendEventBatch(events: List<T>, endpoint: String) {
+        scope.launch {
+            try {
+                if (events.isEmpty()) return@launch
+
+                // Get the type from the first event
+                val listAdapter = moshi.adapter<List<T>>(
+                    com.squareup.moshi.Types.newParameterizedType(List::class.java, events.first()!!::class.java)
+                )
+                val json = listAdapter.toJson(events)
+                val url = "$baseUrl/$endpoint"
+
+                BCLogger.d(TAG, "Sending ${events.size} events to: $endpoint")
+
+                val result = httpClient.post(url, json)
+
+                if (result.isSuccess) {
+                    BCLogger.v(TAG, "Event batch sent successfully: $endpoint")
+                } else {
+                    BCLogger.w(TAG, "Failed to send event batch: $endpoint - ${result.exceptionOrNull()?.message}")
+                }
+            } catch (e: Exception) {
+                BCLogger.e(TAG, "Error sending event batch", e)
+            }
+        }
+    }
+
+    // MARK: - Common Event Fields
+
+    /**
+     * Get common web schema fields (device context, attribution, etc.)
+     *
+     * Returns a data class with all the common fields needed for events
+     */
+    private data class CommonEventFields(
+        val browser: String,
+        val device: String,
+        val os: String,
+        val country: String,
+        val region: String,
+        val sessionSource: String,
+        val sessionMedium: String,
+        val utmSource: String?,
+        val utmMedium: String?,
+        val utmCampaign: String?,
+        val utmTerm: String?,
+        val utmContent: String?
+    )
+
+    private fun getCommonEventFields(): CommonEventFields {
+        val deviceContext = DeviceContext.getInstance()
+        val webFields = deviceContext.getWebSchemaFields()
+
+        return CommonEventFields(
+            browser = webFields["browser"] as String,
+            device = webFields["device"] as String,
+            os = webFields["os"] as String,
+            country = webFields["country"] as String,
+            region = webFields["region"] as String,
+            sessionSource = sessionManager.sessionSource,
+            sessionMedium = sessionManager.sessionMedium,
+            utmSource = sessionManager.utmSource,
+            utmMedium = sessionManager.utmMedium,
+            utmCampaign = sessionManager.utmCampaign,
+            utmTerm = sessionManager.utmTerm,
+            utmContent = sessionManager.utmContent
+        )
+    }
+
+    // MARK: - Page View Tracking
+
+    /**
+     * Track a screen view
+     *
+     * @param screenName Name of the screen being viewed
+     */
+    fun trackScreenView(screenName: String) {
+        // Start new page view and get IDs (pass screen name for impression tracking)
+        val pageId = sessionManager.startPageView(screenName)
+
+        // Get common event fields
+        val common = getCommonEventFields()
+
+        // Get GAM network code from BigCrunchAds if available
+        val gamNetworkCode = try {
+            BigCrunchAds.getConfigManager().getGamNetworkCode() ?: ""
+        } catch (e: Exception) {
+            ""
+        }
+
+        // region must be 2 chars or empty per backend validation
+        val regionCode = common.region.takeIf { it.length == 2 } ?: ""
+
+        val event = PageViewEvent(
+            payloadVersion = "1.0.0",
+            configVersion = 1,  // TODO: Get from ConfigManager when available
+            browserTimestamp = sessionManager.getCurrentTimestamp(),
+            sessionId = sessionManager.sessionId,
+            userId = sessionManager.userId,
+            propertyId = propertyId,
+            newUser = sessionManager.isNewUser,
+            pageId = pageId,
+            sessionDepth = sessionManager.sessionDepth,
+            pageUrl = "",  // page_url must be valid URL or empty - mobile doesn't have URLs
+            pageSearch = "",  // Not applicable for mobile
+            pageReferrer = "",  // page_referrer must be valid URL or empty
+            browser = common.browser,
+            device = common.device,
+            os = common.os,
+            country = common.country,
+            region = regionCode,
+            sessionSource = common.sessionSource,
+            sessionMedium = common.sessionMedium,
+            utmSource = common.utmSource ?: "",
+            utmMedium = common.utmMedium ?: "",
+            utmCampaign = common.utmCampaign ?: "",
+            utmTerm = common.utmTerm ?: "",
+            utmContent = common.utmContent ?: "",
+            gclid = "",
+            fbclid = "",
+            acctType = "anonymous",
+            diiSource = "",
+            gamNetworkCode = gamNetworkCode,
+            amznPubId = NIL_UUID,  // amzn_pub_id must be valid UUID
+            customDimensions = emptyMap()
+        )
+
+        sendEvent(event, pageViewAdapter, "pageviews")
+
+        // Update previous screen for next referrer
+        previousScreenName = screenName
+    }
+
+
+    // MARK: - Impression Context Management
+
+    /**
+     * Create and store an impression context for tracking
+     *
+     * Call this when starting to load an ad to generate an impression ID.
+     */
+    fun createImpressionContext(
+        placementId: String,
+        gamAdUnit: String,
+        format: String,
+        width: Int? = null,
+        height: Int? = null
+    ): ImpressionContext {
+        val context = ImpressionContext(
+            placementId = placementId,
+            gamAdUnit = gamAdUnit,
+            format = format,
+            width = width,
+            height = height
+        )
+
+        impressionContexts[context.impressionId] = context
+
+        BCLogger.d(TAG, "Created impression context: ${context.impressionId} for $placementId")
+
+        return context
+    }
+
+    /**
+     * Update auction data for an impression context
+     */
+    fun updateAuctionData(impressionId: String, auctionData: AuctionData) {
+        impressionContexts[impressionId]?.let { context ->
+            impressionContexts[impressionId] = context.copy(auctionData = auctionData)
+        }
+        BCLogger.d(TAG, "Updated auction data for impression: $impressionId")
+    }
+
+    /**
+     * Get impression context by ID
+     */
+    fun getImpressionContext(impressionId: String): ImpressionContext? {
+        return impressionContexts[impressionId]
+    }
+
+    // MARK: - Enhanced Impression Tracking
+
+    /**
+     * Get GAM network code from config (helper method)
+     */
+    private fun getGamNetworkCode(): String {
+        return try {
+            BigCrunchAds.getConfigManager().getGamNetworkCode() ?: ""
+        } catch (e: Exception) {
+            ""
+        }
+    }
+
+    /**
+     * Track an ad impression with auction data
+     *
+     * @param context The impression context with all tracking data
+     */
+    fun trackAdImpression(context: ImpressionContext) {
+        val adSize = if (context.width != null && context.height != null) {
+            "${context.width}x${context.height}"
+        } else ""
+
+        // Get common event fields
+        val common = getCommonEventFields()
+
+        // auction_id is required and must be a valid UUID - generate one if not provided
+        val auctionId = context.auctionData.auctionId?.takeIf { it.isNotEmpty() }
+            ?: UUID.randomUUID().toString()
+
+        // Create impression record with all fields (defaults to empty string/0.0)
+        val impressionRecord = ImpressionRecord(
+            slotId = context.placementId,
+            gamUnit = context.gamAdUnit,
+            impressionId = context.impressionId,
+            auctionId = auctionId,
+            adBidder = context.auctionData.bidder ?: "",
+            adSize = adSize,
+            adPrice = context.auctionData.bidPriceCpm ?: 0.0,
+            creativeId = context.auctionData.creativeId ?: ""
+        )
+
+        // region must be 2 chars or empty per backend validation
+        val regionCode = common.region.takeIf { it.length == 2 } ?: ""
+
+        // Create batch event with session/page context
+        val batchEvent = ImpressionBatchEvent(
+            payloadVersion = "1.0.0",
+            configVersion = 1,
+            browserTimestamp = sessionManager.getCurrentTimestamp(),
+            sessionId = sessionManager.sessionId,
+            userId = sessionManager.userId,
+            propertyId = propertyId,
+            newUser = sessionManager.isNewUser,
+            pageId = sessionManager.getOrCreatePageId(),
+            sessionDepth = sessionManager.sessionDepth,
+            pageUrl = "",  // page_url must be valid URL or empty - mobile doesn't have URLs
+            pageSearch = "",
+            pageReferrer = "",
+            browser = common.browser,
+            device = common.device,
+            os = common.os,
+            country = common.country,
+            region = regionCode,
+            sessionSource = common.sessionSource,
+            sessionMedium = common.sessionMedium,
+            utmSource = common.utmSource ?: "",
+            utmMedium = common.utmMedium ?: "",
+            utmCampaign = common.utmCampaign ?: "",
+            utmTerm = common.utmTerm ?: "",
+            utmContent = common.utmContent ?: "",
+            gclid = "",
+            fbclid = "",
+            acctType = "anonymous",
+            diiSource = "",
+            gamNetworkCode = getGamNetworkCode(),
+            amznPubId = NIL_UUID,  // amzn_pub_id must be valid UUID
+            customDimensions = emptyMap(),
+            impressions = listOf(impressionRecord)
+        )
+
+        sendEvent(batchEvent, impressionBatchAdapter, "impressions")
+    }
+
+    /**
+     * Track an ad impression (simple version without auction data)
+     */
+    fun trackAdImpression(
+        placementId: String,
+        format: String,
+        gamAdUnit: String = "",
+        advertiserId: String? = null,
+        campaignId: String? = null,
+        lineItemId: String? = null,
+        creativeId: String? = null,
+        refreshCount: Int = 0
+    ) {
+        // Increment session impression counter
+        SessionManager.incrementAdImpressionCount()
+
+        // Get common event fields
+        val common = getCommonEventFields()
+
+        // auction_id is required and must be a valid UUID
+        val auctionId = UUID.randomUUID().toString()
+
+        // Create impression record with all fields (defaults to empty string/0.0)
+        val impressionRecord = ImpressionRecord(
+            slotId = placementId,
+            gamUnit = gamAdUnit,
+            impressionId = UUID.randomUUID().toString(),
+            auctionId = auctionId,
+            advertiserId = advertiserId ?: "",
+            campaignId = campaignId ?: "",
+            lineItemId = lineItemId ?: "",
+            creativeId = creativeId ?: "",
+            refreshCount = refreshCount
+        )
+
+        // region must be 2 chars or empty per backend validation
+        val regionCode = common.region.takeIf { it.length == 2 } ?: ""
+
+        // Create batch event with session/page context
+        val batchEvent = ImpressionBatchEvent(
+            payloadVersion = "1.0.0",
+            configVersion = 1,
+            browserTimestamp = sessionManager.getCurrentTimestamp(),
+            sessionId = sessionManager.sessionId,
+            userId = sessionManager.userId,
+            propertyId = propertyId,
+            newUser = sessionManager.isNewUser,
+            pageId = sessionManager.getOrCreatePageId(),
+            sessionDepth = sessionManager.sessionDepth,
+            pageUrl = "",  // page_url must be valid URL or empty - mobile doesn't have URLs
+            pageSearch = "",
+            pageReferrer = "",
+            browser = common.browser,
+            device = common.device,
+            os = common.os,
+            country = common.country,
+            region = regionCode,
+            sessionSource = common.sessionSource,
+            sessionMedium = common.sessionMedium,
+            utmSource = common.utmSource ?: "",
+            utmMedium = common.utmMedium ?: "",
+            utmCampaign = common.utmCampaign ?: "",
+            utmTerm = common.utmTerm ?: "",
+            utmContent = common.utmContent ?: "",
+            gclid = "",
+            fbclid = "",
+            acctType = "anonymous",
+            diiSource = "",
+            gamNetworkCode = getGamNetworkCode(),
+            amznPubId = NIL_UUID,  // amzn_pub_id must be valid UUID
+            customDimensions = emptyMap(),
+            impressions = listOf(impressionRecord)
+        )
+
+        sendEvent(batchEvent, impressionBatchAdapter, "impressions")
+    }
+
+    // MARK: - Click Tracking
+
+    /**
+     * Track an ad click with impression context
+     *
+     * @param impressionId The impression that was clicked
+     * @param placementId Placement ID
+     * @param format Ad format
+     */
+    fun trackAdClick(impressionId: String, placementId: String, format: String) {
+        // Get common event fields
+        val common = getCommonEventFields()
+
+        // region must be 2 chars or empty per backend validation
+        val regionCode = common.region.takeIf { it.length == 2 } ?: ""
+
+        // Create nested click data - impressionId must be valid UUID
+        val clickData = ClickData(
+            clickId = UUID.randomUUID().toString(),
+            slotId = placementId,
+            impressionId = impressionId.takeIf { it.isNotEmpty() } ?: UUID.randomUUID().toString()
+        )
+
+        val event = ClickEvent(
+            payloadVersion = "1.0.0",  // Must be semver format
+            configVersion = 1,
+            browserTimestamp = sessionManager.getCurrentTimestamp(),
+            sessionId = sessionManager.sessionId,
+            userId = sessionManager.userId,
+            propertyId = propertyId,
+            newUser = sessionManager.isNewUser,
+            pageId = sessionManager.getOrCreatePageId(),
+            sessionDepth = sessionManager.sessionDepth,
+            pageUrl = "",  // page_url must be valid URL or empty - mobile doesn't have URLs
+            pageSearch = "",
+            pageReferrer = "",
+            browser = common.browser,
+            device = common.device,
+            os = common.os,
+            country = common.country,
+            region = regionCode,
+            sessionSource = common.sessionSource,
+            sessionMedium = common.sessionMedium,
+            utmSource = common.utmSource ?: "",
+            utmMedium = common.utmMedium ?: "",
+            utmCampaign = common.utmCampaign ?: "",
+            utmTerm = common.utmTerm ?: "",
+            utmContent = common.utmContent ?: "",
+            gclid = "",
+            fbclid = "",
+            acctType = "anonymous",
+            diiSource = "",
+            gamNetworkCode = getGamNetworkCode(),
+            amznPubId = NIL_UUID,  // amzn_pub_id must be valid UUID
+            customDimensions = emptyMap(),
+            click = clickData
+        )
+
+        sendEvent(event, clickAdapter, "clicks")
+    }
+
+    /**
+     * Track an ad click (simple version without impression ID)
+     */
+    fun trackAdClick(placementId: String, format: String) {
+        trackAdClick("", placementId, format)
+    }
+
+    // MARK: - Viewability Tracking
+
+    /**
+     * Track ad viewability with impression context
+     *
+     * @param impressionId The impression that became viewable
+     * @param placementId Placement ID
+     * @param format Ad format
+     * @param viewableTimeMs Time the ad was viewable in milliseconds (unused, kept for API compatibility)
+     * @param percentVisible Percentage of ad that was visible (unused, kept for API compatibility)
+     */
+    fun trackAdViewable(
+        impressionId: String,
+        placementId: String,
+        format: String,
+        viewableTimeMs: Long,
+        percentVisible: Int
+    ) {
+        // Get common event fields
+        val common = getCommonEventFields()
+
+        // region must be 2 chars or empty per backend validation
+        val regionCode = common.region.takeIf { it.length == 2 } ?: ""
+
+        // Create nested viewability data - impressionId must be valid UUID
+        val viewabilityData = ViewabilityData(
+            slotId = placementId,
+            impressionId = impressionId.takeIf { it.isNotEmpty() } ?: UUID.randomUUID().toString()
+        )
+
+        val event = ViewabilityEvent(
+            payloadVersion = "1.0.0",  // Must be semver format
+            configVersion = 1,
+            browserTimestamp = sessionManager.getCurrentTimestamp(),
+            sessionId = sessionManager.sessionId,
+            userId = sessionManager.userId,
+            propertyId = propertyId,
+            newUser = sessionManager.isNewUser,
+            pageId = sessionManager.getOrCreatePageId(),
+            sessionDepth = sessionManager.sessionDepth,
+            pageUrl = "",  // page_url must be valid URL or empty - mobile doesn't have URLs
+            pageSearch = "",
+            pageReferrer = "",
+            browser = common.browser,
+            device = common.device,
+            os = common.os,
+            country = common.country,
+            region = regionCode,
+            sessionSource = common.sessionSource,
+            sessionMedium = common.sessionMedium,
+            utmSource = common.utmSource ?: "",
+            utmMedium = common.utmMedium ?: "",
+            utmCampaign = common.utmCampaign ?: "",
+            utmTerm = common.utmTerm ?: "",
+            utmContent = common.utmContent ?: "",
+            gclid = "",
+            fbclid = "",
+            acctType = "anonymous",
+            diiSource = "",
+            gamNetworkCode = getGamNetworkCode(),
+            amznPubId = NIL_UUID,  // amzn_pub_id must be valid UUID
+            customDimensions = emptyMap(),
+            viewability = listOf(viewabilityData)
+        )
+
+        batchViewabilityEvent(event)
+    }
+
+    /**
+     * Track ad viewability (simple version without metrics)
+     */
+    fun trackAdViewable(placementId: String, format: String) {
+        trackAdViewable("", placementId, format, 0, 0)
+    }
+
+    // MARK: - Engagement Tracking
+
+    /**
+     * Track user engagement with content
+     *
+     * @param engagedTime Time actively engaged in seconds
+     * @param timeOnPage Total time on page/screen in seconds
+     * @param scrollDepth Maximum scroll depth percentage (0-100)
+     */
+    fun trackEngagement(engagedTime: Int, timeOnPage: Int, scrollDepth: Int = 0) {
+        // Get common event fields
+        val common = getCommonEventFields()
+
+        // region must be 2 chars or empty per backend validation
+        val regionCode = common.region.takeIf { it.length == 2 } ?: ""
+
+        val event = EngagementEvent(
+            payloadVersion = "1.0.0",  // Must be semver format
+            configVersion = 1,
+            browserTimestamp = sessionManager.getCurrentTimestamp(),
+            sessionId = sessionManager.sessionId,
+            userId = sessionManager.userId,
+            propertyId = propertyId,
+            newUser = sessionManager.isNewUser,
+            pageId = sessionManager.getOrCreatePageId(),
+            sessionDepth = sessionManager.sessionDepth,
+            pageUrl = "",  // page_url must be valid URL or empty - mobile doesn't have URLs
+            pageSearch = "",
+            pageReferrer = "",
+            browser = common.browser,
+            device = common.device,
+            os = common.os,
+            country = common.country,
+            region = regionCode,
+            sessionSource = common.sessionSource,
+            sessionMedium = common.sessionMedium,
+            utmSource = common.utmSource ?: "",
+            utmMedium = common.utmMedium ?: "",
+            utmCampaign = common.utmCampaign ?: "",
+            utmTerm = common.utmTerm ?: "",
+            utmContent = common.utmContent ?: "",
+            gclid = "",
+            fbclid = "",
+            acctType = "anonymous",
+            diiSource = "",
+            gamNetworkCode = getGamNetworkCode(),
+            amznPubId = NIL_UUID,  // amzn_pub_id must be valid UUID
+            customDimensions = emptyMap(),
+            engagedTime = engagedTime,
+            timeOnPage = timeOnPage,
+            scrollDepth = scrollDepth
+        )
+
+        sendEvent(event, engagementAdapter, "engagement")
+    }
+
+    /**
+     * Track an ad request
+     *
+     * @param placementId The placement ID being requested
+     * @param format The ad format (banner, interstitial, etc.)
+     */
+    fun trackAdRequest(placementId: String, format: String) {
+        SessionManager.incrementAdRequestCount()
+        BCLogger.d("AnalyticsClient", "Tracked ad request: $placementId ($format)")
+        // TODO: Send actual event to backend when endpoint is available
+    }
+
+    // NOTE: trackAdRevenue() removed - revenue now tracked via ImpressionEvent.bidPriceCpm
+
+    // MARK: - Cleanup
+
+    /**
+     * Remove an impression context (call when ad is destroyed)
+     */
+    fun removeImpressionContext(impressionId: String) {
+        impressionContexts.remove(impressionId)
+    }
+
+    /**
+     * Clear all impression contexts
+     */
+    fun clearImpressionContexts() {
+        impressionContexts.clear()
+    }
+
+    // MARK: - Batching Helpers
+
+    /**
+     * Batch a viewability event (250ms delay)
+     */
+    private fun batchViewabilityEvent(event: ViewabilityEvent) {
+        synchronized(batchLock) {
+            viewabilityBatch.add(event)
+
+            // Cancel existing timer
+            viewabilityBatchHandler?.removeCallbacksAndMessages(null)
+
+            // Create new handler if needed
+            if (viewabilityBatchHandler == null) {
+                viewabilityBatchHandler = android.os.Handler(android.os.Looper.getMainLooper())
+            }
+
+            // Schedule flush after 250ms
+            viewabilityBatchHandler?.postDelayed({
+                flushViewabilityBatch()
+            }, BATCH_DELAY_MS)
+        }
+    }
+
+    /**
+     * Flush viewability batch to backend
+     */
+    private fun flushViewabilityBatch() {
+        synchronized(batchLock) {
+            if (viewabilityBatch.isEmpty()) return
+
+            val eventsToSend = viewabilityBatch.toList()
+            viewabilityBatch.clear()
+
+            BCLogger.d(TAG, "Flushing ${eventsToSend.size} viewability events")
+
+            // Send events as a batch array
+            sendEventBatch(eventsToSend, "viewability")
+        }
+    }
+}