@tamer4lynx/tamer-host 0.0.1

package/README.md

@@ -0,0 +1,48 @@
+# tamer-host
+
+Production Lynx host templates for injecting LynxView into existing Android and iOS apps.
+
+## Overview
+
+`tamer-host` provides the minimal native infrastructure needed to run a Lynx bundle in an existing app:
+
+- **Android**: `App.java`, `TemplateProvider.java`, `MainActivity.kt`
+- **iOS**: `AppDelegate.swift`, `SceneDelegate.swift`, `ViewController.swift`, `LynxProvider.swift`, `LynxInitProcessor.swift`
+
+## Installation
+
+```bash
+npm install @tamer4lynx/tamer-host
+```
+
+## Usage
+
+### Inject into an existing project
+
+After creating an Android or iOS project (or if you already have one), run:
+
+```bash
+t4l android inject
+t4l ios inject
+```
+
+Use `--force` to overwrite existing files:
+
+```bash
+t4l android inject --force
+```
+
+### Prerequisites
+
+- `tamer.config.json` with `android.packageName` / `ios.appName` and `ios.bundleId`
+- An existing Android project (`android/app/src/main/java/`, `android/app/src/main/kotlin/`) or iOS project (`ios/<AppName>/`)
+- Run `t4l link` after injecting to register native modules
+
+### Create flow
+
+`t4l android create` and `t4l ios create` use `tamer-host` templates when the package is installed. If `tamer-host` is not installed, the CLI falls back to inline templates.
+
+## Related
+
+- [tamer-dev-client](https://github.com/tamer4lynx/tamer-dev-client) — Adds dev launcher (QR scan, HMR) on top of the host
+- [Embedding LynxView into Native View](https://lynxjs.org/guide/embed-lynx-to-native) — Lynx guide for embedding LynxView in existing layouts

package/android/templates/App.java

@@ -0,0 +1,41 @@
+package {{PACKAGE_NAME}};
+
+import android.app.Application;
+import com.facebook.drawee.backends.pipeline.Fresco;
+import com.facebook.imagepipeline.core.ImagePipelineConfig;
+import com.facebook.imagepipeline.memory.PoolConfig;
+import com.facebook.imagepipeline.memory.PoolFactory;
+import com.lynx.service.http.LynxHttpService;
+import com.lynx.service.image.LynxImageService;
+import com.lynx.service.log.LynxLogService;
+import com.lynx.tasm.LynxEnv;
+import com.lynx.tasm.service.LynxServiceCenter;
+import {{PACKAGE_NAME}}.generated.GeneratedLynxExtensions;
+
+public class App extends Application {
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        initLynxService();
+        initFresco();
+        initLynxEnv();
+    }
+
+    private void initLynxEnv() {
+        GeneratedLynxExtensions.INSTANCE.register(this);
+        LynxEnv.inst().init(this, null, new TemplateProvider(this), null);
+    }
+
+    private void initLynxService() {
+        LynxServiceCenter.inst().registerService(LynxLogService.INSTANCE);
+        LynxServiceCenter.inst().registerService(LynxImageService.getInstance());
+        LynxServiceCenter.inst().registerService(LynxHttpService.INSTANCE);
+    }
+
+    private void initFresco() {
+        final PoolFactory factory = new PoolFactory(PoolConfig.newBuilder().build());
+        ImagePipelineConfig.Builder builder =
+                ImagePipelineConfig.newBuilder(getApplicationContext()).setPoolFactory(factory);
+        Fresco.initialize(getApplicationContext(), builder.build());
+    }
+}

package/android/templates/MainActivity.kt

@@ -0,0 +1,104 @@
+package {{PACKAGE_NAME}}
+
+import android.os.Bundle
+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.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import androidx.core.view.ViewCompat
+import androidx.core.view.updatePadding
+import com.lynx.tasm.LynxView
+import com.lynx.tasm.LynxViewBuilder
+import {{PACKAGE_NAME}}.generated.GeneratedLynxExtensions
+import {{PACKAGE_NAME}}.generated.GeneratedActivityLifecycle
+
+class MainActivity : AppCompatActivity() {
+    private var lynxView: LynxView? = null
+    private val handler = android.os.Handler(android.os.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)
+        ViewCompat.setOnApplyWindowInsetsListener(lynxView!!) { view, insets ->
+            val imeVisible = insets.isVisible(WindowInsetsCompat.Type.ime())
+            val imeHeight = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
+            view.updatePadding(bottom = if (imeVisible) imeHeight else 0)
+            insets
+        }
+        GeneratedActivityLifecycle.onViewAttached(lynxView)
+        GeneratedLynxExtensions.onHostViewChanged(lynxView)
+        lynxView?.renderTemplateUrl("main.lynx.bundle", "")
+        GeneratedActivityLifecycle.onCreateDelayed(handler)
+    }
+
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        super.onWindowFocusChanged(hasFocus)
+        GeneratedActivityLifecycle.onWindowFocusChanged(hasFocus)
+    }
+
+    override fun onNewIntent(intent: android.content.Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        GeneratedActivityLifecycle.onNewIntent(intent)
+    }
+
+    override fun onPause() {
+        super.onPause()
+        GeneratedActivityLifecycle.onPause()
+    }
+
+    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)
+            }
+        }
+    }
+
+    @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
+        super.onDestroy()
+    }
+
+    private fun buildLynxView(): LynxView {
+        val viewBuilder = LynxViewBuilder()
+        viewBuilder.setTemplateProvider(TemplateProvider(this))
+        return viewBuilder.build(this)
+    }
+}

package/android/templates/TemplateProvider.java

@@ -0,0 +1,30 @@
+package {{PACKAGE_NAME}};
+
+import com.lynx.tasm.provider.AbsTemplateProvider;
+
+public class TemplateProvider extends AbsTemplateProvider {
+    private final android.content.Context context;
+
+    public TemplateProvider(android.content.Context context) {
+        this.context = context.getApplicationContext();
+    }
+
+    @Override
+    public void loadTemplate(String url, final Callback callback) {
+        new Thread(() -> {
+            try {
+                java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
+                try (java.io.InputStream is = context.getAssets().open(url)) {
+                    byte[] buf = new byte[1024];
+                    int n;
+                    while ((n = is.read(buf)) != -1) {
+                        baos.write(buf, 0, n);
+                    }
+                }
+                callback.onSuccess(baos.toByteArray());
+            } catch (java.io.IOException e) {
+                callback.onFailed(e.getMessage());
+            }
+        }).start();
+    }
+}

package/ios/templates/AppDelegate.swift

@@ -0,0 +1,13 @@
+import UIKit
+
+@UIApplicationMain
+class AppDelegate: UIResponder, UIApplicationDelegate {
+  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+      LynxInitProcessor.shared.setupEnvironment()
+      return true
+  }
+
+  func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
+      return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
+  }
+}

package/ios/templates/LynxInitProcessor.swift

@@ -0,0 +1,37 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+import Foundation
+
+// GENERATED IMPORTS START
+// This section is automatically generated by Tamer4Lynx.
+// Manual edits will be overwritten.
+// GENERATED IMPORTS END
+
+final class LynxInitProcessor {
+    static let shared = LynxInitProcessor()
+    private init() {}
+
+    func setupEnvironment() {
+        TamerIconElement.registerFonts()
+        setupLynxEnv()
+        setupLynxService()
+    }
+
+    private func setupLynxEnv() {
+        let env = LynxEnv.sharedInstance()
+        let globalConfig = LynxConfig(provider: env.config.templateProvider)
+
+        // GENERATED AUTOLINK START
+
+        // GENERATED AUTOLINK END
+
+        env.prepareConfig(globalConfig)
+    }
+
+    private func setupLynxService() {
+        let webPCoder = SDImageWebPCoder.shared
+        SDImageCodersManager.shared.addCoder(webPCoder)
+    }
+}

package/ios/templates/LynxProvider.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+class LynxProvider: NSObject, LynxTemplateProvider {
+    func loadTemplate(withUrl url: String!, onComplete callback: LynxTemplateLoadBlock!) {
+        DispatchQueue.global(qos: .background).async {
+            guard let url = url,
+                  let bundleUrl = Bundle.main.url(forResource: url, withExtension: nil),
+                  let data = try? Data(contentsOf: bundleUrl) else {
+                let err = NSError(domain: "LynxProvider", code: 404,
+                                  userInfo: [NSLocalizedDescriptionKey: "Bundle not found: \(url ?? "nil")"])
+                callback?(nil, err)
+                return
+            }
+            callback?(data, nil)
+        }
+    }
+}

package/ios/templates/SceneDelegate.swift

@@ -0,0 +1,12 @@
+import UIKit
+
+class SceneDelegate: UIResponder, UIWindowSceneDelegate {
+  var window: UIWindow?
+
+  func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
+      guard let windowScene = scene as? UIWindowScene else { return }
+      window = UIWindow(windowScene: windowScene)
+      window?.rootViewController = ViewController()
+      window?.makeKeyAndVisible()
+  }
+}

package/ios/templates/ViewController.swift

@@ -0,0 +1,68 @@
+import UIKit
+import Lynx
+import tamerinsets
+
+class ViewController: UIViewController {
+  private var lynxView: LynxView?
+
+  override func viewDidLoad() {
+    super.viewDidLoad()
+    view.backgroundColor = .black
+    edgesForExtendedLayout = .all
+    extendedLayoutIncludesOpaqueBars = true
+    additionalSafeAreaInsets = .zero
+    view.insetsLayoutMarginsFromSafeArea = false
+    view.preservesSuperviewLayoutMargins = false
+    viewRespectsSystemMinimumLayoutMargins = false
+  }
+
+  override func viewDidLayoutSubviews() {
+    super.viewDidLayoutSubviews()
+    guard view.bounds.width > 0, view.bounds.height > 0 else { return }
+    if lynxView == nil {
+      setupLynxView()
+    } else {
+      applyFullscreenLayout(to: lynxView!)
+    }
+  }
+
+  override func viewSafeAreaInsetsDidChange() {
+    super.viewSafeAreaInsetsDidChange()
+    TamerInsetsModule.reRequestInsets()
+  }
+
+  override var preferredStatusBarStyle: UIStatusBarStyle { .lightContent }
+
+  private func buildLynxView() -> LynxView {
+    let bounds = view.bounds
+    let lv = LynxView { builder in
+      builder.config = LynxConfig(provider: LynxProvider())
+      builder.screenSize = bounds.size
+      builder.fontScale = 1.0
+    }
+    lv.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    lv.insetsLayoutMarginsFromSafeArea = false
+    lv.preservesSuperviewLayoutMargins = false
+    applyFullscreenLayout(to: lv)
+    return lv
+  }
+
+  private func setupLynxView() {
+    let lv = buildLynxView()
+    view.addSubview(lv)
+    lv.loadTemplate(fromURL: "main.lynx.bundle", initData: nil)
+    self.lynxView = lv
+  }
+
+  private func applyFullscreenLayout(to lynxView: LynxView) {
+    let bounds = view.bounds
+    let size = bounds.size
+    lynxView.frame = bounds
+    lynxView.updateScreenMetrics(withWidth: size.width, height: size.height)
+    lynxView.updateViewport(withPreferredLayoutWidth: size.width, preferredLayoutHeight: size.height, needLayout: true)
+    lynxView.preferredLayoutWidth = size.width
+    lynxView.preferredLayoutHeight = size.height
+    lynxView.layoutWidthMode = .exact
+    lynxView.layoutHeightMode = .exact
+  }
+}

package/lynx.ext.json

@@ -0,0 +1,12 @@
+{
+  "hostTransforms": {
+    "android": {
+      "templateDir": "android/templates",
+      "replaceTemplateProvider": true
+    },
+    "ios": {
+      "templateDir": "ios/templates",
+      "injectViewControllers": ["ViewController"]
+    }
+  }
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@tamer4lynx/tamer-host",
+  "version": "0.0.1",
+  "publishConfig": { "access": "public", "tag": "prerelease" },
+  "type": "module",
+  "description": "Production Lynx host templates for injecting LynxView into existing apps",
+  "files": ["android/templates", "ios", "lynx.ext.json"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tamer4lynx/tamer-host.git"
+  },
+  "homepage": "https://github.com/tamer4lynx/tamer-host#readme",
+  "bugs": {
+    "url": "https://github.com/tamer4lynx/tamer-host/issues"
+  },
+  "author": "Nanofuxion",
+  "license": "MIT"
+}