📡 Network Event Bus

KNETNetworkEventBus to centralna magistrala zdarzeń sieciowych. Umożliwia reagowanie na zdarzenia HTTP w całej aplikacji.

📦 Import

import rip.nerd.kitsunenet.util.KNETNetworkEventBus
import rip.nerd.kitsunenet.util.KNETNetworkEventBus.NetworkEvent
import rip.nerd.kitsunenet.util.collectIn

🚀 Szybki start

val eventBus = KNETNetworkEventBus.create()

// Dodaj jako interceptor
val client = KNETClient.builder()
    .addInterceptor(eventBus.interceptor())
    .build()

// Obserwuj zdarzenia (Flow)
lifecycleScope.launch {
    eventBus.events.collect { event ->
        when (event) {
            is NetworkEvent.RequestStarted -> showLoading()
            is NetworkEvent.RequestCompleted -> {
                hideLoading()
                if (!event.isSuccess) showError()
            }
            is NetworkEvent.RequestFailed -> {
                hideLoading()
                showError(event.error.message)
            }
            else -> {}
        }
    }
}

📊 Typy zdarzeń

sealed class NetworkEvent {
    // Request rozpoczęty
    data class RequestStarted(
        val id: Long,
        val timestamp: Long,
        val request: KNETRequest
    )

    // Request zakończony
    data class RequestCompleted(
        val id: Long,
        val timestamp: Long,
        val request: KNETRequest,
        val response: KNETResponse,
        val durationMs: Long
    ) {
        val statusCode: Int
        val isSuccess: Boolean
    }

    // Request nieudany (wyjątek)
    data class RequestFailed(
        val id: Long,
        val timestamp: Long,
        val request: KNETRequest,
        val error: Throwable,
        val durationMs: Long
    )

    // Wolny request
    data class SlowRequest(
        val id: Long,
        val timestamp: Long,
        val request: KNETRequest,
        val response: KNETResponse?,
        val durationMs: Long,
        val thresholdMs: Long
    )
}

🎯 Filtered Flows

// Tylko errors
lifecycleScope.launch {
    eventBus.errors.collect { event ->
        analytics.logError(event.error)
    }
}

// Tylko completed
lifecycleScope.launch {
    eventBus.requestsCompleted.collect { event ->
        metrics.recordLatency(event.durationMs)
    }
}

// Tylko slow requests
lifecycleScope.launch {
    eventBus.slowRequests.collect { event ->
        Log.w("Perf", "Slow: ${event.request.url} (${event.durationMs}ms)")
    }
}

🔔 Callback Listeners

// Na konkretny status code
val unsubscribe401 = eventBus.onStatusCode(401) { event ->
    // Token wygasł - refresh
    authManager.refreshToken()
}

// Na 401 Unauthorized (shortcut)
eventBus.onUnauthorized { event ->
    navigateToLogin()
}

// Na 403 Forbidden
eventBus.onForbidden { event ->
    showAccessDenied()
}

// Na 404 Not Found
eventBus.onNotFound { event ->
    showNotFound()
}

// Na wszystkie server errors (5xx)
eventBus.onServerError { event ->
    showServerError()
}

// Na wszystkie błędy (4xx i 5xx)
eventBus.onError { event ->
    if (event.statusCode in 500..599) {
        showServerError()
    } else {
        showClientError()
    }
}

// Anuluj subskrypcję
unsubscribe401()

🔧 Konfiguracja

// Custom slow threshold
val eventBus = KNETNetworkEventBus.create()
val interceptor = eventBus.interceptor(slowThresholdMs = 2000)

// Singleton
val eventBus = KNETNetworkEventBus.instance

📊 Statystyki

val stats = eventBus.getStats()

println("Total requests: ${stats.totalRequests}")
println("Successful: ${stats.totalSuccessful}")
println("Failed: ${stats.totalFailed}")
println("Slow: ${stats.totalSlowRequests}")
println("Success rate: ${stats.successRate}%")
println("Active listeners: ${stats.activeListeners}")

// Reset
eventBus.resetStats()

💡 Praktyczne przykłady

Global Loading Indicator

class LoadingManager(private val eventBus: KNETNetworkEventBus) {

    private var activeRequests = AtomicInteger(0)
    val isLoading: StateFlow<Boolean> get() = _isLoading
    private val _isLoading = MutableStateFlow(false)

    init {
        CoroutineScope(Dispatchers.Main).launch {
            eventBus.events.collect { event ->
                when (event) {
                    is NetworkEvent.RequestStarted -> {
                        activeRequests.incrementAndGet()
                        _isLoading.value = true
                    }
                    is NetworkEvent.RequestCompleted,
                    is NetworkEvent.RequestFailed -> {
                        if (activeRequests.decrementAndGet() == 0) {
                            _isLoading.value = false
                        }
                    }
                    else -> {}
                }
            }
        }
    }
}

// W UI
loadingManager.isLoading.collect { isLoading ->
    progressBar.isVisible = isLoading
}

Centralized Error Handling

class ErrorHandler(
    private val eventBus: KNETNetworkEventBus,
    private val snackbarHost: SnackbarHostState
) {
    init {
        eventBus.onError { event ->
            val message = when (event.statusCode) {
                401 -> "Sesja wygasła. Zaloguj się ponownie."
                403 -> "Brak dostępu do tego zasobu."
                404 -> "Nie znaleziono."
                in 500..599 -> "Błąd serwera. Spróbuj później."
                else -> "Wystąpił błąd: ${event.statusCode}"
            }

            CoroutineScope(Dispatchers.Main).launch {
                snackbarHost.showSnackbar(message)
            }
        }

        eventBus.onUnauthorized {
            // Navigate to login
            navigationController.navigate("login")
        }
    }
}

Analytics

class NetworkAnalytics(
    private val eventBus: KNETNetworkEventBus,
    private val analytics: FirebaseAnalytics
) {
    init {
        CoroutineScope(Dispatchers.IO).launch {
            eventBus.requestsCompleted.collect { event ->
                analytics.logEvent("http_request") {
                    param("url", event.request.url)
                    param("method", event.request.method)
                    param("status", event.statusCode.toLong())
                    param("duration_ms", event.durationMs)
                    param("success", event.isSuccess.toString())
                }
            }
        }

        CoroutineScope(Dispatchers.IO).launch {
            eventBus.errors.collect { event ->
                analytics.logEvent("http_error") {
                    param("url", event.request.url)
                    param("error", event.error.message ?: "unknown")
                }
            }
        }
    }
}

Performance Monitoring

class PerformanceMonitor(private val eventBus: KNETNetworkEventBus) {

    init {
        eventBus.interceptor(slowThresholdMs = 3000)

        CoroutineScope(Dispatchers.IO).launch {
            eventBus.slowRequests.collect { event ->
                // Alert do monitoring
                monitoring.alert(
                    level = AlertLevel.WARNING,
                    title = "Slow HTTP Request",
                    message = "${event.request.method} ${event.request.url}",
                    data = mapOf(
                        "duration_ms" to event.durationMs,
                        "threshold_ms" to event.thresholdMs
                    )
                )
            }
        }
    }
}

ViewModel Integration

class MainViewModel(
    private val eventBus: KNETNetworkEventBus
) : ViewModel() {

    private val _networkState = MutableStateFlow<NetworkState>(NetworkState.Idle)
    val networkState: StateFlow<NetworkState> = _networkState

    init {
        eventBus.collectIn(viewModelScope) { event ->
            _networkState.value = when (event) {
                is NetworkEvent.RequestStarted -> NetworkState.Loading
                is NetworkEvent.RequestCompleted -> {
                    if (event.isSuccess) NetworkState.Success
                    else NetworkState.Error(event.statusCode)
                }
                is NetworkEvent.RequestFailed -> NetworkState.Error(0)
                else -> _networkState.value
            }
        }
    }
}

sealed class NetworkState {
    object Idle : NetworkState()
    object Loading : NetworkState()
    object Success : NetworkState()
    data class Error(val code: Int) : NetworkState()
}

🔗 API Reference

KNETNetworkEventBus

📚 Zobacz też