@granite-js/screen 1.0.0

package/gradle-plugin/src/test/kotlin/run/granite/gradle/utils/TaskTestUtils.kt

@@ -0,0 +1,88 @@
+package run.granite.gradle.utils
+
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.testfixtures.ProjectBuilder
+import java.io.File
+
+/**
+ * Test utilities for creating and configuring Gradle tasks in tests.
+ */
+
+/**
+ * Creates a test project with Android Library plugin applied.
+ *
+ * @param projectDir Optional project directory (uses temp dir if not specified)
+ * @return Configured Gradle project
+ */
+internal fun createProject(projectDir: File? = null): Project {
+  val project = ProjectBuilder.builder()
+    .apply {
+      if (projectDir != null) {
+        withProjectDir(projectDir)
+      }
+    }
+    .build()
+
+  // Apply Android Library plugin for testing
+  project.plugins.apply("com.android.library")
+
+  return project
+}
+
+/**
+ * Creates and registers a test task of the specified type.
+ *
+ * This helper allows testing of abstract Gradle tasks by using Gradle's
+ * task registration mechanism which handles property injection.
+ *
+ * @param T Task type to create
+ * @param project Project to register the task in (defaults to new test project)
+ * @param taskName Name for the task (defaults to class simple name)
+ * @param block Configuration block to setup task properties
+ * @return Configured task instance
+ */
+internal inline fun <reified T : Task> createTestTask(
+  project: Project = createProject(),
+  taskName: String = T::class.java.simpleName,
+  noinline block: (T) -> Unit = {},
+): T = project.tasks.register(taskName, T::class.java, block).get()
+
+/**
+ * Creates a test file with specified content.
+ *
+ * @param parent Parent directory
+ * @param name File name
+ * @param content File content
+ * @return Created file
+ */
+internal fun createTestFile(parent: File, name: String, content: String): File {
+  val file = File(parent, name)
+  file.parentFile.mkdirs()
+  file.writeText(content)
+  return file
+}
+
+/**
+ * Creates a test directory structure.
+ *
+ * @param parent Parent directory
+ * @param path Directory path (can be nested with /)
+ * @return Created directory
+ */
+internal fun createTestDirectory(parent: File, path: String): File {
+  val dir = File(parent, path)
+  dir.mkdirs()
+  return dir
+}
+
+/**
+ * Reads a file and returns its content.
+ *
+ * @param file File to read
+ * @return File content as string
+ */
+internal fun readFileContent(file: File): String {
+  require(file.exists()) { "File does not exist: ${file.absolutePath}" }
+  return file.readText()
+}

package/gradle-plugin/src/test/resources/fixtures/sample-rn-config.json

@@ -0,0 +1,45 @@
+{
+  "project": {
+    "name": "test-project",
+    "version": "1.0.0",
+    "android": {
+      "sourceDir": "android",
+      "manifestPath": "android/AndroidManifest.xml",
+      "packageName": "com.example.testproject"
+    }
+  },
+  "dependencies": {
+    "react-native-webview": {
+      "name": "react-native-webview",
+      "root": "/path/to/node_modules/react-native-webview",
+      "platforms": {
+        "android": {
+          "sourceDir": "android",
+          "packageImportPath": "com.reactnativecommunity.webview.RNCWebViewPackage",
+          "packageInstance": "new RNCWebViewPackage()",
+          "libraryName": "RNCWebView",
+          "componentDescriptors": ["RNCWebViewComponentDescriptor"],
+          "cmakeListsPath": "android/CMakeLists.txt"
+        }
+      }
+    },
+    "react-native-camera": {
+      "name": "react-native-camera",
+      "root": "/path/to/node_modules/react-native-camera",
+      "platforms": {
+        "android": {
+          "sourceDir": "android",
+          "packageImportPath": "org.reactnative.camera.RNCameraPackage",
+          "packageInstance": "new RNCameraPackage()",
+          "libraryName": "RNCamera",
+          "componentDescriptors": null
+        }
+      }
+    },
+    "pure-js-module": {
+      "name": "pure-js-module",
+      "root": "/path/to/node_modules/pure-js-module",
+      "platforms": {}
+    }
+  }
+}

package/ios/BundleLoader/BundleEvaluator.h

@@ -0,0 +1,16 @@
+//
+//  BundleEvaluator.h
+//  Pods
+//
+//  Created by 오 진성B on 10/8/25.
+//
+
+#import <Foundation/Foundation.h>
+
+@interface BundleEvaluator : NSObject
+
++ (void)evaluate:(NSData *)scriptData
+                   url:(NSString *)url
+           bridgeProxy:(id)bridgeProxy
+            completion:(void (^)(NSError *))completion;
+@end

package/ios/BundleLoader/BundleEvaluator.mm

@@ -0,0 +1,76 @@
+//
+//  BundleEvaluator.mm
+//  Pods
+//
+//  Created by 오 진성B on 10/8/25.
+//
+
+#import "BundleEvaluator.h"
+#import <React/RCTBridgeProxy.h>
+#import <React-callinvoker/ReactCommon/CallInvoker.h>
+#import <jsi/jsi.h>
+
+@interface RCTBridgeProxy (JSIRuntime)
+- (void *)runtime;
+@end
+
+@interface RCTBridgeProxy (RCTTurboModule)
+- (std::shared_ptr<facebook::react::CallInvoker>)jsCallInvoker;
+@end
+
+@implementation BundleEvaluator
+
++ (void)evaluate:(NSData *)scriptData
+                   url:(NSString *)url
+                bridgeProxy:(id)bridgeProxy
+            completion:(void (^)(NSError *))completion {
+
+    // Cast to RCTBridgeProxy
+    RCTBridgeProxy *bridgeProxyObj = (RCTBridgeProxy *)bridgeProxy;
+
+    // Get CallInvoker
+    std::shared_ptr<facebook::react::CallInvoker> callInvoker = bridgeProxyObj.jsCallInvoker;
+    if (!callInvoker) {
+        NSError *error = [NSError errorWithDomain:@"TossBundleLoader"
+                                             code:500
+                                         userInfo:@{NSLocalizedDescriptionKey: @"CallInvoker unavailable"}];
+        completion(error);
+        return;
+    }
+
+    // Get runtime pointer
+    facebook::jsi::Runtime *runtime = (facebook::jsi::Runtime *)bridgeProxyObj.runtime;
+    if (!runtime) {
+        NSError *error = [NSError errorWithDomain:@"TossBundleLoader"
+                                             code:500
+                                         userInfo:@{NSLocalizedDescriptionKey: @"Runtime unavailable"}];
+        completion(error);
+        return;
+    }
+
+    // Prepare source
+    std::string source{static_cast<const char *>([scriptData bytes]), [scriptData length]};
+    std::string sourceUrl{[url UTF8String]};
+
+    // Execute on JS thread
+    callInvoker->invokeAsync([source = std::move(source),
+                             sourceUrl = std::move(sourceUrl),
+                             runtime,
+                             completion]() {
+        try {
+            runtime->evaluateJavaScript(
+                std::make_unique<facebook::jsi::StringBuffer>(std::move(source)),
+                sourceUrl
+            );
+            completion(nil);
+        } catch (const std::exception &e) {
+            NSString *errorString = [NSString stringWithUTF8String:e.what()];
+            NSError *error = [NSError errorWithDomain:@"TossBundleLoader"
+                                                 code:500
+                                             userInfo:@{NSLocalizedDescriptionKey: errorString}];
+            completion(error);
+        }
+    });
+}
+
+@end

package/ios/BundleLoader/BundleLoadable.swift

@@ -0,0 +1,91 @@
+//
+//  BundleLoader.swift
+//  GraniteScreen
+//
+//  Protocol for abstracting bundle loading strategies
+//
+
+import Foundation
+
+// MARK: - BundleLoader Protocol
+
+/// Protocol that abstracts bundle loading strategies
+/// Matches Android's BundleLoader interface for cross-platform consistency
+public protocol BundleLoadable {
+    /// Loads a bundle and returns its source configuration
+    func loadBundle() async throws -> BundleSource
+    static func evaluate(scriptData: Data,
+                                url: String,
+                                bridgeProxy: Any) async throws
+}
+
+// MARK: - BundleSource
+
+/// Represents the source of a JavaScript bundle
+/// Matches Android's sealed class BundleSource
+public enum BundleSource {
+    /// Development server bundle
+    case devServer(host: String = "localhost", port: Int = 8081, moduleName: String, forBundleRoot: String)
+
+    /// Production bundle from various locations
+    case production(location: ProductionLocation, moduleName: String)
+
+    case customPath(URL, moduleName: String)
+}
+
+
+/// Represents the location of a production bundle
+public enum ProductionLocation {
+    /// Bundle from file system
+    case fileSystemBundle(filePath: URL)
+
+    /// Bundle from app's main bundle
+    case embeddedBundle
+}
+
+// MARK: - Bundle Loading Error
+
+/// Errors that can occur during bundle loading
+public enum BundleLoadError: LocalizedError {
+    case networkError(Error)
+    case fileNotFound(String)
+    case invalidURL(String)
+    case downloadFailed(String)
+    case metroServerUnavailable
+    case bundleNotReady
+
+    public var errorDescription: String? {
+        switch self {
+        case .networkError(let error):
+            return "Network error: \(error.localizedDescription)"
+        case .fileNotFound(let path):
+            return "Bundle file not found at: \(path)"
+        case .invalidURL(let url):
+            return "Invalid bundle URL: \(url)"
+        case .downloadFailed(let reason):
+            return "Bundle download failed: \(reason)"
+        case .metroServerUnavailable:
+            return "Metro server is not available"
+        case .bundleNotReady:
+            return "Bundle is not ready for loading"
+        }
+    }
+}
+
+public extension BundleLoadable {
+    public static func evaluate(scriptData: Data,
+                                url: String,
+                                bridgeProxy: Any) async throws {
+        try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+            BundleEvaluator.evaluate(scriptData,
+                                     url: url,
+                                     bridgeProxy: bridgeProxy) { nsError in
+                if let error = nsError {
+                    continuation.resume(throwing: error)
+                } else {
+                    continuation.resume()
+                }
+            }
+        }
+    }
+}

package/ios/GraniteBundleLoaderTypes.swift

@@ -0,0 +1,7 @@
+// This file is automatically generated by brick-codegen
+// Do not edit manually - regenerate using: brick-codegen
+
+import Foundation
+
+/// GraniteBundleLoader module types for Brick framework
+

package/ios/GraniteScreen.h

@@ -0,0 +1,12 @@
+//
+//  GraniteScreen.h
+//  GraniteScreen
+//
+//  Umbrella header for GraniteScreen framework
+//
+
+#import <Foundation/Foundation.h>
+
+// Version information
+FOUNDATION_EXPORT double GraniteScreenVersionNumber;
+FOUNDATION_EXPORT const unsigned char GraniteScreenVersionString[];

package/ios/ReactNativeHosting/DefaultViews.swift

@@ -0,0 +1,138 @@
+//
+//  DefaultViews.swift
+//  GraniteScreen
+//
+//  Default loading and error views for React Native hosting
+//
+
+import UIKit
+
+/// Default loading view shown while React Native is loading
+public class DefaultLoadingView: UIView {
+    private let activityIndicator = UIActivityIndicatorView(style: .large)
+    private let label = UILabel()
+    
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupViews()
+    }
+    
+    public convenience init() {
+        self.init(frame: .zero)
+    }
+    
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupViews()
+    }
+    
+    private func setupViews() {
+        backgroundColor = .systemBackground
+        
+        // Setup activity indicator
+        activityIndicator.translatesAutoresizingMaskIntoConstraints = false
+        activityIndicator.startAnimating()
+        addSubview(activityIndicator)
+        
+        // Setup label
+        label.text = "Loading React Native..."
+        label.textColor = .label
+        label.textAlignment = .center
+        label.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(label)
+        
+        // Layout constraints
+        NSLayoutConstraint.activate([
+            activityIndicator.centerXAnchor.constraint(equalTo: centerXAnchor),
+            activityIndicator.centerYAnchor.constraint(equalTo: centerYAnchor, constant: -20),
+            
+            label.topAnchor.constraint(equalTo: activityIndicator.bottomAnchor, constant: 16),
+            label.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 20),
+            label.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -20)
+        ])
+    }
+}
+
+/// Default error view shown when React Native fails to load
+public class DefaultErrorView: UIView {
+    private let errorImageView = UIImageView()
+    private let titleLabel = UILabel()
+    private let messageLabel = UILabel()
+    private let retryButton = UIButton(type: .system)
+    
+    private let error: Error
+    public var onRetry: (() -> Void)?
+    
+    public init(error: Error) {
+        self.error = error
+        super.init(frame: .zero)
+        setupViews()
+    }
+    
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    private func setupViews() {
+        backgroundColor = .systemBackground
+        
+        // Setup error icon
+        errorImageView.image = UIImage(systemName: "exclamationmark.triangle.fill")
+        errorImageView.tintColor = .systemRed
+        errorImageView.contentMode = .scaleAspectFit
+        errorImageView.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(errorImageView)
+        
+        // Setup title
+        titleLabel.text = "Failed to Load"
+        titleLabel.font = .systemFont(ofSize: 20, weight: .semibold)
+        titleLabel.textColor = .label
+        titleLabel.textAlignment = .center
+        titleLabel.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(titleLabel)
+        
+        // Setup message
+        messageLabel.text = error.localizedDescription
+        messageLabel.font = .systemFont(ofSize: 16)
+        messageLabel.textColor = .secondaryLabel
+        messageLabel.textAlignment = .center
+        messageLabel.numberOfLines = 0
+        messageLabel.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(messageLabel)
+        
+        // Setup retry button
+        retryButton.setTitle("Retry", for: .normal)
+        retryButton.titleLabel?.font = .systemFont(ofSize: 17, weight: .medium)
+        retryButton.backgroundColor = .systemBlue
+        retryButton.setTitleColor(.white, for: .normal)
+        retryButton.layer.cornerRadius = 8
+        retryButton.translatesAutoresizingMaskIntoConstraints = false
+        retryButton.addTarget(self, action: #selector(retryTapped), for: .touchUpInside)
+        addSubview(retryButton)
+        
+        // Layout constraints
+        NSLayoutConstraint.activate([
+            errorImageView.centerXAnchor.constraint(equalTo: centerXAnchor),
+            errorImageView.centerYAnchor.constraint(equalTo: centerYAnchor, constant: -80),
+            errorImageView.widthAnchor.constraint(equalToConstant: 60),
+            errorImageView.heightAnchor.constraint(equalToConstant: 60),
+            
+            titleLabel.topAnchor.constraint(equalTo: errorImageView.bottomAnchor, constant: 20),
+            titleLabel.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 20),
+            titleLabel.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -20),
+            
+            messageLabel.topAnchor.constraint(equalTo: titleLabel.bottomAnchor, constant: 12),
+            messageLabel.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 40),
+            messageLabel.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -40),
+            
+            retryButton.topAnchor.constraint(equalTo: messageLabel.bottomAnchor, constant: 32),
+            retryButton.centerXAnchor.constraint(equalTo: centerXAnchor),
+            retryButton.widthAnchor.constraint(equalToConstant: 120),
+            retryButton.heightAnchor.constraint(equalToConstant: 44)
+        ])
+    }
+    
+    @objc private func retryTapped() {
+        onRetry?()
+    }
+}

package/ios/ReactNativeHosting/GraniteDefaultModuleProvider.h

@@ -0,0 +1,24 @@
+//  GraniteDefaultModuleProvider.h
+//  GraniteScreen
+//
+//  Exposes default module provisioning to Swift
+//
+
+#import <Foundation/Foundation.h>
+#if __has_include(<React-RCTAppDelegate/RCTDependencyProvider.h>)
+#import <React-RCTAppDelegate/RCTDependencyProvider.h>
+#else
+#import <React_RCTAppDelegate/RCTDependencyProvider.h>
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GraniteDefaultModuleProvider : NSObject
+
++ (nullable id)defaultModuleInstanceForClass:(Class)moduleClass
+                          dependencyProvider:(nullable id<RCTDependencyProvider>)dependencyProvider
+    NS_SWIFT_NAME(defaultModuleInstance(for:dependencyProvider:));
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/ReactNativeHosting/GraniteDefaultModuleProvider.mm

@@ -0,0 +1,22 @@
+#import "GraniteDefaultModuleProvider.h"
+
+// Declared in React-RCTAppDelegate but only exposed in ObjC++ headers.
+#ifdef __cplusplus
+extern "C" id RCTAppSetupDefaultModuleFromClass(
+    Class moduleClass,
+    id<RCTDependencyProvider> dependencyProvider);
+#else
+extern id RCTAppSetupDefaultModuleFromClass(
+    Class moduleClass,
+    id<RCTDependencyProvider> dependencyProvider);
+#endif
+
+@implementation GraniteDefaultModuleProvider
+
++ (id)defaultModuleInstanceForClass:(Class)moduleClass
+                 dependencyProvider:(id<RCTDependencyProvider>)dependencyProvider
+{
+  return RCTAppSetupDefaultModuleFromClass(moduleClass, dependencyProvider);
+}
+
+@end

package/ios/ReactNativeHosting/GraniteHostingHelper.swift

@@ -0,0 +1,103 @@
+//
+//  GraniteHostingHelper.swift
+//  GraniteScreen
+//
+//  Helper extension for setting up React Native hosting with GraniteNativeFactory
+//
+
+import React
+import ReactAppDependencyProvider
+import UIKit
+
+struct GraniteHostItem {
+    var hostURL: URL
+    var moduleName: String
+}
+
+public enum GraniteReactHostError: Error {
+    case bundleLoadError
+    case graniteItemConvertError
+    case rnHostViewFactoryError
+    case bundleURLParsingError
+}
+
+private var ReactNativeHostAssociatedKey: UInt8 = 0
+private var ReactNativeDelegateAssociatedKey: UInt8 = 0
+// MARK: - Setup Extension for GraniteReactHost
+/// Extension for classes implementing GraniteReactHost
+/// Provides one-line setup matching Android's pattern
+public extension GraniteReactHost where Self: UIViewController {
+
+ /// Setup React Native host with automatic lifecycle management
+    /// Call this in viewDidLoad() for one-line initialization like Android
+    @MainActor
+    func setupHost(bundleLoader: BundleLoadable,
+                   initialProperties: [AnyHashable: Any],
+                   launchOptions: [AnyHashable: Any]) async {
+        graniteSetupDidStart()
+        do {
+            let bundle = try await bundleLoader.loadBundle()
+            do {
+                let item = try await convertToGraniteItem(bundleSource: bundle)
+                let delegate = ReactNativeFactoryDelegate(url: item.hostURL)
+                delegate.dependencyProvider = RCTAppDependencyProvider()
+                // Use GraniteNativeFactoryWrapper to enable module customization
+                let factory = GraniteNativeFactoryImpl(delegate: delegate)
+                factory.reactHost = self  // self is GraniteReactHost
+                let rnHostView = factory.view(withModuleName: item.moduleName,
+                                              initialProperties: initialProperties,
+                                              launchOptions: launchOptions)
+                // 진성님 돌아오고나면 의견나눠보기 objC 기반으로 메모리 등록해서 사용하는방법
+                objc_setAssociatedObject(self, &ReactNativeHostAssociatedKey, factory, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+                objc_setAssociatedObject(self, &ReactNativeDelegateAssociatedKey, delegate, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+                if let rnHostView {
+                    setGraniteBaseView(graniteBaseView: rnHostView)
+                    graniteSetupDidFinish()
+                } else {
+                    graniteSetupDidError(didFailWith: GraniteReactHostError.rnHostViewFactoryError)
+                }
+            } catch {
+                graniteSetupDidError(didFailWith: GraniteReactHostError.graniteItemConvertError)
+            }
+        } catch {
+            graniteSetupDidError(didFailWith: GraniteReactHostError.bundleLoadError)
+        }
+    }
+
+    private func setGraniteBaseView(graniteBaseView: UIView) {
+        self.graniteBaseView = graniteBaseView
+        view.addSubview(graniteBaseView)
+        graniteBaseView.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            graniteBaseView.topAnchor.constraint(equalTo: view.topAnchor),
+            graniteBaseView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            graniteBaseView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            graniteBaseView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
+        ])
+    }
+
+    private func convertToGraniteItem(bundleSource: BundleSource) async throws -> GraniteHostItem {
+        switch bundleSource {
+        case .devServer(let host, let port, let moduleName, let forBundleRoot):
+            if let url = URL(string: "http://\(host):\(port)/\(forBundleRoot).bundle?platform=ios&dev=true&minify=false") {
+                return .init(hostURL: url, moduleName: moduleName)
+            } else {
+                let url = URL(string: "http://\(host):\(port)/\(forBundleRoot).bundle?platform=ios&dev=true&minify=false")
+                return .init(hostURL: url!, moduleName: moduleName)
+            }
+        case .production(let location, let moduleName):
+            switch location {
+            case .fileSystemBundle(let filePath):
+                return .init(hostURL: filePath, moduleName: moduleName)
+            case .embeddedBundle:
+                if let url = Bundle.main.url(forResource: "main", withExtension: "jsbundle") {
+                    return .init(hostURL: url, moduleName: moduleName)
+                } else {
+                    throw GraniteReactHostError.bundleURLParsingError
+                }
+            }
+        case .customPath(let url, let moduleName):
+            return .init(hostURL: url, moduleName: moduleName)
+        }
+    }
+}

package/ios/ReactNativeHosting/GraniteNativeFactory.swift

@@ -0,0 +1,35 @@
+//
+//  GraniteNativeFactory.swift
+//  GraniteScreen
+//
+//  Swift implementation of GraniteNativeFactory
+//
+
+import Foundation
+import ObjectiveC
+import React_RCTAppDelegate
+import UIKit
+
+@objcMembers
+open class GraniteNativeFactory: RCTReactNativeFactory {
+
+    open func view(
+        withModuleName moduleName: String,
+        initialProperties initProps: [AnyHashable: Any]?,
+        launchOptions: [AnyHashable: Any]?
+    ) -> UIView? {
+        return self.rootViewFactory.view(
+            withModuleName: moduleName,
+            initialProperties: initProps,
+            launchOptions: launchOptions
+        )
+    }
+
+    @objc(getModuleInstanceFromClass:)
+    open func getModuleInstance(from moduleClass: AnyClass) -> Any? {
+        return GraniteDefaultModuleProvider.defaultModuleInstance(
+            for: moduleClass,
+            dependencyProvider: delegate?.dependencyProvider
+        )
+    }
+}