@tileflow/react-native 0.0.0-bootstrap.0 → 0.1.0-alpha.0

package/android/src/main/java/dev/tileflow/reactnative/NativeSurfaceState.kt

@@ -0,0 +1,115 @@
+package dev.tileflow.reactnative
+
+// All methods run on the view's UI queue. Identity is captured before each native frame.
+internal class NativeSurfaceState(private val surface: String, private val emit: (Map<String, Any>) -> Unit) {
+	private var token = ""
+	private var style: Any? = null
+	private var frame: Any? = null
+	private var frameLayout = 0L
+	private var visible = false
+	private var closed = false
+	private var failed = false
+	private var layoutEpoch = 1L
+	private var committed = 0L
+	private var requested = 0L
+	private var reported = false
+	private var sequence = 0L
+	private var command = 0L
+	private var gestureSequence = 0L
+	private var gesture = 0L
+	private val pending = ArrayDeque<Map<String, Any>>()
+	var awaitingSequence: Long? = null
+		private set
+	val active: Boolean get() = !closed && !failed
+	val pendingCount: Int get() = pending.size
+
+	fun expect(value: String) {
+		check(!closed && AdmissionUrl.validToken(value)) { "Native surface operation failed." }
+		token = value; style = null; frame = null; committed = 0; requested = 0; reported = false; failed = false; gesture = 0
+	}
+	fun layout(isVisible: Boolean) {
+		if (closed) return
+		visible = isVisible
+		if (layoutEpoch >= 9007199254740991L) { fail(); return }
+		layoutEpoch++; committed = 0; requested = 0; frame = null; reported = false; gesture = 0
+		enqueue("invalidate")
+	}
+	fun loaded(value: String, identity: Any) {
+		if (!active || value != token || style === identity) return
+		style = identity; requested = 0; frame = null; reported = false
+		enqueue("style")
+	}
+	fun commit(value: String): Long {
+		check(active && visible && value == token && style != null) { "Native surface operation failed." }
+		committed = layoutEpoch; requested = 0; frame = null; reported = false
+		return committed
+	}
+	fun request(value: String) {
+		check(active && visible && value == token && style != null && committed == layoutEpoch && !reported) { "Native surface operation failed." }
+		requested = layoutEpoch; frame = null
+	}
+	fun frameStart(identity: Any?) {
+		frame = if (active && visible && identity === style && committed == layoutEpoch && requested == layoutEpoch) identity else null
+		frameLayout = layoutEpoch
+	}
+	fun frameEnd(identity: Any?, fully: Boolean) {
+		val captured = frame; frame = null
+		if (!active || reported || !visible || !fully || captured == null ||
+			captured !== identity || captured !== style || frameLayout != layoutEpoch || committed != layoutEpoch || requested != layoutEpoch) return
+		reported = true; requested = 0
+		enqueue("render")
+	}
+	fun beginCommand(value: Long): Long {
+		if (!active || !visible || style == null || gesture != 0L || value <= command || value > 9007199254740991L) return 0
+		command = value; committed = 0; requested = 0; frame = null; reported = false
+		return enqueue("invalidate")
+	}
+	fun cancelCommand(value: Long) { if (value > command && value <= 9007199254740991L) command = value }
+	fun gestureStart(view: Map<String, Any>) {
+		if (!active || !visible || style == null || gesture != 0L) return
+		if (gestureSequence >= 9007199254740991L) { fail(); return }
+		requested = 0; frame = null; gesture = ++gestureSequence
+		enqueue("gesture-start", mapOf("gesture" to gesture, "view" to view))
+	}
+	fun gestureChange(view: Map<String, Any>) {
+		if (active && gesture != 0L) enqueue("gesture-change", mapOf("gesture" to gesture, "view" to view))
+	}
+	fun gestureEnd(view: Map<String, Any>) {
+		if (!active || gesture == 0L) return
+		val completed = gesture; gesture = 0
+		enqueue("gesture-end", mapOf("gesture" to completed, "view" to view))
+	}
+	fun fail() {
+		if (closed || failed) return
+		failed = true; committed = 0; requested = 0; frame = null; gesture = 0
+		enqueue("error")
+	}
+	private fun enqueue(kindInput: String, fieldsInput: Map<String, Any> = emptyMap()): Long {
+		if (closed || token.isEmpty() || sequence >= 9007199254740991L) return 0
+		var kind = kindInput
+		var fields = fieldsInput
+		val last = pending.lastOrNull()
+		if ((kind == "gesture-change" || kind == "invalidate") && last?.get("kind") == kind && last["style"] == token && last["gesture"] == fields["gesture"]) pending.removeLast()
+		val overflow = pending.size >= 32
+		if (overflow) {
+			pending.clear(); failed = true; frame = null; committed = 0; requested = 0; gesture = 0
+			kind = "error"; fields = emptyMap()
+		}
+		val emitted = ++sequence
+		pending.addLast(mapOf("surface" to surface, "style" to token, "layout" to layoutEpoch, "sequence" to emitted, "kind" to kind) + fields)
+		drain()
+		return if (overflow) 0 else emitted
+	}
+	private fun drain() {
+		if (closed || awaitingSequence != null || pending.isEmpty()) return
+		val event = pending.removeFirst()
+		awaitingSequence = event["sequence"] as Long
+		try { emit(event) } catch (_: Exception) { close() }
+	}
+	fun acknowledge(value: Long) {
+		if (awaitingSequence != value) return
+		awaitingSequence = null; drain()
+	}
+	fun close() { closed = true; style = null; frame = null; committed = 0; requested = 0; gesture = 0; pending.clear(); awaitingSequence = null }
+	override fun toString() = "NativeSurfaceState"
+}

package/android/src/main/java/dev/tileflow/reactnative/TileflowNativeAdmissionModule.kt

@@ -0,0 +1,234 @@
+package dev.tileflow.reactnative
+
+import android.util.Base64
+import java.util.UUID
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.common.LifecycleState
+import org.maplibre.android.MapLibre
+
+class TileflowNativeAdmissionModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context), LifecycleEventListener {
+	private val scheduler = HandlerAdmissionScheduler()
+	private var installation: String? = null
+	private var lease: AdmissionProviderLease? = null
+	private var engine: AdmissionEngine? = null
+	private var network: AdmissionOkHttpNetwork? = null
+	private var bootstrapRequests: AdmissionBootstrap? = null
+	private var bootstrapNetwork: AdmissionBootstrapOkHttpNetwork? = null
+	private var listeners = 0
+	private var invalidated = false
+	private var lastRemoved: String? = null
+	private var lastRemoval: Map<String, Boolean>? = null
+
+	init { context.addLifecycleEventListener(this) }
+	override fun getName() = "TileflowNativeAdmission"
+
+	@ReactMethod fun addListener(eventName: String) { scheduler.dispatch { if (eventName == "TileflowNativeAdmissionEvent") listeners++ } }
+	@ReactMethod fun removeListeners(count: Double) { scheduler.dispatch { listeners = maxOf(0, listeners - count.toInt()) } }
+
+	@ReactMethod fun install(promise: Promise) = action(promise) {
+		if (invalidated || installation != null || listeners <= 0) invalid()
+		val ownership = AdmissionProviderLease({ MapLibre.getModuleProvider() }, { MapLibre.setModuleProvider(it) })
+		if (ownership.previous is AdmissionModuleProvider) invalid()
+		val id = UUID.randomUUID().toString()
+		lease = ownership
+		installation = id
+		try {
+			val transport = AdmissionOkHttpNetwork()
+			network = transport
+			val admission = AdmissionEngine(id, scheduler, transport, ownership::owns, ::emit)
+			engine = admission
+			val bootstrapTransport = AdmissionBootstrapOkHttpNetwork()
+			bootstrapNetwork = bootstrapTransport
+			bootstrapRequests = AdmissionBootstrap(id, scheduler, bootstrapTransport) { admission.checkOwnership() }
+			ownership.install(AdmissionModuleProvider(ownership.previous, admission))
+			admission.lifecycle(reactApplicationContext.lifecycleState == LifecycleState.RESUMED)
+			if (!admission.checkOwnership()) invalid()
+			Arguments.makeNativeMap(mapOf("installation" to id))
+		} catch (_: Exception) {
+			// Includes failures after writing the provider or emitting lifecycle.
+			// Keep failed cleanup state available for a later teardown attempt.
+			try { shutdown() } catch (_: Exception) { /* No successful acknowledgement. */ }
+			invalid()
+		}
+	}
+
+	@ReactMethod fun registerContext(id: String, registration: ReadableMap, promise: Promise) = action(promise) {
+		val admission = current(id)
+		val mapId = if (registration.isNull("mapId")) null else registration.getString("mapId") ?: invalid()
+		val context = admission.register(mapId, readResources(registration.getArray("resources") ?: invalid()))
+		try { (bootstrapRequests ?: invalid()).register(context, mapId) }
+		catch (error: Exception) { admission.retire(context); throw error }
+		Arguments.makeNativeMap(mapOf("context" to context, "generation" to 1))
+	}
+
+	@ReactMethod fun extendContext(id: String, context: String, source: ReadableArray, promise: Promise) = action(promise) {
+		if (!AdmissionUrl.validToken(context)) invalid()
+		Arguments.makeNativeMap(mapOf("resources" to current(id).extend(context, readResources(source))))
+	}
+
+	private fun readResources(source: ReadableArray): List<AdmissionResource> {
+		if (source.size() > AdmissionLimits.RESOURCES) invalid()
+		var characters = 0
+		return (0 until source.size()).map { index ->
+			val item = source.getMap(index) ?: invalid()
+			val keys = item.keySetIterator()
+			var fields = 0
+			while (keys.hasNextKey()) if (++fields > 5 || keys.nextKey() !in setOf("url", "scope", "tilesetId", "template", "fontStacks")) invalid()
+			val url = item.getString("url") ?: invalid()
+			val scope = item.getString("scope") ?: invalid()
+			val tileset = if (item.hasKey("tilesetId") && !item.isNull("tilesetId")) item.getString("tilesetId") else null
+			val template = if (item.hasKey("template") && !item.isNull("template")) item.getString("template") else null
+			val stacks = if (item.hasKey("fontStacks")) {
+				val array = item.getArray("fontStacks") ?: invalid()
+				if (array.size() > 16) invalid()
+				(0 until array.size()).map { position ->
+					val value = array.getString(position) ?: invalid()
+					if (value.length > 256) invalid()
+					characters += value.length * 4
+					value
+				}
+			} else null
+			characters += url.length + scope.length + (tileset?.length ?: 0) + (template?.length ?: 0) + 128
+			if (characters > AdmissionLimits.BRIDGE_BYTES || url.length > AdmissionLimits.URL) invalid()
+			AdmissionResource(url, scope, tileset, template, stacks)
+		}
+	}
+
+	@ReactMethod fun retireContext(id: String, context: String, promise: Promise) = action(promise) {
+		if (!AdmissionUrl.validToken(context)) invalid()
+		if (installation == id) {
+			bootstrapRequests?.retire(context)
+			engine?.retire(context)
+		} else if (lastRemoved != id) invalid()
+		Arguments.makeNativeMap(mapOf("retired" to true))
+	}
+
+	internal fun documentScope(id: String, context: String, maximumBytes: Int = 8388608): NativeDocumentScope {
+		if (!AdmissionUrl.validToken(context)) invalid()
+		return createAdmissionDocumentScope(current(id), context, maximumBytes)
+	}
+
+	@ReactMethod fun bootstrap(id: String, context: String, request: String, url: String, credential: String, body: String, promise: Promise) {
+		scheduler.dispatch {
+			try {
+				current(id)
+				(bootstrapRequests ?: invalid()).start(context, request, url, credential, body) { reply ->
+					if (reply == null) reject(promise)
+					else promise.resolve(Arguments.makeNativeMap(mapOf(
+						"status" to reply.status, "cacheControl" to reply.cacheControl,
+						"bodyBase64" to Base64.encodeToString(reply.body, Base64.NO_WRAP))))
+				}
+			} catch (_: Exception) { reject(promise) }
+		}
+	}
+
+	@ReactMethod fun cancelBootstrap(id: String, context: String, request: String, promise: Promise) = action(promise) {
+		if (!AdmissionUrl.validToken(context) || !AdmissionUrl.validToken(request)) invalid()
+		if (installation == id) (bootstrapRequests ?: invalid()).cancel(context, request)
+		else if (lastRemoved != id) invalid()
+		Arguments.makeNativeMap(mapOf("cancelled" to true))
+	}
+
+	@ReactMethod fun completeBatch(id: String, context: String, generation: Double, batch: String, source: ReadableArray, promise: Promise) = action(promise) {
+		val admission = current(id)
+		if (!AdmissionUrl.validToken(context) || !AdmissionUrl.validToken(batch) || generation != 1.0 || source.size() > AdmissionLimits.BATCH) invalid()
+		var characters = 0
+		fun string(map: ReadableMap, key: String, maximum: Int = AdmissionLimits.URL): String {
+			val value = map.getString(key) ?: invalid()
+			characters += value.length
+			if (value.length > maximum || characters > AdmissionLimits.BRIDGE_BYTES) invalid()
+			return value
+		}
+		fun strings(map: ReadableMap, key: String, maximum: Int): List<String> {
+			val array = map.getArray(key) ?: invalid()
+			if (array.size() > maximum) invalid()
+			return (0 until array.size()).map { index ->
+				val value = array.getString(index) ?: invalid()
+				characters += value.length
+				if (value.length > AdmissionLimits.URL || characters > AdmissionLimits.BRIDGE_BYTES) invalid()
+				value
+			}
+		}
+		val results = (0 until source.size()).map { index ->
+			val item = source.getMap(index) ?: invalid()
+			val ticket = string(item, "ticket", 96)
+			if (!AdmissionUrl.validToken(ticket)) invalid()
+			when (string(item, "kind", 16)) {
+				"delegate" -> AdmissionResult.Delegate(ticket)
+				"reject" -> AdmissionResult.Reject(ticket)
+				"grant" -> {
+					val budget = item.getDouble("validForMs")
+					if (!budget.isFinite() || budget != budget.toLong().toDouble() || budget <= 0 || budget > AdmissionLimits.MAX_VALID_MS) invalid()
+					val authority = item.getMap("authority") ?: invalid()
+					AdmissionResult.Grant(ticket, budget.toLong(), AdmissionAuthority(string(authority, "grant", AdmissionLimits.GRANT),
+						string(authority, "mapId", 64), strings(authority, "resourceOrigins", 2), strings(authority, "resourceScopes", 6), strings(authority, "tilesetIds", 18)))
+				}
+				else -> invalid()
+			}
+		}
+		Arguments.makeNativeMap(mapOf("accepted" to admission.complete(context, 1, batch, results)))
+	}
+
+	@ReactMethod fun remove(id: String, promise: Promise) = action(promise) {
+		if (installation == null && id == lastRemoved) return@action Arguments.makeNativeMap(lastRemoval ?: invalid())
+		if (id != installation) invalid()
+		Arguments.makeNativeMap(shutdown())
+	}
+
+	private fun current(id: String): AdmissionEngine {
+		if (installation != id || invalidated) invalid()
+		val admission = engine ?: invalid()
+		if (!admission.checkOwnership()) invalid()
+		return admission
+	}
+	private fun action(promise: Promise, block: () -> Any) {
+		scheduler.dispatch {
+			try { promise.resolve(block()) }
+			catch (_: Exception) { reject(promise) }
+		}
+	}
+	private fun reject(promise: Promise) { promise.reject("NATIVE_ADMISSION_UNAVAILABLE", "Native resource admission failed") }
+	private fun emit(event: Map<String, Any>) {
+		when (event["kind"]) {
+			"retired" -> (event["context"] as? String)?.let {
+				bootstrapRequests?.retire(it)
+				reactApplicationContext.getNativeModule(TileflowNativeDocumentsModule::class.java)?.retireNativeContext(it)
+			}
+			"ownershipLost" -> bootstrapRequests?.close()
+			"lifecycle" -> bootstrapRequests?.lifecycle(event["foreground"] == true)
+		}
+		if (listeners <= 0 || invalidated) throw IllegalStateException("Native admission listener is unavailable")
+		reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+			.emit("TileflowNativeAdmissionEvent", Arguments.makeNativeMap(event))
+	}
+
+	override fun onHostPause() { scheduler.dispatch { engine?.lifecycle(false) } }
+	override fun onHostResume() { scheduler.dispatch { engine?.lifecycle(true) } }
+	override fun onHostDestroy() { scheduler.dispatch { invalidated = true; teardown() } }
+	override fun invalidate() {
+		reactApplicationContext.removeLifecycleEventListener(this)
+		scheduler.dispatch { invalidated = true; teardown() }
+		super.invalidate()
+	}
+	private fun teardown() {
+		try { shutdown() } catch (_: Exception) { /* Retain failed cleanup for retry; never report success. */ }
+	}
+	private fun shutdown(): Map<String, Boolean> {
+		val id = installation ?: return lastRemoval ?: mapOf("removed" to false, "ownershipLost" to false)
+		bootstrapRequests?.close(); engine?.close(); network?.close(); bootstrapNetwork?.close()
+		val ack = (lease ?: invalid()).remove()
+		lastRemoved = id; lastRemoval = ack
+		installation = null; engine = null; network = null; lease = null
+		bootstrapRequests = null; bootstrapNetwork = null
+		return ack
+	}
+	private fun invalid(): Nothing = throw IllegalArgumentException("Invalid native admission")
+}

package/android/src/main/java/dev/tileflow/reactnative/TileflowNativeAdmissionPackage.kt

@@ -0,0 +1,16 @@
+package dev.tileflow.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class TileflowNativeAdmissionPackage : ReactPackage {
+	override fun createNativeModules(context: ReactApplicationContext): List<NativeModule> = listOf(
+		TileflowNativeAdmissionModule(context),
+		TileflowNativeConfigurationModule(context),
+		TileflowNativeDocumentsModule(context),
+		TileflowNativeSurfaceModule(context)
+	)
+	override fun createViewManagers(context: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}

package/android/src/main/java/dev/tileflow/reactnative/TileflowNativeConfigurationModule.kt

@@ -0,0 +1,43 @@
+package dev.tileflow.reactnative
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+class TileflowNativeConfigurationModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+	private var invalidated = false
+
+	override fun getName() = "TileflowNativeConfiguration"
+
+	@ReactMethod fun readConfiguration(promise: Promise) {
+		synchronized(this) {
+			if (invalidated) {
+				promise.reject("NATIVE_CONFIGURATION_UNAVAILABLE", "Native application configuration is unavailable.")
+				return
+			}
+			val configuration = try {
+				applicationConfiguration.read { readMobileConfigurationResources(reactApplicationContext) }
+			} catch (_: Exception) {
+				promise.reject("NATIVE_CONFIGURATION_INVALID", "Native application configuration is invalid.")
+				return
+			}
+			// No constants, events or public state. This bounded response belongs to the private bridge.
+			promise.resolve(Arguments.makeNativeMap(mapOf(
+				"apiOrigin" to configuration.apiOrigin,
+				"credential" to configuration.credential
+			)))
+		}
+	}
+
+	override fun invalidate() {
+		synchronized(this) { invalidated = true }
+		super.invalidate()
+	}
+
+	companion object {
+		// The cache retains immutable application data, never a React context or Map lifetime.
+		private val applicationConfiguration = MobileConfigurationCache()
+	}
+}

package/android/src/main/java/dev/tileflow/reactnative/TileflowNativeDocumentsModule.kt

@@ -0,0 +1,80 @@
+package dev.tileflow.reactnative
+
+import android.util.Base64
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.common.LifecycleState
+
+class TileflowNativeDocumentsModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context), LifecycleEventListener {
+	private val scheduler = HandlerAdmissionScheduler()
+	private val network = NativeDocumentOkHttpNetwork()
+	private val registry = NativeDocumentRegistry(scheduler, { url, limit, scope, developmentOrigin, active, completion ->
+		if (scope == null) network.start(url, limit, active, completion, developmentOrigin)
+		else scope.load(url, completion)
+	})
+	@Volatile private var invalidated = false
+
+	init {
+		registry.lifecycle(context.lifecycleState == LifecycleState.RESUMED)
+		context.addLifecycleEventListener(this)
+	}
+	override fun getName() = "TileflowNativeDocuments"
+
+	@ReactMethod fun openDocument(url: String, maximumBytes: Double, installation: String?, context: String?, developmentOrigin: String?, promise: Promise) = action(promise) {
+		if (invalidated || !maximumBytes.isFinite() || maximumBytes != maximumBytes.toInt().toDouble() || maximumBytes < 1 || maximumBytes > 8388608 ||
+			(installation == null) != (context == null)) invalid()
+		val scope = if (installation == null) null else {
+			if (!AdmissionUrl.validToken(installation) || !AdmissionUrl.validToken(context!!)) invalid()
+			val admission = reactApplicationContext.getNativeModule(TileflowNativeAdmissionModule::class.java) ?: invalid()
+			admission.documentScope(installation!!, context!!, maximumBytes.toInt())
+		}
+		Arguments.makeNativeMap(mapOf("document" to registry.open(url, maximumBytes.toInt(), scope, developmentOrigin)))
+	}
+
+	@ReactMethod fun documentResponse(document: String, promise: Promise) {
+		scheduler.dispatch {
+			try {
+				if (invalidated || !AdmissionUrl.validToken(document)) invalid()
+				registry.response(document) { response ->
+					if (response == null || invalidated) reject(promise)
+					else promise.resolve(Arguments.makeNativeMap(mapOf("url" to response.url, "status" to response.status)))
+				}
+			} catch (_: Exception) { reject(promise) }
+		}
+	}
+
+	@ReactMethod fun documentChunk(document: String, maximumBytes: Double, promise: Promise) = action(promise) {
+		if (invalidated || !maximumBytes.isFinite() || maximumBytes != maximumBytes.toInt().toDouble() || maximumBytes < 1 || maximumBytes > 65536) invalid()
+		val chunk = registry.chunk(document, maximumBytes.toInt())
+		val encoded = Base64.encodeToString(chunk.bytes, Base64.NO_WRAP)
+		chunk.bytes.fill(0)
+		Arguments.makeNativeMap(mapOf("bodyBase64" to encoded, "last" to chunk.last))
+	}
+
+	@ReactMethod fun cancelDocument(document: String, promise: Promise) = action(promise) {
+		registry.cancel(document)
+		Arguments.makeNativeMap(mapOf("cancelled" to true))
+	}
+
+	internal fun retireNativeContext(context: String) { registry.retireContext(context) }
+	private fun action(promise: Promise, block: () -> Any) {
+		scheduler.dispatch {
+			try { promise.resolve(block()) }
+			catch (_: Exception) { reject(promise) }
+		}
+	}
+	private fun reject(promise: Promise) { promise.reject("NATIVE_DOCUMENT_UNAVAILABLE", "Native document acquisition failed.") }
+	private fun invalid(): Nothing = throw IllegalArgumentException("Native document acquisition failed.")
+	override fun onHostPause() { scheduler.dispatch { registry.lifecycle(false) } }
+	override fun onHostResume() { scheduler.dispatch { if (!invalidated) registry.lifecycle(true) } }
+	override fun onHostDestroy() { scheduler.dispatch { invalidated = true; registry.close(); network.close() } }
+	override fun invalidate() {
+		reactApplicationContext.removeLifecycleEventListener(this)
+		scheduler.dispatch { invalidated = true; registry.close(); network.close() }
+		super.invalidate()
+	}
+}