### Cross-Platform XCTest Example with SkipFuse Source: https://context7.com/skiptools/skip-fuse/llms.txt Demonstrates writing cross-platform tests using XCTest, importing SkipFuse, Foundation, and OSLog. The logger works on both Apple and Android targets. ```swift import OSLog import Foundation import SkipFuse import XCTest final class MyFeatureTests: XCTestCase { let logger = Logger(subsystem: "com.example.tests", category: "MyFeature") func testObservablePropertyChange() { let model = CounterViewModel() XCTAssertEqual(model.count, 0) model.increment() XCTAssertEqual(model.count, 1) model.reset() XCTAssertEqual(model.count, 0) logger.info("testObservablePropertyChange passed") } func testLoggingDoesNotThrow() { // Logger works on both Apple and Android via SkipFuse XCTAssertNoThrow { logger.debug("debug message") logger.info("info message") logger.error("error message") } } } ``` -------------------------------- ### Swift @Observable + Jetpack Compose Integration Source: https://context7.com/skiptools/skip-fuse/llms.txt Integrate Swift's @Observable macro with Jetpack Compose for automatic UI recomposition. This requires no manual state management setup like StateFlow or LiveData. ```swift import SkipFuse import Observation // Re-exported via SkipFuse on both platforms // Define a shared view model using Swift's @Observable macro @Observable class CounterViewModel { var count: Int = 0 var title: String = "My Counter" func increment() { count += 1 Logger(subsystem: "com.example", category: "counter") .debug("Count incremented to \(count)") } func reset() { count = 0 } } // On Apple platforms: works with SwiftUI's @State / @Environment observation // On Android via Skip: transparently drives Jetpack Compose recomposition // -- Compose picks up property changes on `count` and `title` automatically struct CounterView: View { @State var model = CounterViewModel() var body: some View { VStack { Text(model.title) Text("Count: \(model.count)") Button("Increment") { model.increment() } Button("Reset") { model.reset() } } } } ``` -------------------------------- ### Invoke Kotlin Utility Class with AnyDynamicObject Source: https://context7.com/skiptools/skip-fuse/llms.txt Dynamically construct and use Java NumberFormat for currency formatting from Swift. Uses `AnyDynamicObject.fromClass` to instantiate Java classes. ```swift // Example: invoking a Kotlin utility class with no pre-generated Swift bindings func formatCurrency(amount: Double, locale: AnyDynamicObject) throws -> String { // Dynamically construct a Java NumberFormat instance let numberFormat = try AnyDynamicObject.fromClass("java.text.NumberFormat") .getCurrencyInstance(locale) return try numberFormat.format(amount) as String } ``` -------------------------------- ### Call Android PackageManager from Swift using AnyDynamicObject Source: https://context7.com/skiptools/skip-fuse/llms.txt Dynamically access Android's PackageManager and PackageInfo to retrieve app version names. Requires `SkipFuse` and `AnyDynamicObject`. ```swift import SkipFuse // Example: calling Android's PackageManager from Swift using AnyDynamicObject func getAppVersionName(context: AnyDynamicObject) throws -> String { // Dynamically access context.packageManager (returns AnyDynamicObject) let packageManager = try context.packageManager // Call getPackageInfo(packageName, flags) on the Java PackageManager object let packageName = try context.packageName as String let packageInfo = try packageManager.getPackageInfo(packageName, 0) // Access the versionName field of the PackageInfo result let versionName = try packageInfo.versionName as String return versionName } ``` -------------------------------- ### Add SkipFuse Dependency to Package.swift Source: https://github.com/skiptools/skip-fuse/blob/main/README.md Include the SkipFuse framework in your Swift Package Manager project by adding its Git URL and specifying the product dependency. ```swift let package = Package( name: "my-package", products: [ .library(name: "MyProduct", targets: ["MyTarget"]) ], dependencies: [ .package(url: "https://source.skip.dev/skip-fuse.git", from: "1.0.0") ], targets: [ .target(name: "MyTarget", dependencies: [ .product(name: "SkipFuse", package: "skip-fuse") ]) ] ) ``` -------------------------------- ### Cross-Platform OSLog Logging with SkipFuse Source: https://context7.com/skiptools/skip-fuse/llms.txt Utilize the OSLog APIs for logging on both Apple platforms and Android. SkipFuse routes logger messages to Android's Logcat, allowing for unified logging code. ```swift import SkipFuse import OSLog // Available on both platforms via SkipFuse's re-export // Create a logger with a subsystem and category (identical on iOS and Android) let logger = Logger(subsystem: "com.example.myapp", category: "networking") func fetchUser(id: String) async throws -> User { logger.debug("Fetching user with id: \(id)") do { let user = try await APIClient.shared.getUser(id: id) logger.info("Successfully fetched user: \(user.name)") return user } catch { logger.error("Failed to fetch user \(id): \(error.localizedDescription)") throw error } } // On Apple platforms: messages appear in the unified logging system / Console.app // On Android: messages appear in Logcat under the configured subsystem tag ``` -------------------------------- ### Add SkipFuse as Swift Package Dependency Source: https://context7.com/skiptools/skip-fuse/llms.txt Declare the skip-fuse package in your Package.swift file and add it as a dependency to your target. This makes all re-exported symbols available without additional imports. ```swift // Package.swift import PackageDescription let package = Package( name: "my-cross-platform-app", platforms: [ .iOS(.v16), .macOS(.v13), .tvOS(.v16), .watchOS(.v9), .macCatalyst(.v16), ], products: [ .library(name: "MyApp", targets: ["MyApp"]) ], dependencies: [ .package(url: "https://source.skip.dev/skip-fuse.git", from: "1.0.0") ], targets: [ .target( name: "MyApp", dependencies: [ .product(name: "SkipFuse", package: "skip-fuse") ] ), .testTarget( name: "MyAppTests", dependencies: ["MyApp"] ) ] ) ``` -------------------------------- ### Platform-Conditional Module Re-Exports in SkipFuse Source: https://context7.com/skiptools/skip-fuse/llms.txt Internal mechanism of SkipFuse demonstrating how `@_exported import` with `canImport` guards makes platform-specific modules available. Application code simply imports `SkipFuse`. ```swift // This is the internal mechanism inside SkipFuse.swift — shown for reference. // Application code simply `import SkipFuse` and gets all of these automatically: #if canImport(Android) @_exported import Android // Core Android platform APIs on Android targets #elseif canImport(Darwin) @_exported import Darwin // Darwin/POSIX layer on Apple targets #endif #if canImport(AndroidNative) @_exported import AndroidNative // Native Android integration APIs #elseif canImport(OSLog) @_exported import OSLog // Apple unified logging framework #endif @_exported import SkipBridge // Core Skip bridging infrastructure @_exported import SkipAndroidBridge // Android-specific bridge (AnyDynamicObject, Compose hooks) // ── Application code ────────────────────────────────────────────────────────── // No platform guards needed. Just: import SkipFuse let logger = Logger(subsystem: "com.example", category: "general") // Works everywhere ``` === COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.