@tamer4lynx/tamer-dev-client 0.0.1

package/android/src/main/kotlin/com/nanofuxion/tamerdevclient/nsd/ResolveService.kt

@@ -0,0 +1,28 @@
+package com.nanofuxion.tamerdevclient.nsd
+
+import android.net.nsd.NsdManager
+import android.net.nsd.NsdServiceInfo
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+@Suppress("DEPRECATION")
+suspend fun NsdManager.resolveServiceCoroutine(serviceInfo: NsdServiceInfo): NsdServiceInfo =
+    suspendCancellableCoroutine { cont ->
+        resolveService(
+            serviceInfo,
+            object : NsdManager.ResolveListener {
+                override fun onResolveFailed(info: NsdServiceInfo, errorCode: Int) {
+                    if (cont.isActive) {
+                        cont.resumeWithException(RuntimeException("Resolve failed: errorCode=$errorCode"))
+                    }
+                }
+
+                override fun onServiceResolved(resolvedInfo: NsdServiceInfo) {
+                    if (cont.isActive) {
+                        cont.resume(resolvedInfo)
+                    }
+                }
+            }
+        )
+    }

package/android/templates/DevClientManager.kt

@@ -0,0 +1,49 @@
+package {{PACKAGE_NAME}}
+
+import android.content.Context
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+
+class DevClientManager(private val context: Context, private val onReload: Runnable) {
+    private var webSocket: WebSocket? = null
+    private val handler = Handler(Looper.getMainLooper())
+    private val client = OkHttpClient.Builder()
+        .connectTimeout(5, java.util.concurrent.TimeUnit.SECONDS)
+        .readTimeout(0, java.util.concurrent.TimeUnit.SECONDS)
+        .build()
+
+    fun connect() {
+        val devUrl = DevServerPrefs.getUrl(context) ?: return
+        val uri = Uri.parse(devUrl)
+        val scheme = if (uri.scheme == "https") "wss" else "ws"
+        val host = uri.host ?: return
+        val port = if (uri.port > 0) ":${uri.port}" else ""
+        val path = (uri.path ?: "").let { p -> (if (p.endsWith("/")) p else p + "/") + "__hmr" }
+        val wsUrl = "$scheme://$host$port$path"
+        val request = Request.Builder()
+            .url(wsUrl)
+            .build()
+        webSocket = client.newWebSocket(request, object : WebSocketListener() {
+            override fun onMessage(webSocket: WebSocket, text: String) {
+                try {
+                    if (text.contains("\"type\":\"reload\"")) {
+                        handler.post(onReload)
+                    }
+                } catch (_: Exception) { }
+            }
+            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) { }
+            override fun onClosed(webSocket: WebSocket, code: Int, reason: String) { }
+        })
+    }
+
+    fun disconnect() {
+        webSocket?.close(1000, null)
+        webSocket = null
+    }
+}

package/android/templates/DevServerPrefs.kt

@@ -0,0 +1,44 @@
+package {{PACKAGE_NAME}}
+
+import android.content.Context
+import android.content.SharedPreferences
+import org.json.JSONArray
+
+object DevServerPrefs {
+    private const val PREFS = "tamer_dev_server"
+    private const val KEY_URL = "dev_server_url"
+    private const val KEY_RECENT = "dev_server_recent"
+
+    fun getUrl(context: Context): String? {
+        return prefs(context).getString(KEY_URL, null)
+    }
+
+    fun setUrl(context: Context, url: String) {
+        prefs(context).edit().putString(KEY_URL, url).apply()
+        addRecent(context, url)
+    }
+
+    fun getRecentUrls(context: Context): List<String> {
+        val json = prefs(context).getString(KEY_RECENT, "[]") ?: "[]"
+        return try {
+            val arr = JSONArray(json)
+            (0 until arr.length()).map { arr.getString(it) }.distinct().take(10)
+        } catch (_: Exception) { emptyList() }
+    }
+
+    fun addRecent(context: Context, url: String) {
+        val current = getRecentUrls(context).filter { it != url }
+        val updated = listOf(url) + current
+        prefs(context).edit()
+            .putString(KEY_RECENT, JSONArray(updated.take(10)).toString())
+            .apply()
+    }
+
+    fun clear(context: Context) {
+        prefs(context).edit().clear().apply()
+    }
+
+    private fun prefs(context: Context): SharedPreferences {
+        return context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+    }
+}

package/android/templates/PortraitCaptureActivity.kt

@@ -0,0 +1,5 @@
+package {{PACKAGE_NAME}}
+
+import com.journeyapps.barcodescanner.CaptureActivity
+
+class PortraitCaptureActivity : CaptureActivity()

package/android/templates/ProjectActivity.kt

@@ -0,0 +1,112 @@
+package {{PACKAGE_NAME}}
+
+import android.content.Intent
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.view.MotionEvent
+import android.view.inputmethod.InputMethodManager
+import android.widget.EditText
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.lynx.tasm.LynxView
+import com.lynx.tasm.LynxViewBuilder
+import {{PACKAGE_NAME}}.DevClientManager
+import {{PACKAGE_NAME}}.generated.GeneratedLynxExtensions
+import {{PACKAGE_NAME}}.generated.GeneratedActivityLifecycle
+
+class ProjectActivity : AppCompatActivity() {
+    private var lynxView: LynxView? = null
+    private var devClientManager: DevClientManager? = null
+    private val handler = Handler(Looper.getMainLooper())
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        GeneratedActivityLifecycle.onCreate(intent)
+        WindowCompat.setDecorFitsSystemWindows(window, false)
+        WindowInsetsControllerCompat(window, window.decorView).isAppearanceLightStatusBars = true
+        lynxView = buildLynxView()
+        setContentView(lynxView)
+        GeneratedActivityLifecycle.onViewAttached(lynxView)
+        GeneratedLynxExtensions.onHostViewChanged(lynxView)
+        lynxView?.renderTemplateUrl("main.lynx.bundle", "")
+        devClientManager = DevClientManager(this) { reloadProjectView() }
+        devClientManager?.connect()
+        GeneratedActivityLifecycle.onCreateDelayed(handler)
+    }
+
+    private fun reloadProjectView() {
+        GeneratedActivityLifecycle.onViewDetached()
+        GeneratedLynxExtensions.onHostViewChanged(null)
+        lynxView?.destroy()
+
+        val nextView = buildLynxView()
+        lynxView = nextView
+        setContentView(nextView)
+        GeneratedActivityLifecycle.onViewAttached(nextView)
+        GeneratedLynxExtensions.onHostViewChanged(nextView)
+        nextView.renderTemplateUrl("main.lynx.bundle", "")
+        GeneratedActivityLifecycle.onCreateDelayed(handler)
+    }
+
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        super.onWindowFocusChanged(hasFocus)
+        GeneratedActivityLifecycle.onWindowFocusChanged(hasFocus)
+    }
+
+    override fun onResume() {
+        super.onResume()
+        GeneratedActivityLifecycle.onResume()
+    }
+
+    override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+        if (ev.action == MotionEvent.ACTION_DOWN) maybeClearFocusedInput(ev)
+        return super.dispatchTouchEvent(ev)
+    }
+
+    private fun maybeClearFocusedInput(ev: MotionEvent) {
+        val focused = currentFocus
+        if (focused is EditText) {
+            val loc = IntArray(2)
+            focused.getLocationOnScreen(loc)
+            val x = ev.rawX.toInt()
+            val y = ev.rawY.toInt()
+            if (x < loc[0] || x > loc[0] + focused.width || y < loc[1] || y > loc[1] + focused.height) {
+                focused.clearFocus()
+                (getSystemService(INPUT_METHOD_SERVICE) as? InputMethodManager)
+                    ?.hideSoftInputFromWindow(focused.windowToken, 0)
+            }
+        }
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        GeneratedActivityLifecycle.onNewIntent(intent)
+    }
+
+    @Deprecated("Deprecated in Java")
+    override fun onBackPressed() {
+        GeneratedActivityLifecycle.onBackPressed { consumed ->
+            if (!consumed) {
+                runOnUiThread { super.onBackPressed() }
+            }
+        }
+    }
+
+    override fun onDestroy() {
+        GeneratedActivityLifecycle.onViewDetached()
+        GeneratedLynxExtensions.onHostViewChanged(null)
+        lynxView?.destroy()
+        lynxView = null
+        devClientManager?.disconnect()
+        super.onDestroy()
+    }
+
+    private fun buildLynxView(): LynxView {
+        val viewBuilder = LynxViewBuilder()
+        viewBuilder.setTemplateProvider(TemplateProvider(this))
+        return viewBuilder.build(this)
+    }
+}

package/ios/tamerdevclient/tamerdevclient/Classes/DevClientModule.swift

@@ -0,0 +1,298 @@
+import Foundation
+import Lynx
+import AVFoundation
+
+private final class BonjourResolver: NSObject, NetServiceBrowserDelegate, NetServiceDelegate {
+    var onServersChanged: (([[String: String]]) -> Void)?
+
+    private let browser = NetServiceBrowser()
+    private var services: [String: NetService] = [:]
+    private var resolved: [String: [String: String]] = [:]
+
+    override init() {
+        super.init()
+        browser.delegate = self
+    }
+
+    func start() {
+        browser.schedule(in: .main, forMode: .common)
+        browser.searchForServices(ofType: "_tamer._tcp.", inDomain: "local.")
+    }
+
+    func stop() {
+        browser.stop()
+        browser.remove(from: .main, forMode: .common)
+        services.values.forEach { service in
+            service.stop()
+            service.remove(from: .main, forMode: .common)
+            service.delegate = nil
+        }
+        services.removeAll()
+        resolved.removeAll()
+        onServersChanged?([])
+    }
+
+    func netServiceBrowserWillSearch(_ browser: NetServiceBrowser) {
+        onServersChanged?(Array(resolved.values))
+    }
+
+    func netServiceBrowser(_ browser: NetServiceBrowser, didFind service: NetService, moreComing: Bool) {
+        let key = serviceKey(service)
+        service.delegate = self
+        service.schedule(in: .main, forMode: .common)
+        services[key] = service
+        service.resolve(withTimeout: 10)
+        if !moreComing {
+            onServersChanged?(sortedServers())
+        }
+    }
+
+    func netServiceBrowser(_ browser: NetServiceBrowser, didRemove service: NetService, moreComing: Bool) {
+        let key = serviceKey(service)
+        services[key]?.stop()
+        services[key]?.delegate = nil
+        services.removeValue(forKey: key)
+        resolved.removeValue(forKey: key)
+        if !moreComing {
+            onServersChanged?(sortedServers())
+        }
+    }
+
+    func netServiceDidResolveAddress(_ sender: NetService) {
+        let key = serviceKey(sender)
+        guard let host = sender.hostName?.trimmingCharacters(in: CharacterSet(charactersIn: ".")),
+              !host.isEmpty,
+              sender.port > 0 else {
+            return
+        }
+        resolved[key] = [
+            "url": "http://\(host):\(sender.port)",
+            "name": sender.name
+        ]
+        onServersChanged?(sortedServers())
+    }
+
+    func netService(_ sender: NetService, didNotResolve errorDict: [String : NSNumber]) {
+        resolved.removeValue(forKey: serviceKey(sender))
+        onServersChanged?(sortedServers())
+    }
+
+    private func serviceKey(_ service: NetService) -> String {
+        "\(service.name)|\(service.type)|\(service.domain)"
+    }
+
+    private func sortedServers() -> [[String: String]] {
+        resolved.values.sorted { lhs, rhs in
+            (lhs["name"] ?? lhs["url"] ?? "") < (rhs["name"] ?? rhs["url"] ?? "")
+        }
+    }
+}
+
+@objcMembers
+public final class DevClientModule: NSObject, LynxModule {
+
+    // MARK: - LynxModule Protocol
+
+    @objc public static var name: String { "DevClientModule" }
+
+    @objc public static var methodLookup: [String: String] {
+        [
+            "getDevServerUrl":          NSStringFromSelector(#selector(getDevServerUrl(_:))),
+            "setDevServerUrl":          NSStringFromSelector(#selector(setDevServerUrl(_:))),
+            "getRecentUrls":            NSStringFromSelector(#selector(getRecentUrls(_:))),
+            "clearDevServerUrl":        NSStringFromSelector(#selector(clearDevServerUrl)),
+            "scanQR":                   NSStringFromSelector(#selector(scanQR)),
+            "reloadWithProjectBundle":  NSStringFromSelector(#selector(reloadWithProjectBundle)),
+            "startDiscovery":           NSStringFromSelector(#selector(startDiscovery)),
+            "stopDiscovery":            NSStringFromSelector(#selector(stopDiscovery)),
+            "getDiscoveredServers":     NSStringFromSelector(#selector(getDiscoveredServers(_:))),
+            "checkServerCompatibility": NSStringFromSelector(#selector(checkServerCompatibility(_:callback:))),
+        ]
+    }
+
+    // MARK: - Static Attachment Points (set by DevLauncherViewController)
+
+    public static weak var shared: DevClientModule?
+
+    /// Present a QR scanner; call completion with scanned URL string or nil on cancel.
+    public static var presentQRScanner: ((@escaping (String?) -> Void) -> Void)?
+
+    /// Navigate to the project view controller.
+    public static var reloadProjectHandler: (() -> Void)?
+
+    // MARK: - Instance State
+
+    private weak var lynxContext: LynxContext?
+    private var bonjourResolver: BonjourResolver?
+    private var lastDiscovered: [[String: String]] = []
+
+    // MARK: - Init
+
+    @objc public required init(param: Any) {
+        super.init()
+        lynxContext = param as? LynxContext
+        DevClientModule.shared = self
+    }
+
+    @objc public override init() {
+        super.init()
+        DevClientModule.shared = self
+    }
+
+    // MARK: - LynxModule Methods
+
+    @objc func getDevServerUrl(_ callback: LynxCallbackBlock) {
+        callback(DevServerPrefs.getUrl() as Any)
+    }
+
+    @objc func setDevServerUrl(_ url: String) {
+        var normalized = url.trimmingCharacters(in: .whitespaces)
+        if normalized.hasSuffix("/main.lynx.bundle") {
+            normalized = String(normalized.dropLast("/main.lynx.bundle".count))
+        } else if normalized.hasSuffix("main.lynx.bundle") {
+            normalized = String(normalized.dropLast("main.lynx.bundle".count))
+                .trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+        }
+        DevServerPrefs.setUrl(normalized)
+    }
+
+    @objc func getRecentUrls(_ callback: LynxCallbackBlock) {
+        callback(DevServerPrefs.getRecentUrls() as NSArray)
+    }
+
+    @objc func clearDevServerUrl() {
+        DevServerPrefs.clear()
+    }
+
+    @objc func scanQR() {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            guard let present = DevClientModule.presentQRScanner else {
+                self.emitScanResult(nil)
+                return
+            }
+            present { [weak self] result in
+                self?.emitScanResult(result)
+            }
+        }
+    }
+
+    @objc func reloadWithProjectBundle() {
+        DispatchQueue.main.async {
+            DevClientModule.reloadProjectHandler?()
+        }
+    }
+
+    @objc func startDiscovery() {
+        guard bonjourResolver == nil else { return }
+        let resolver = BonjourResolver()
+        resolver.onServersChanged = { [weak self] servers in
+            self?.emitDiscoveredServers(servers)
+        }
+        bonjourResolver = resolver
+        DispatchQueue.main.async {
+            resolver.start()
+        }
+    }
+
+    @objc func stopDiscovery() {
+        bonjourResolver?.stop()
+        bonjourResolver = nil
+    }
+
+    @objc func getDiscoveredServers(_ callback: LynxCallbackBlock) {
+        let list = lastDiscovered.map { s -> NSDictionary in
+            ["url": s["url"] ?? "", "name": s["name"] ?? ""] as NSDictionary
+        }
+        callback(list as NSArray)
+    }
+
+    @objc func checkServerCompatibility(_ baseUrl: String, callback: @escaping LynxCallbackBlock) {
+        DispatchQueue.global(qos: .utility).async {
+            let trimmed = baseUrl.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+            guard let url = URL(string: trimmed + "/meta.json") else {
+                callback([true, []] as NSArray)
+                return
+            }
+            var req = URLRequest(url: url)
+            req.timeoutInterval = 5
+            URLSession.shared.dataTask(with: req) { data, _, _ in
+                guard let data = data,
+                      let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                      let modules = json["nativeModules"] as? [[String: Any]] else {
+                    callback([true, []] as NSArray)
+                    return
+                }
+                let required = modules.compactMap { $0["moduleClassName"] as? String }
+                callback([true, required] as NSArray)
+            }.resume()
+        }
+    }
+
+    // MARK: - Private
+
+    private func emitScanResult(_ url: String?) {
+        let payload = url.map { "{\"url\":\"\($0)\"}" } ?? "{\"url\":\"\"}"
+        sendEvent("devclient:scanResult", payload: payload)
+    }
+
+    private func emitDiscoveredServers(_ servers: [[String: String]]) {
+        lastDiscovered = servers
+        let payloadServers = servers.map { server -> [String: Any] in
+            [
+                "url": server["url"] ?? "",
+                "name": server["name"] ?? ""
+            ]
+        }
+        let payload = (try? JSONSerialization.data(withJSONObject: ["servers": payloadServers]))
+            .flatMap { String(data: $0, encoding: .utf8) } ?? "{\"servers\":[]}"
+        sendEvent("devclient:discoveredServers", payload: payload)
+    }
+
+    private func sendEvent(_ name: String, payload: String) {
+        let params: [[String: Any]] = [["payload": payload]]
+        if let ctx = lynxContext {
+            ctx.sendGlobalEvent(name, withParams: params)
+        } else if let ctx = DevClientModule.shared?.lynxContext {
+            ctx.sendGlobalEvent(name, withParams: params)
+        }
+    }
+}
+
+// MARK: - DevServerPrefs
+
+public final class DevServerPrefs {
+    private static let suite = "tamer_dev_server"
+    private static let keyUrl = "dev_server_url"
+    private static let keyRecent = "dev_server_recent"
+    private static var defaults: UserDefaults { UserDefaults(suiteName: suite) ?? .standard }
+
+    public static func getUrl() -> String? {
+        defaults.string(forKey: keyUrl)
+    }
+
+    public static func setUrl(_ url: String) {
+        defaults.set(url, forKey: keyUrl)
+        addRecent(url)
+    }
+
+    public static func getRecentUrls() -> [String] {
+        guard let json = defaults.string(forKey: keyRecent),
+              let data = json.data(using: .utf8),
+              let arr = try? JSONDecoder().decode([String].self, from: data) else { return [] }
+        return Array(arr.prefix(10))
+    }
+
+    public static func addRecent(_ url: String) {
+        var current = getRecentUrls().filter { $0 != url }
+        current.insert(url, at: 0)
+        if let data = try? JSONEncoder().encode(Array(current.prefix(10))),
+           let json = String(data: data, encoding: .utf8) {
+            defaults.set(json, forKey: keyRecent)
+        }
+    }
+
+    public static func clear() {
+        defaults.removePersistentDomain(forName: suite)
+    }
+}