Deepak Sharma's questions

我有以下 SwiftUI Observable 模型类以及本地和全局参与者变量，但无法构建并出现错误Global actor 'MyGlobalActor'-isolated default value in a nonisolated context。我的问题是全局参与者构建失败但本地参与者构建成功有什么特别之处？本地参与者中的 init 方法是否在默认上下文中运行，而全局参与者在隔离上下文中运行？

import SwiftUI
    
@Observable
final class Model {
    let testActor = TestLocalActor() //This builds 
    let testGlobalActor = TestGlobalActor() //Build fails here
}

actor TestLocalActor {
    init() {
        
    }
}

@MyGlobalActor
final class TestGlobalActor {
    init() {
        
    }
}

@globalActor
actor MyGlobalActor: GlobalActor {
   static let shared = MyGlobalActor()
}

以下代码在 Xcode 中 Swift 6 语言版本下构建时出错。这是架构问题还是有简单的解决方法？类型Bool是，Sendable但它的发布者不是。

Non-sendable type 'Published<Bool>.Publisher' in implicitly asynchronous access to actor-isolated property '$isRecording' cannot cross actor boundary

import Foundation

final class Recorder {
    
    var writer = Writer()
    var isRecording = false
    
    func startRecording() {
        Task { [writer] in
            await writer.startRecording()
            print("started recording")
        }
    }
    
    func stopRecording() {
        Task { [writer] in
            await writer.stopRecording()
            print("stopped recording")
        }
    }
    
    func observeValues() {
        
        Task {
            for await value in await writer.$isRecording.values {
                isRecording = value
            }
        }
    }
}

actor Writer {
    @Published private(set) public var isRecording = false
    
    func startRecording() {
        isRecording = true
    }
    
    func stopRecording() {
        isRecording = false
    }
}

请参阅此屏幕截图以查看我看到的 AVCam 示例代码中的实际错误（唯一的修改是输入@preconcurrency）import AVFoundation。

将类或函数标记为Sendable可确保它可以安全地跨越并发边界，值类型是安全的，因为它们实现了写时复制等，我们都可以在 Swift 语言文档中找到。但我的观点是，这Sendable并不保证变量没有数据竞争。即使在基本值类型中，我们也可能存在数据竞争，如Int下面的代码所示。因此，Sendable并不等同于数据可以安全地避免并发访问/修改，它只意味着值可以安全地跨不同线程复制。但我的问题是它解决了什么问题，或者作为构造的重要性是什么Sendable？有人可以解释一下吗？

var num = 0

DispatchQueue.global(qos: .background).async {
    for _ in 0..<100 {
        num += 1 
    }
}

DispatchQueue.global(qos: .background).async {
    for _ in 0..<100 {
        num -= 1 
    }
}

在 XCode 中将 Swift 6 设置为语言版本后，我在代码中的几个地方使用 Task 关闭时收到此错误。

Passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure

以下是最低限度可重现的示例代码。

import Foundation

final class Recorder {
    
    var writer = Writer()
    
    func startRecording() {
        Task {
            await writer.startRecording()
            print("started recording")
        }
    }
    
    func stopRecording() {
        Task {
            await writer.stopRecording()
            print("stopped recording")
        }
    }
}

actor Writer {
    var isRecording = false
    
    func startRecording() {
        isRecording = true
    }
    
    func stopRecording() {
        isRecording = false
    }
}

这是参考Apple的AVCam示例代码：

   actor CaptureService {

          // The app's capture session.
         private let captureSession = AVCaptureSession()

        // A serial dispatch queue to use for capture control actions.
         private let sessionQueue = DispatchSerialQueue(label: "com.example.apple-samplecode.AVCam.sessionQueue")

       // Sets the session queue as the actor's executor.
        nonisolated var unownedExecutor: UnownedSerialExecutor {
            sessionQueue.asUnownedSerialExecutor()
        }
     ...
  }

然后在 Actor 代码中：

    // Set the controls delegate.
    captureSession.setControlsDelegate(controlsDelegate, queue: sessionQueue)

如果我理解正确的话，此代码的效果是通过sessionQueue隐式调用使所有隔离方法调用和可变状态修改有效地发生在sessionQueue.sync()。我的理解正确吗？还是还有更多内容？

AsyncStream我想了解iOS 17 引入宏的实用性@Observable，我们可以在其中直接观察模型中任何变量值的变化（并且观察跟踪甚至可以在 SwiftUI 视图之外进行）。因此，如果我AsyncStream在 SwiftUI 视图中使用连续的值流（例如文件的下载进度），则可以在同一个 SwiftUI 视图中使用onChange(of:initial)下载进度（存储为模型对象中的属性）观察到相同的值流。我正在寻找这两种方法的优点、缺点和局限性。

具体来说，我的问题与 Apple 的AVCam 示例代码有关，他们观察到以下几个状态。这是在CameraModel附加到 SwiftUI 视图的类中完成的。

    // MARK: - Internal state observations

// Set up camera's state observations.
private func observeState() {
    Task {
        // Await new thumbnails that the media library generates when saving a file.
        for await thumbnail in mediaLibrary.thumbnails.compactMap({ $0 }) {
            self.thumbnail = thumbnail
        }
    }
    
    Task {
        // Await new capture activity values from the capture service.
        for await activity in await captureService.$captureActivity.values {
            if activity.willCapture {
                // Flash the screen to indicate capture is starting.
                flashScreen()
            } else {
                // Forward the activity to the UI.
                captureActivity = activity
            }
        }
    }
    
    Task {
        // Await updates to the capabilities that the capture service advertises.
        for await capabilities in await captureService.$captureCapabilities.values {
            isHDRVideoSupported = capabilities.isHDRSupported
            cameraState.isVideoHDRSupported = capabilities.isHDRSupported
        }
    }
    
    Task {
        // Await updates to a person's interaction with the Camera Control HUD.
        for await isShowingFullscreenControls in await captureService.$isShowingFullscreenControls.values {
            withAnimation {
                // Prefer showing a minimized UI when capture controls enter a fullscreen appearance.
                prefersMinimizedUI = isShowingFullscreenControls
            }
        }
    }
}

如果我们看到结构，它是一个具有两个 Bool 成员的小结构。这些变化可以通过 SwiftUI 视图直接观察到。我想知道在这里使用并在 for 循环中不断迭代变化CaptureCapabilities是否有特定的优势或理由。AsyncStream

   /// A structure that represents the capture capabilities of `CaptureService` in
  /// its current configuration.
struct CaptureCapabilities {

let isLivePhotoCaptureSupported: Bool
let isHDRSupported: Bool

init(isLivePhotoCaptureSupported: Bool = false,
     isHDRSupported: Bool = false) {
    self.isLivePhotoCaptureSupported = isLivePhotoCaptureSupported
    self.isHDRSupported = isHDRSupported
}

  static let unknown = CaptureCapabilities()
}

我有一个圆角矩形，我想遮盖它的左右部分（其宽度可以自定义为State变量）。我希望圆角矩形在应用左右遮盖时保留其圆角矩形形状。我说遮盖是为了解释，但.mask如果在整个视图上对手势识别器的命中测试中产生问题，实际实现可能不会使用修饰符。

这是屏蔽圆角矩形左侧和右侧部分的代码。

struct MaskTesting: View {

  @State var rectWidth:CGFloat = 300
  @State var leftMaskWidth:CGFloat = 100
  @State var rightMaskWidth:CGFloat = 100

  var body: some View {
    
    Rectangle()
        .fill(Color.orange)
        .frame(maxHeight:70)
        .frame(width: rectWidth)
        .clipShape(RoundedRectangle(cornerRadius: 5))
        .overlay(alignment: .leading) {
            Rectangle()
                .fill(Color.purple)
                .frame(maxHeight:70)
                .frame(width: leftMaskWidth)
        }
        .overlay(alignment: .leading) {
            Rectangle()
                .fill(Color.purple)
                .frame(maxHeight:70)
                .frame(width: rightMaskWidth)
                .offset(x:rectWidth - 100)
        }
    
}

输出是这样的。但我希望输出中的主橙色视图是圆角矩形而不是普通矩形。如何在 SwiftUI 中实现它？

我想检测拖动手势的起始位置。我有一个只有 20 点宽的子视图。我向超级视图添加了一个拖动手势，并且仅当手势开始时的拖动手势起始位置在该子视图位置的 20 点以内时，我才想在这个子视图周围移动。我不想向这个子视图添加拖动手势，因为它已经在代码中引起了其他问题（在其他 SO 问题中报告，并且没有干净的解决方案）。所以我尝试将手势添加到超级视图。

我尝试了以下代码，但它不起作用，因为它无法检测手势开始的时间和地点。

  DragGesture(minimumDistance: 0)
                    .updating($scrubberSeeking, body: { value, state, _ in
                        
                        if abs(value.startLocation.x - scrubberOffset) > 20.0  {
                            state = false
                            return
                        }
                        
                        state = true
                    })
                    .onChanged({ value in
                        
                            if scrubberSeeking {
                                ...
                                ...
                            }
                       

                    })
                    .onEnded { value in
                        
                    }

我有以下 SwiftUI 代码：

    Rectangle()
        .fill(Color.blue.opacity(0.5))
        .frame(width: 130)
        .frame(maxWidth: .infinity)
        .background(Color.orange.opacity(0.5))
        .padding()
        .frame(maxHeight:100)

这是输出。

可以清楚地看到，蓝色的内矩形已放置在外矩形的中心。我尝试对框架的对齐方式进行实验，发现只能通过改变外矩形的框架对齐方式来更改内矩形的对齐方式，如下所示：

  .frame(maxWidth: .infinity, alignment: .trailing)

但是如果我改变内部矩形的框架对齐属性，则什么都不会改变。

我想更清楚地理解这种行为——视图是否默认居中，以及为什么内部框架对齐修改没有任何改变。

我在 SwiftUI 中有以下代码：

  HStack(spacing: 0) {
        ForEach(images) { thumbImage in
            Image(uiImage: thumbImage.image)
                .resizable()
                .aspectRatio(contentMode: .fill)
                .frame(width: 50, height: 50)
                .clipped()
        }
    }
    .frame(width: 330, alignment: .center)
    .clipped()

我看到以下输出：

实际上，它会剪切左右两侧的内容HStack。我想要的是只在右侧（尾部）进行剪切，而不是左侧。实现它的正确方法是什么？

我已经使用 SwiftUI 实现了一个示例视频编辑时间线，但遇到了一些问题。因此，我将问题分解成几个部分，并将每个问题作为单独的问题发布。在下面的代码中，我有一个简单的时间线，它HStack由左间隔、右间隔（表示为简单的黑色）和中间的修剪器 UI 组成。当拖动左右手柄时，修剪器会调整大小。当拖动修剪器手柄时，左右间隔的宽度也会调整。

问题：我希望修剪器中的背景缩略图（当前实现为填充不同颜色的简单矩形）在修剪器调整大小时保持静止。当前，它们会随着修剪器调整大小而移动，如下面的 gif 所示。我该如何修复它？

import SwiftUI

struct SampleTimeline: View {
    
    let viewWidth:CGFloat = 340 //Width of HStack container for Timeline
   
    @State var frameWidth:CGFloat = 280 //Width of trimmer
    
    var minWidth: CGFloat {
        2*chevronWidth + 10
    } //min Width of trimmer
    
    @State private var leftViewWidth:CGFloat = 20
    @State private var rightViewWidth:CGFloat = 20
    
    var chevronWidth:CGFloat {
        return 24
    }
    
    var body: some View {
        
        HStack(spacing:0) {
            Color.black
                .frame(width: leftViewWidth)
                .frame(height: 70)
            
            HStack(spacing: 0) {
            
                Image(systemName: "chevron.compact.left")
                    .frame(width: chevronWidth, height: 70)
                    .background(Color.blue)
                    .gesture(
                        DragGesture(minimumDistance: 0)
                            .onChanged({ value in
                                leftViewWidth = max(leftViewWidth + value.translation.width, 0)
                                
                                if leftViewWidth > viewWidth - minWidth - rightViewWidth {
                                    leftViewWidth = viewWidth - minWidth - rightViewWidth
                                }
                                   
                                frameWidth = max(viewWidth - leftViewWidth - rightViewWidth, minWidth)
                                
                            })
                            .onEnded { value in
                               
                            }
                    )
        
                Spacer()
                
                Image(systemName: "chevron.compact.right")
                    .frame(width: chevronWidth, height: 70)
                    .background(Color.blue)
                    .gesture(
                        DragGesture(minimumDistance: 0)
                            .onChanged({ value in
                                rightViewWidth = max(rightViewWidth - value.translation.width, 0)
                                
                                if rightViewWidth > viewWidth - minWidth - leftViewWidth {
                                    rightViewWidth = viewWidth - minWidth - leftViewWidth
                                }
                                
                                frameWidth = max(viewWidth - leftViewWidth - rightViewWidth, minWidth)
                            })
                            .onEnded { value in
                              
                            }
                    )
                 
            }
            .foregroundColor(.black)
            .font(.title3.weight(.semibold))
          
            .background {
                
                HStack(spacing:0) {
                    Rectangle().fill(Color.red)
                        .frame(width: 70, height: 60)
                    Rectangle().fill(Color.cyan)
                        .frame(width: 70, height: 60)
                    Rectangle().fill(Color.orange)
                        .frame(width: 70, height: 60)
                    Rectangle().fill(Color.brown)
                        .frame(width: 70, height: 60)
                    Rectangle().fill(Color.purple)
                        .frame(width: 70, height: 60)
                }
                
            }
            .frame(width: frameWidth)
            .clipped()
            
            Color.black
                .frame(width: rightViewWidth)
                .frame(height: 70)
        }
        .frame(width: viewWidth, alignment: .leading)
    }
}

#Preview {
    SampleTimeline()
}

更新：我已设法按如下方式解决问题，但我仍然觉得这只是一种变通方法（因为我已为缩略图视图设置了偏移）。如果您认为有任何更好更准确的解决方案，请发布（例如，使用同时减小修剪器框架宽度的遮罩）。

import SwiftUI

struct SampleTimeline: View {
    
    let viewWidth:CGFloat = 340 //Width of HStack container for Timeline
   
    @State var frameWidth:CGFloat = 280 //Width of trimmer
    
    var minWidth: CGFloat {
        2*chevronWidth + 10
    } //min Width of trimmer
    
    @State private var leftViewWidth:CGFloat = 20
    @State private var rightViewWidth:CGFloat = 20
    @GestureState private var leftEndPanned = false
    @GestureState private var rightEndPanned = false
    
    var chevronWidth:CGFloat {
        return 24
    }
    
    var body: some View {
        
        HStack(spacing:0) {
            Color.clear
                .frame(width: leftViewWidth)
                .frame(height: 70)
            
            HStack(spacing: 0) {
            
                Image(systemName: "chevron.compact.left")
                    .frame(width: chevronWidth, height: 70)
                    .background(Color.blue)
                    .gesture(
                        DragGesture(minimumDistance: 0)
                            .updating($leftEndPanned, body: { _, state, _ in
                                state = true
                            })
                            .onChanged({ value in
                                leftViewWidth = max(leftViewWidth + value.translation.width, 0)
                                
                                if leftViewWidth > viewWidth - minWidth - rightViewWidth {
                                    leftViewWidth = viewWidth - minWidth - rightViewWidth
                                }
                                   
                                frameWidth = max(viewWidth - leftViewWidth - rightViewWidth, minWidth)
                                
                            })
                            .onEnded { value in
                               
                            }
                    )
        
                Spacer()
                
                Image(systemName: "chevron.compact.right")
                    .frame(width: chevronWidth, height: 70)
                    .background(Color.blue)
                    .gesture(
                        DragGesture(minimumDistance: 0)
                            .updating($rightEndPanned, body: { _, state, _ in
                                state = true
                            })
                            .onChanged({ value in
                                rightViewWidth = max(rightViewWidth - value.translation.width, 0)
                                
                                if rightViewWidth > viewWidth - minWidth - leftViewWidth {
                                    rightViewWidth = viewWidth - minWidth - leftViewWidth
                                }
                                
                                frameWidth = max(viewWidth - leftViewWidth - rightViewWidth, minWidth)
                            })
                            .onEnded { value in
                              
                            }
                    )
                 
            }
            .foregroundColor(.black)
            .font(.title3.weight(.semibold))
            .background {
                
                HStack(spacing:0) {
                    Rectangle().fill(Color.red)
                        .frame(width: 70, height: 60)
                    Rectangle().fill(Color.cyan)
                        .frame(width: 70, height: 60)
                    Rectangle().fill(Color.orange)
                        .frame(width: 70, height: 60)
                    Rectangle().fill(Color.brown)
                        .frame(width: 70, height: 60)
                    Rectangle().fill(Color.purple)
                        .frame(width: 70, height: 60)
                }
                .frame(width: viewWidth - leftViewWidth - rightViewWidth, alignment: .leading)
                .offset(x: -leftViewWidth)
                .background(Color.yellow)
                .clipped()
                
            }
            
            
            Color.clear
                .frame(width: rightViewWidth)
                .frame(height: 70)
        }
        .frame(width: viewWidth, alignment: .leading)
    }
}

#Preview {
    SampleTimeline()
}

我正在尝试在 SwiftUI 中实现视频修剪器 UI，如下所示：

 struct SimpleTrimmer: View {
    @State private var startPosition: CGFloat = 0
    @GestureState private var isDragging: Bool = false
    
    @State private var lastStartPosition: CGFloat = .zero
    @State private var frameWidth:CGFloat = 300
    
    var body: some View {
        HStack(spacing: 10) {
                Image(systemName: "chevron.compact.left")
                    .frame(height:70)
                    .frame(width:20)
                    .padding(.horizontal, 5)
                    .background(Color.blue)
                    .offset(x: startPosition)
                    .gesture(
                        DragGesture(minimumDistance: 0)
                            .updating($isDragging, body: { value, out, transaction in
                                out = true
                                
                            })
                            .onChanged { value in
                                let translation = value.translation.width
                                startPosition = translation + lastStartPosition
                            }.onEnded { _ in
                                lastStartPosition = startPosition
                                NSLog("Last start position \(lastStartPosition)")
                            }
                    )
            
                
                Spacer()
                
                Image(systemName: "chevron.compact.right")
                .frame(height:70)
                .frame(width:20)
                .padding(.horizontal, 5)
                .background(Color.blue)
            }
            .foregroundColor(.black)
            .font(.title3.weight(.semibold))
            .padding(.horizontal, 7)
            .padding(.vertical, 3)
            .background(.yellow)
            .clipShape(RoundedRectangle(cornerRadius: 7))
            .frame(width: frameWidth)
          //  .offset(x: startPosition)
            .onGeometryChange(for: CGFloat.self) { proxy in
                proxy.size.width
            } action: { width in
                print("width = \(width)")
            }
    }
}

这适用于拖动时移动修剪器的左手。我还需要SimpleTrimmer拖动末端时缩小视图。无论我做什么（例如调整主 HStack 的偏移量和宽度等），它都不起作用。

我正在尝试在 SwiftUI 中设计一个视频修剪器视图，如下所示。结果如下。我的问题是，我是否可以将中间部分（即除左右 20 个点和上下 5 个点之外的所有内容）透明，以便我可以在它们后面显示缩略图（也许通过自定义剪辑形状）？

  var body: some View {
    HStack(spacing: 10) {
        Image(systemName: "chevron.compact.left")
            .frame(height:70)
        
        Spacer()
        
        Image(systemName: "chevron.compact.right")
    }
    .foregroundColor(.black)
    .font(.title3.weight(.semibold))
    .padding(.horizontal, 7)
    .padding(.vertical, 3)
    .background(.yellow)
    .clipShape(RoundedRectangle(cornerRadius: 7))
    .frame(width: 300)
    .onGeometryChange(for: CGFloat.self) { proxy in
        proxy.size.width
    } action: { width in
        print("width = \(width)")
    }

}

我将 SwiftUI 嵌入VideoPlayer到 a 中VStack，看到当设备旋转时屏幕变黑（即即使视频播放器自动旋转，内容也会消失）。即使我使用AVPlayerViewController(as UIViewControllerRepresentable)，也会出现此问题。这是一个错误还是我做错了什么？

var videoURL:URL
let player = AVPlayer()

var body: some View {
    VStack {
        VideoPlayer(player: player)
                        .frame(maxWidth:.infinity)
                        .frame(height:300)
                        .padding()
                        .ignoresSafeArea()
                        .background {
                            Color.black
                        }
                        .onTapGesture {
                            player.rate = player.rate == 0.0 ? 1.0 : 0.0
                        } 
       
        Spacer()
    }
    .ignoresSafeArea()
    .background(content: {
        Color.black
    })
    .onAppear {
        let audioSession = AVAudioSession.sharedInstance()
        do {
            try audioSession.setCategory(AVAudioSession.Category.playback, mode: AVAudioSession.Mode.default, options: AVAudioSession.CategoryOptions.duckOthers)
        } catch {
            NSLog("Unable to set session category to playback")
        }
        
        let playerItem = AVPlayerItem(url: videoURL)
        player.replaceCurrentItem(with: playerItem)
    }

 }

我有一个 SwiftUI 视图，UIHostingController并像formSheet在 iPad 上那样以模态方式呈现。我有一个完成按钮可以关闭，并且有一个从父视图控制器传递的回调闭包，以便在按下此完成按钮时执行操作。该问题发生在 iPad 上，用户可能会在视图之外点击，视图会被关闭，从而错过回调。

解决此问题的一种方法是触发onDismissSwiftUI 视图中的回调闭包。虽然它有效，但我不确定它是否是正确的地方以及是否足够可靠。文档只说onDismiss当“视图从屏幕上消失”时调用。但是，如果我们将一个视图推到导航层次结构中该视图的顶部，onDismiss仍然会被调用怎么办？

很多时候，我们需要打开一个需要在UIViewControllerSwiftUI 视图中呈现的视图。此类的突出示例UIDocumentInteractionController和不太突出的示例是 SwiftyDropbox，用于在 Safari 中打开 Dropbox 的登录屏幕进行身份验证。常见的技术是在子类中创建一个UIViewController按需的UIViewControllerRepresentable并从中呈现视图控制器。但它从来没有对我有用。

struct DropboxView: UIViewControllerRepresentable {
   typealias UIViewControllerType = UIViewController

   @Binding var isShown : Bool

   func updateUIViewController(_ uiViewController: UIViewController, context: Context)  {
    
     if isShown {
        let scopeRequest = ScopeRequest(scopeType: .user, scopes: ["files.content.write"], includeGrantedScopes: false)
  
        DropboxClientsManager.authorizeFromControllerV2(
            UIApplication.shared,
            controller: uiViewController,
            loadingStatusDelegate: nil,
            openURL: { (url: URL) -> Void in UIApplication.shared.open(url, options: [:], completionHandler: nil) },
            scopeRequest: scopeRequest)
       }
    }

   func makeUIViewController(context _: Self.Context) -> UIViewController {
       return UIViewController()
   }
}

当我使用修饰符从 SwiftUI 视图调用此类视图时，例如：

    .fullScreenCover(isPresented: $showDropboxLoginView) {
        DropboxView(isShown: $showDropboxLoginView)
    }

我收到两个错误：

Cannot use Scene methods for URL, NSUserActivity, and other External Events without using SwiftUI Lifecycle. Without SwiftUI Lifecycle, advertising and handling External Events wastes resources, and will have unpredictable results.

和

Attempt to present <SwiftyDropbox.MobileSafariViewController: 0x107919600> on <UIViewController: 0x105a2f130> (from <UIViewController: 0x105a2f130>) whose view is not in the window hierarchy.

我想知道如何从 SwiftUI 视图中呈现此类视图控制器？

看起来[[stitchable]]Metal Core Image 内核由于未找到 Core Imagesampler.coord()和符号而无法在编译时链接，或者如果我添加其他 Metal 链接器标志（这对于可缝合内核来说并不是必需的），则sampler.sample(coord)无法在运行时加载。-fcikernel

这是github上测试项目的完整链接。欢迎下载并玩一玩。

我发现罪魁祸首是 Metal 文件中的这一行，链接器无法解析：

 float2 srcCoord = inputImage.coord();

我的代码摘录：

import CoreImage

class FilterTwo: CIFilter {
var inputImage: CIImage?
var inputParam: Float = 0.0

static var kernel: CIKernel = { () -> CIKernel in
   let url = Bundle.main.url(forResource: "default",
                            withExtension: "metallib")!
   let data = try! Data(contentsOf: url)

    let kernelNames = CIKernel.kernelNames(fromMetalLibraryData: data)
    NSLog("Kernels \(kernelNames)")
   return try! CIKernel(functionName: "secondFilter", fromMetalLibraryData: data) //<-- This fails!
}()

override var outputImage : CIImage? {
    guard let inputImage = inputImage else {
        return nil
    }
    
    return FilterTwo.kernel.apply(extent: inputImage.extent, roiCallback: { (index, rect) in
        return rect }, arguments: [inputImage])
}

}

这是金属文件：

 #include <CoreImage/CoreImage.h> // includes CIKernelMetalLib.h

 using namespace metal;

 [[ stitchable ]] half4 secondFilter (coreimage::sampler inputImage, coreimage::destination dest)
{
   float2 srcCoord = inputImage.coord();
   half4 color =  half4(inputImage.sample(srcCoord));

   return color;
}

这是用法：

       class ViewController: UIViewController {

override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view.
    
    let filter = FilterTwo()
    filter.inputImage = CIImage(color: CIColor.red)
    let outputImage = filter.outputImage!
    
    NSLog("Output \(outputImage)")
}

}

和输出：

     StitchableKernelsTesting/FilterTwo.swift:15: Fatal error: 'try!' expression unexpectedly raised an error: Error Domain=CIKernel Code=1 "(null)" UserInfo={CINonLocalizedDescriptionKey=Function does not exist in library data. …•∆}
   Kernels []

   reflect Function 'secondFilter' does not exist.