Add AndroidContext and dependency on swift-jni (#2)

* Add AndroidContext and dependency on swift-jni

* Update AndroidContext

* Add docs and example of using an ANativeActivity

* Fix conditional import

* Add AndroidContext.assetManager accessor for AndroidAssetManager

* Switch CI to Linux

* Switch CI to Linux

* Fix OSLog import for Linux

* Fix OSLog import for Linux

* Update CI

* Import fixes

* Import fixes

* Package fixes

Author: marcprux

.github/workflows/ci.yml

@@ -9,17 +9,23 @@ on:
   schedule:
     - cron:  '45 2,13 * * *'
 jobs:
-  test:
-    # emulator fails to launch with: HVF error: HV_UNSUPPORTED
-    #runs-on: macos-15
-    runs-on: macos-13
-    timeout-minutes: 120
+  linux-android:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
       - name: "Test Swift Package Locally"
         run: swift test
       - name: "Test Swift Package on Android"
         uses: skiptools/swift-android-action@v2
+
+  macos-ios:
+    runs-on: macos-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Test Swift Package Locally"
+        run: swift test
       - name: "Test Swift Package on iOS"
         run: xcodebuild test -sdk "iphonesimulator" -destination "platform=iOS Simulator,name=iPhone 15" -scheme "$(xcodebuild -list -json | jq -r '.workspace.schemes[-1]')"
 

Package.swift

@@ -5,12 +5,14 @@ let package = Package(
     name: "swift-android-native",
     products: [
         .library(name: "AndroidNative", targets: ["AndroidNative"]),
+        .library(name: "AndroidContext", targets: ["AndroidContext"]),
         .library(name: "AndroidAssetManager", targets: ["AndroidAssetManager"]),
         .library(name: "AndroidLogging", targets: ["AndroidLogging"]),
         .library(name: "AndroidLooper", targets: ["AndroidLooper"]),
         .library(name: "AndroidChoreographer", targets: ["AndroidLooper"]),
     ],
     dependencies: [
+        .package(url: "https://source.skip.tools/swift-jni.git", "0.0.0"..<"2.0.0"),
     ],
     targets: [
         .target(name: "AndroidNDK", linkerSettings: [
@@ -28,6 +30,7 @@ let package = Package(
             "AndroidSystem",
         ]),
         .target(name: "AndroidAssetManager", dependencies: [
+            .product(name: "SwiftJNI", package: "swift-jni"),
             .target(name: "AndroidNDK", condition: .when(platforms: [.android])),
         ]),
         .testTarget(name: "AndroidAssetManagerTests", dependencies: [
@@ -39,6 +42,13 @@ let package = Package(
         .testTarget(name: "AndroidLoggingTests", dependencies: [
             "AndroidLogging",
         ]),
+        .target(name: "AndroidContext", dependencies: [
+            "AndroidAssetManager",
+            .target(name: "AndroidNDK", condition: .when(platforms: [.android])),
+        ]),
+        .testTarget(name: "AndroidContextTests", dependencies: [
+            "AndroidContext",
+        ]),
         .target(name: "AndroidLooper", dependencies: [
             "AndroidSystem",
             "AndroidLogging",
@@ -55,7 +65,7 @@ let package = Package(
             "AndroidChoreographer",
         ]),
         .target(name: "AndroidNative", dependencies: [
-            "AndroidAssetManager",
+            "AndroidContext",
             "AndroidLogging",
             "AndroidLooper",
             "AndroidChoreographer",

README.md

@@ -86,6 +86,62 @@ function.
 - `OSLogMessage` is simply a typealias to `Swift.String`, and does not implement any of the [redaction features](https://developer.apple.com/documentation/os/logging/generating_log_messages_from_your_code#3665948) of the Darwin version.
 
 
+# AndroidContext
+
+This module provides a minimal wrapper for [android.content.Context](https://developer.android.com/reference/android/content/Context)
+that uses [SwiftJNI](https://github.com/skiptools/swift-jni) to bridge into the global application context.
+
+## Installation
+
+Add the `AndroidContext` module as a conditional dependency for any targets that need it:
+
+```swift
+.target(name: "MyTarget", dependencies: [
+    .product(name: "AndroidContext", package: "swift-android-native", condition: .when(platforms: [.android]))
+])
+```
+
+## Usage
+
+```swift
+let context = try AndroidContext.application
+let packageName = try context.getPackageName()
+```
+
+## Internals
+
+### Implementation details
+
+By default, the `AndroidContext.application` accessor will try to invoke the JNI method
+`android.app.ActivityThread.currentApplication()Landroid/app/Application;` to obtain the
+global application context. This can be overridden at app initialization time by setting
+the `SWIFT_ANDROID_CONTEXT_FACTORY` environment to a different static accessor, such as:
+
+```swift
+// another way to access the global context (deprecated)
+setenv("SWIFT_ANDROID_CONTEXT_FACTORY", "android.app.AppGlobals.getInitialApplication()Landroid/app/Application;", 1)
+
+let context = try AndroidContext.application
+```
+
+Such setup must be performed before the first time the `AndroidContext.application`
+accessor is called, as the result will be cached the first time it is invoked.
+
+Alternatively, if the application bootstrapping code already has access to a
+JNI context and `jobject` reference to the application context, it can be
+set directly in the static `contextPointer` field. For example,
+if your application uses an NDK [ANativeActivity](https://developer.android.com/ndk/reference/struct/a-native-activity)
+activity, then the context can be accessed from its reference to the underlying
+[android.app.NativeActivity](https://developer.android.com/reference/android/app/NativeActivity)
+instance:
+
+```swift
+let nativeActivity: ANativeActivity = …
+AndroidContext.contextPointer = nativeActivity.clazz
+let context = try AndroidContext.application // returns the wrapper around the application context
+```
+
+
 # AndroidAssetManager
 
 This module provides an [AssetManager](https://developer.android.com/ndk/reference/group/asset) API for native Swift on Android.

Sources/AndroidAssetManager/AndroidAssetManager.swift

@@ -2,20 +2,33 @@
 #if os(Android)
 import Android
 import AndroidNDK
+#endif
+import SwiftJNI
 import Foundation
 
 /// https://developer.android.com/ndk/reference/group/asset
+//@available(macOS, unavailable)
+@available(iOS, unavailable)
+@available(tvOS, unavailable)
+@available(watchOS, unavailable)
 public final class AndroidAssetManager : @unchecked Sendable {
     let assetManager: OpaquePointer // AAssetManager
     typealias AssetHandle = OpaquePointer
 
     /// Create the asset manager from the given JNI environment with a jobject pointer to the Java AssetManager.
-    public init(env: UnsafeMutablePointer<JNIEnv?>, peer: jobject) {
+    public init(env: UnsafeMutablePointer<JNIEnv?>, peer: JavaObjectPointer) {
+        #if !os(Android)
+        fatalError("only implemented for Android")
+        #else
         self.assetManager = AAssetManager_fromJava(env, peer)
+        #endif
     }
 
     /// List the file names for each asset in the specific directory
     public func listAssets(inDirectory directory: String) -> [String]? {
+        #if !os(Android)
+        fatalError("only implemented for Android")
+        #else
         guard let assetDir = AAssetManager_openDir(assetManager, directory) else { return nil }
         defer { AAssetDir_close(assetDir) }
 
@@ -24,14 +37,19 @@ public final class AndroidAssetManager : @unchecked Sendable {
             assets.append(String(cString: assetName))
         }
         return assets
+        #endif
     }
 
     /// Opens the asset at the given path with the specified mode, returning nil if the asset was not found.
     public func open(from path: String, mode: AssetMode) -> Asset? {
+        #if !os(Android)
+        fatalError("only implemented for Android")
+        #else
         guard let handle = AAssetManager_open(self.assetManager, path, mode.assetMode) else {
             return nil
         }
         return Asset(handle: handle)
+        #endif
     }
 
     /// Attempt to read the entire contents from the asset with the given name.
@@ -56,25 +74,41 @@ public final class AndroidAssetManager : @unchecked Sendable {
         public func close() {
             if closed { return }
             closed = true
+            #if !os(Android)
+            fatalError("only implemented for Android")
+            #else
             AAsset_close(handle)
+            #endif
         }
 
         /// Returns the total size of the asset data
         public var length: Int64 {
             assert(!closed, "asset is closed")
+            #if !os(Android)
+            fatalError("only implemented for Android")
+            #else
             return AAsset_getLength64(handle)
+            #endif
         }
 
         /// Report the total amount of asset data that can be read from the current position
         public var remainingLength: Int64 {
             assert(!closed, "asset is closed")
+            #if !os(Android)
+            fatalError("only implemented for Android")
+            #else
             return AAsset_getRemainingLength64(handle)
+            #endif
         }
 
         /// Returns whether this asset's internal buffer is allocated in ordinary RAM (i.e. not mmapped).
         public var isAllocated: Bool {
             assert(!closed, "asset is closed")
+            #if !os(Android)
+            fatalError("only implemented for Android")
+            #else
             return AAsset_isAllocated(handle) != 0
+            #endif
         }
 
         /// Attempt to read 'count' bytes of data from the current offset.
@@ -86,7 +120,11 @@ public final class AndroidAssetManager : @unchecked Sendable {
             var data = Data(count: len)
 
             let bytesRead: Int32 = try data.withUnsafeMutableBytes { buffer in
+                #if !os(Android)
+                fatalError("only implemented for Android")
+                #else
                 AAsset_read(handle, buffer, len)
+                #endif
             }
 
             if bytesRead < 0 {
@@ -104,17 +142,25 @@ public final class AndroidAssetManager : @unchecked Sendable {
         /// Seek to the specified offset within the asset data.
         public func seek(offset: Int64, whence: AssetSeek) -> Int64 {
             assert(!closed, "asset is closed")
+            #if !os(Android)
+            fatalError("only implemented for Android")
+            #else
             return AAsset_seek64(handle, offset, whence.seekMode)
+            #endif
         }
 
         /// Open a new file descriptor that can be used to read the asset data.
         ///
         /// Returns nil if direct fd access is not possible (for example, if the asset is compressed).
         public func openFileDescriptor(offset: inout Int64, outLength: inout Int64) -> Int32? {
             assert(!closed, "asset is closed")
+            #if !os(Android)
+            fatalError("only implemented for Android")
+            #else
             let fd = AAsset_openFileDescriptor64(handle, &offset, &outLength)
             if fd < 0 { return nil }
             return fd
+            #endif
         }
     }
 
@@ -125,6 +171,9 @@ public final class AndroidAssetManager : @unchecked Sendable {
         case random
 
         var assetMode: Int32 {
+            #if !os(Android)
+            fatalError("only implemented for Android")
+            #else
             switch self {
             case .buffer:
                 return Int32(AASSET_MODE_BUFFER)
@@ -133,6 +182,7 @@ public final class AndroidAssetManager : @unchecked Sendable {
             case .random:
                 return Int32(AASSET_MODE_RANDOM)
             }
+            #endif
         }
     }
 
@@ -149,15 +199,17 @@ public final class AndroidAssetManager : @unchecked Sendable {
         case data
 
         var seekMode: Int32 {
+            #if !os(Android)
+            fatalError("only implemented for Android")
+            #else
             switch self {
             case .set: return Int32(SEEK_SET)
             case .cur: return Int32(SEEK_CUR)
             case .end: return Int32(SEEK_END)
             case .hole: return Int32(SEEK_HOLE)
             case .data: return Int32(SEEK_DATA)
             }
+            #endif
         }
     }
 }
-
-#endif

Sources/AndroidChoreographer/AndroidChoreographer.swift

@@ -2,12 +2,17 @@
 #if os(Android)
 import Android
 import AndroidNDK
+#endif
 import AndroidLogging
 import CoreFoundation
 
-let logger = Logger(subsystem: "swift.android.native", category: "AndroidChoreographer")
+//let logger = Logger(subsystem: "swift.android.native", category: "AndroidChoreographer")
 
 /// https://developer.android.com/ndk/reference/group/choreographer
+@available(macOS, unavailable)
+@available(iOS, unavailable)
+@available(tvOS, unavailable)
+@available(watchOS, unavailable)
 public final class AndroidChoreographer : @unchecked Sendable {
     private let _choreographer: OpaquePointer
 
@@ -20,7 +25,11 @@ public final class AndroidChoreographer : @unchecked Sendable {
     ///
     /// This must be called on an ALooper thread.
     public static var current: AndroidChoreographer {
+        #if !os(Android)
+        fatalError("only implemented for Android")
+        #else
         AndroidChoreographer(choreographer: AChoreographer_getInstance())
+        #endif
     }
 
     init(choreographer: OpaquePointer) {
@@ -30,38 +39,17 @@ public final class AndroidChoreographer : @unchecked Sendable {
     /// Add a callback to the Choreographer to  invoke `_dispatch_main_queue_callback_4CF` on each frame to drain the main queue
     public static func setupMainChoreographer() {
         if Self.main == nil {
-            logger.info("setupMainQueue")
+            //logger.info("setupMainQueue")
             Self.main = AndroidChoreographer.current
             //enqueueMainChoreographer()
         }
     }
 
     public func postFrameCallback(_ callback: @convention(c)(Int, UnsafeMutableRawPointer?) -> ()) {
+        #if !os(Android)
+        fatalError("only implemented for Android")
+        #else
         AChoreographer_postFrameCallback(_choreographer, callback, nil)
+        #endif
     }
 }
-
-// no longer used: we use the AndroidLooper instead, which will be more efficient than trying to drain the main queue on every frame render
-
-//private func enqueueMainChoreographer() {
-//    AndroidChoreographer.current.postFrameCallback(choreographerCallback)
-//}
-//
-//// C-compatible callback wrapper
-//private var choreographerCallback: AChoreographer_frameCallback64 = { _, _ in
-//    // Drain the main queue
-//    //_dispatch_main_queue_callback_4CF()
-//    while CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.0, true) == CFRunLoopRunResult.handledSource {
-//        // continue handling queued events without a timeout
-//    }
-//
-//    // AChoreographer_postFrameCallback64 is single-shot, so we need to re-enqueue the callback each frame
-//    enqueueMainChoreographer()
-//}
-
-//// https://github.com/apple-oss-distributions/libdispatch/blob/bd82a60ee6a73b4eca50af028b48643d51aaf1ea/src/queue.c#L8237
-//// https://forums.swift.org/t/main-dispatch-queue-in-linux-sdl-app/31708/3
-//@_silgen_name("_dispatch_main_queue_callback_4CF")
-//func _dispatch_main_queue_callback_4CF()
-
-#endif