Allow multiple AVPlayer instances, use TextureView instead of SurfaceView

Package.swift

@@ -1,14 +1,14 @@
-// swift-tools-version:5.7
+// swift-tools-version:6.0
 import PackageDescription
 
 let package = Package(
     name: "UIKit",
-    platforms: [.macOS(.v10_15)],
+    platforms: [.macOS(.v13)],
     products: [
         .library(name: "UIKit", targets: ["UIKit"])
     ],
     dependencies: [
-        .package(path: "./swift-jni"),
+        .package(url: "https://github.com/SwiftAndroid/swift-jni", branch: "devel"),
         .package(path: "./SDL"),
     ],
     targets: [
@@ -23,5 +23,6 @@ let package = Package(
             exclude: ["Mac-Info.plist"]
         ),
         .target(name: "UIKit_C_API", path: "UIKit_C_API"),
-    ]
+    ],
+    swiftLanguageModes: [.v5]
 )

Sources/AVPlayer+Android.swift

@@ -1,15 +1,7 @@
 #if os(Android)
-//
-//  JNIVideo.swift
-//  UIKit
-//
-//  Created by Chris on 13.09.17.
-//  Copyright © 2017 flowkey. All rights reserved.
-//
-
 import JNI
 
-public class AVPlayer: JNIObject {
+public final class AVPlayer: JNIObject {
     public override static var className: String { "org.uikit.AVPlayer" }
 
     public var onError: ((ExoPlaybackError) -> Void)?

Sources/AVPlayerLayer+Android.swift

@@ -1,12 +1,4 @@
 #if os(Android)
-//
-//  JNIVideo.swift
-//  UIKit
-//
-//  Created by Chris on 13.09.17.
-//  Copyright © 2017 flowkey. All rights reserved.
-//
-
 import JNI
 
 public enum AVLayerVideoGravity: JavaInt {
@@ -16,32 +8,91 @@ public enum AVLayerVideoGravity: JavaInt {
 }
 
 @MainActor
-public class AVPlayerLayer: JNIObject {
+final public class AVPlayerLayer: CALayer {
+    public var kotlinAVPlayerLayer: KotlinAVPlayerLayer?
+
+    public convenience init(player: AVPlayer) {
+        self.init()
+        kotlinAVPlayerLayer = KotlinAVPlayerLayer(player: player)
+    }
+
+    public var videoGravity: AVLayerVideoGravity = .resizeAspect {
+        didSet { kotlinAVPlayerLayer?.setVideoGravity(videoGravity) }
+    }
+
+    override public var opacity: Float {
+        didSet { kotlinAVPlayerLayer?.setAlpha(opacity) }
+    }
+
+    override public var isHidden: Bool {
+        didSet { kotlinAVPlayerLayer?.setIsHidden(isHidden) }
+    }
+
+    override public func copy() -> AVPlayerLayer {
+        let copy = super.copy()
+        // Allow the presentation layer's frame to be animated:
+        copy.kotlinAVPlayerLayer = kotlinAVPlayerLayer
+        return copy
+    }
+
+    override public var cornerRadius: CGFloat {
+        didSet { kotlinAVPlayerLayer?.setCornerRadius(Float(cornerRadius)) }
+    }
+
+    override public var zPosition: CGFloat {
+        didSet { kotlinAVPlayerLayer?.setElevation(zPosition) }
+    }
+
+    // [Frame Animations]
+    // `frame` is a computed property, so `position` and `bounds` are what actually gets animated
+    override public var bounds: CGRect {
+        didSet { kotlinAVPlayerLayer?.setFrame(frame) }
+    }
+
+    override public var position: CGPoint {
+        didSet { kotlinAVPlayerLayer?.setFrame(frame) }
+    }
+    // [/Frame Animations]
+}
+
+@MainActor
+public final class KotlinAVPlayerLayer: JNIObject {
     override public static var className: String { "org.uikit.AVPlayerLayer" }
 
     public convenience init(player: AVPlayer) {
         let parentView = JavaSDLView(getSDLView())
         try! self.init(arguments: parentView, player)
     }
 
-    public var videoGravity: AVLayerVideoGravity = .resizeAspect {
-        didSet {
-            try! call("setResizeMode", arguments: [videoGravity.rawValue])
-        }
+    public func setVideoGravity(_ newValue: AVLayerVideoGravity) {
+        // Not implemented because we no longer user ExoPlayer's PlayerView
     }
 
-    public var frame: CGRect {
-        get { return .zero } // FIXME: This would require returning a JavaObject with the various params
-        set {
-            guard let scale = UIScreen.main?.scale else { return }
-            let scaledFrame = (newValue * scale)
-            try! call("setFrame", arguments: [
-                JavaInt(scaledFrame.origin.x.rounded()),
-                JavaInt(scaledFrame.origin.y.rounded()),
-                JavaInt(scaledFrame.size.width.rounded()),
-                JavaInt(scaledFrame.size.height.rounded())
-            ])
-        }
+    public func setAlpha(_ newValue: Float) {
+        try! call("setAlpha", arguments: [newValue])
+    }
+
+    public func setFrame(_ newValue: CGRect) {
+        guard let scale = UIScreen.main?.scale else { return }
+        let scaledFrame = newValue * scale
+        try! call("setFrame", arguments: [
+            JavaInt(scaledFrame.origin.x.rounded()),
+            JavaInt(scaledFrame.origin.y.rounded()),
+            JavaInt(scaledFrame.size.width.rounded()),
+            JavaInt(scaledFrame.size.height.rounded())
+        ])
+    }
+
+    public func setCornerRadius(_ newValue: Float) {
+        try! call("setCornerRadius", arguments: [newValue])
+    }
+
+    public func setIsHidden(_ newValue: Bool) {
+        try! call("setIsHidden", arguments: [newValue])
+    }
+
+    public func setElevation(_ newValue: Double) {
+        try! call("setElevation", arguments: [Float(newValue)])
     }
 
     deinit {

Sources/AVPlayerLayer+Mac.swift

@@ -69,13 +69,12 @@ public final class AVPlayerLayer: CALayer {
         player?.currentItem?.remove(playerOutput)
 
         let aspectRatio = presentationSize.width / presentationSize.height
-        
-        let width = round(size.width)
+
+        let width = (size.width * self.contentsScale).rounded()
         let widthAlignedTo4PixelPadding = (width.remainder(dividingBy: 8) == 0) ?
             width : // <-- no padding required
-            width + (8 - width.remainder(dividingBy: 8))
+            width + (8 - width.remainder(dividingBy: 8).magnitude)
 
-
         playerOutput = AVPlayerItemVideoOutput(pixelBufferAttributes: [
             kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
             kCVPixelBufferOpenGLCompatibilityKey as String: true,
@@ -89,6 +88,7 @@ public final class AVPlayerLayer: CALayer {
         currentPlayerOutputSize = size
     }
 
+    @_optimize(speed)
     func updateVideoFrame() {
         updatePlayerOutput(size: frame.size)
         guard
@@ -124,4 +124,4 @@ public final class AVPlayerLayer: CALayer {
         contents?.replacePixels(with: pixelBytes, bytesPerPixel: 4)
     }
 }
-#endif
+#endif // os(macOS)

Sources/AVURLAsset+Android.swift

@@ -1,12 +1,4 @@
 #if os(Android)
-//
-//  AVPlayerItem+Android.swift
-//  UIKit
-//
-//  Created by Geordie Jay on 24.05.17.
-//  Copyright © 2017 flowkey. All rights reserved.
-//
-
 import JNI
 
 public class AVPlayerItem {
@@ -16,7 +8,7 @@ public class AVPlayerItem {
     }
 }
 
-public class AVURLAsset: JNIObject {
+public final class AVURLAsset: JNIObject {
     public override static var className: String { "org.uikit.AVURLAsset" }
 
     @MainActor

Sources/CALayer+SDL.swift

@@ -59,7 +59,7 @@ extension CALayer {
         // If a mask exists, take it into account when rendering by combining absoluteFrame with the mask's frame
         if let mask = mask {
             // XXX: we're probably not doing exactly what iOS does if there is a transform on here somewhere
-            let maskFrame = (mask._presentation ?? mask).frame
+            let maskFrame = (mask.presentation() ?? mask).frame
             let maskAbsoluteFrame = maskFrame.offsetBy(absoluteFrame.origin)
 
             // Don't intersect with previousClippingRect: in a case where both `masksToBounds` and `mask` are
@@ -143,7 +143,7 @@ extension CALayer {
             transformAtSelfOrigin.setAsSDLgpuMatrix()
 
             for sublayer in sublayers {
-                (sublayer._presentation ?? sublayer).sdlRender(parentAbsoluteOpacity: opacity)
+                (sublayer.presentation() ?? sublayer).sdlRender(parentAbsoluteOpacity: opacity)
             }
         }
 

Sources/CALayer+animations.swift

@@ -13,7 +13,7 @@ extension CALayer {
 
         // animation.fromValue is optional, set it to currently visible state if nil
         if copy.fromValue == nil, let keyPath = copy.keyPath {
-            copy.fromValue = (_presentation ?? self).value(forKeyPath: keyPath)
+            copy.fromValue = (presentation() ?? self).value(forKeyPath: keyPath)
         }
 
         copy.animationGroup?.queuedAnimations += 1

Sources/CALayer.swift

@@ -182,7 +182,10 @@ open class CALayer {
     public required init() {}
 
     public required init(layer: Any) {
-        guard let layer = layer as? CALayer else { fatalError() }
+        guard let layer = layer as? CALayer else {
+            fatalError("Copy of CALayer must be initialized from another CALayer")
+        }
+
         bounds = layer.bounds
         delegate = layer.delegate
         transform = layer.transform
@@ -208,8 +211,8 @@ open class CALayer {
         contentsGravity = layer.contentsGravity
     }
 
-    open func copy() -> Any {
-        return CALayer(layer: self)
+    open func copy() -> Self {
+        return Self(layer: self)
     }
 
     open func action(forKey event: String) -> CAAction? {
@@ -221,7 +224,11 @@ open class CALayer {
 
     /// returns a non animating copy of the layer
     func createPresentation() -> CALayer {
-        let copy = CALayer(layer: self)
+        // XXX: Should we just return _presentation if it already exists??
+        // This seems to break animations, but why?
+        // if let _presentation { return _presentation }
+
+        let copy = self.copy()
         copy.isPresentationForAnotherLayer = true
         return copy
     }
@@ -235,6 +242,14 @@ open class CALayer {
         didSet { onDidSetAnimations(wasEmpty: oldValue.isEmpty) }
     }
 
+    open func animationKeys() -> [String]? {
+        return animations.keys.isEmpty ? nil : animations.keys.map { $0 }
+    }
+
+    open func animation(forKey key: String) -> CABasicAnimation? {
+        return animations[key]
+    }
+
     /// We disable animation on parameters of views / layers that haven't been rendered yet.
     /// This is both a performance optimization (avoids lots of animations at the start)
     /// as well as a correctness fix (matches iOS behaviour). Maybe there's a better way though?

Sources/CGImage.swift

@@ -43,12 +43,34 @@ public class CGImage {
         var data = sourceData
 
         guard let gpuImagePtr = data.withUnsafeMutableBytes({ buffer -> UnsafeMutablePointer<GPU_Image>? in
-            guard let ptr = buffer.baseAddress?.assumingMemoryBound(to: Int8.self) else {
-                return nil
+            var width: Int32 = 0
+            var height: Int32 = 0
+            var channels: Int32 = 4
+
+            #if os(Android)
+            // Android natively supports 2-channel textures. Use them to save 50% (GPU) RAM.
+            let data = stbi_load_from_memory(buffer.baseAddress, Int32(buffer.count), &width, &height, &channels, 0)
+
+            let format: GPU_FormatEnum = switch channels {
+            case 1: GPU_FORMAT_ALPHA
+            case 2: GPU_FORMAT_LUMINANCE_ALPHA
+            case 3: GPU_FORMAT_RGB
+            case 4: GPU_FORMAT_RGBA
+            default: fatalError()
             }
-
-            let rw = SDL_RWFromMem(ptr, Int32(buffer.count))
-            return GPU_LoadImage_RW(rw, true)
+            #elseif os(macOS)
+            // OpenGL on macOS does not natively support 2-channel textures (`unit 0 GLD_TEXTURE_INDEX_2D is unloadable`).
+            // Instead, force `stb_image` to load all images as if they had 4 channels.
+            // This is more compatible, but requires more memory.
+            let data = stbi_load_from_memory(buffer.baseAddress, Int32(buffer.count), &width, &height, nil, channels)
+            let format = GPU_FORMAT_RGBA
+            #endif
+
+            let img = GPU_CreateImage(UInt16(width), UInt16(height), format)
+            GPU_UpdateImageBytes(img, nil, data, width * channels)
+            data?.deallocate()
+
+            return img
         }) else { return nil }
 
         self.init(gpuImagePtr, sourceData: data)

Sources/UIApplicationDelegate.swift

@@ -29,18 +29,13 @@ public extension UIApplicationDelegate {
     func applicationWillResignActive(_ application: UIApplication) {}
     func applicationDidEnterBackground(_ application: UIApplication) {}
 
-    // Note: this is not used on Android, because there we have a library, so no `main` function will be called.
     @MainActor
     static func main() async throws {
-        #if os(macOS)
-        // On Mac (like on iOS), the main thread blocks here via RunLoop.current.run().
-        defer { setupRenderAndRunLoop() }
-        #else
-        // Android is handled differently: we don't want to block the main thread because the system needs it.
-        // Instead, we call render periodically from Kotlin via the Android Choreographer API (see UIApplication).
-        // That said, this function won't even be called on platforms like Android where the app is built as a library, not an executable.
-        #endif
-
+        #if !os(Android) // Unused on Android: we build a library, so no `main` function gets called.
         _ = UIApplicationMain(UIApplication.self, Self.self)
+
+        // On Mac (like on iOS), the main thread blocks here via RunLoop.current.run().
+        setupRenderAndRunLoop()
+        #endif // !os(Android)
     }
 }

Sources/UIScrollView.swift

@@ -52,7 +52,7 @@ open class UIScrollView: UIView {
     /// The contentOffset that is currently shown on the screen
     /// We won't need this once we implement animations via DisplayLink instead of with UIView.animate
     var visibleContentOffset: CGPoint {
-        return (layer._presentation ?? layer).bounds.origin
+        return (layer.presentation() ?? layer).bounds.origin
     }
 
     /// prevent `newContentOffset` being out of bounds

Sources/UIView+SDL.swift

@@ -10,7 +10,7 @@ internal import SDL
 
 extension UIView {
     final func sdlDrawAndLayoutTreeIfNeeded(parentAlpha: CGFloat = 1.0) {
-        let visibleLayer = (layer._presentation ?? layer)
+        let visibleLayer = (layer.presentation() ?? layer)
 
         let alpha = CGFloat(visibleLayer.opacity) * parentAlpha
         if visibleLayer.isHidden || alpha < 0.01 { return }

Sources/UIView.swift

@@ -351,7 +351,7 @@ open class UIView: UIResponder, CALayerDelegate, UIAccessibilityIdentification {
 
         let keyPath = AnimationKeyPath(stringLiteral: event)
         let beginFromCurrentState = prototype.animationGroup.options.contains(.beginFromCurrentState)
-        let state = beginFromCurrentState ? (layer._presentation ?? layer) : layer
+        let state = beginFromCurrentState ? (layer.presentation() ?? layer) : layer
 
         if let fromValue = state.value(forKeyPath: keyPath) {
             return prototype.createAnimation(keyPath: keyPath, fromValue: fromValue)