Deepak Sharma's questions

Tenho a seguinte classe de modelo SwiftUI Observable junto com variáveis ​​de ator local e global que falham ao construir com o erro Global actor 'MyGlobalActor'-isolated default value in a nonisolated context. Minha pergunta é o que há de especial no ator global que a construção falha, mas a construção é bem-sucedida para o ator local? O método init no ator local é executado no contexto padrão, mas o ator global é executado em contexto isolado?

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()
}

O código a seguir dá erro ao compilar na versão de linguagem Swift 6 no Xcode. Isso é um problema de arquitetura ou tem uma solução fácil? O tipo Boolé Sendable, mas seu publicador não é.

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
    }
}

Consulte esta captura de tela para ver os erros reais que vejo no código de exemplo do AVCam (com a única modificação de colocar @preconcurrency) import AVFoundation.

Marcar uma classe ou função como Sendablegarante que é seguro passar por limites simultâneos, tipos de valor são seguros, pois implementam cópia na gravação, etc., todos nós encontramos na documentação da linguagem Swift. Mas meu ponto é que Sendablenão promete que uma variável esteja livre de corridas de dados. Podemos ter corridas de dados mesmo em tipos de valor básicos, como Intdemonstrado no código abaixo. Então Sendablenão equivale a estar seguro de dados contra acesso/modificação simultânea, significa apenas que o valor é seguro para copiar em diferentes threads. Mas minha pergunta é qual problema isso resolve ou qual é a importância de ter Sendablecomo uma construção então? Alguém pode explicar isso?

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 
    }
}

Estou recebendo esse erro em alguns lugares no meu código com o encerramento de tarefa após definir Swift 6 como versão de linguagem no XCode.

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

Abaixo está um código de exemplo minimamente reproduzível.

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
    }
}

Isto é com referência ao código de exemplo AVCam da Apple:

   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()
        }
     ...
  }

E mais tarde no código do Ator:

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

Se entendi corretamente, o efeito desse código é fazer com que todas as chamadas de método isoladas e modificações de estado mutável aconteçam efetivamente sessionQueuechamando implicitamente sessionQueue.sync(). Meu entendimento está correto ou há mais do que isso?

Quero entender a utilidade de usar AsyncStreamquando o iOS 17 introduziu @Observablea macro onde podemos observar diretamente as mudanças no valor de qualquer variável no modelo (e o rastreamento de observação pode acontecer mesmo fora da visualização SwiftUI). Então, se eu estiver observando um fluxo contínuo de valores, como o progresso do download de um arquivo usando AsyncStreamuma visualização SwiftUI, o mesmo pode ser observado na mesma visualização SwiftUI usando onChange(of:initial)o progresso do download (armazenado como uma propriedade no objeto do modelo). Estou procurando benefícios, desvantagens e limitações de ambas as abordagens.

Especificamente, minha pergunta é com relação ao código de exemplo AVCam da Apple, onde eles observam alguns estados como segue. Isso é feito em CameraModelclasse que é anexada à visualização 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
            }
        }
    }
}

Se virmos a estrutura CaptureCapabilities, é uma estrutura pequena com dois membros Bool. Essas mudanças poderiam ter sido observadas diretamente por uma visualização SwiftUI. Gostaria de saber se há uma vantagem ou razão específica para usar AsyncStreamaqui e iterar continuamente sobre as mudanças em um loop for.

   /// 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()
}

Tenho um retângulo arredondado e desejo mascarar as partes esquerda e direita dele (cujas larguras podem ser definidas como Statevariáveis). O que eu quero é que o retângulo arredondado preserve seu formato de retângulo arredondado conforme aplico máscaras esquerda e direita. Digo máscara para fins de explicação, mas a implementação real pode não usar .masko modificador se criar problemas no teste de acerto para reconhecedores de gestos em toda a visualização.

Aqui está o código para mascarar as partes esquerda e direita de um retângulo arredondado.

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)
        }
    
}

A saída é algo como isto. Mas eu quero que a visualização laranja principal seja um retângulo arredondado do que um retângulo simples na saída. Como eu implemento isso no SwiftUI?

Quero detectar onde o gesto de arrastar começou. Tenho uma subvisualização com apenas 20 pontos de largura. Adiciono um gesto de arrastar à supervisualização e quero me mover por essa subvisualização somente se o local de início do gesto de arrastar no início do gesto estiver a 20 pontos do local dessa subvisualização. Não quero adicionar o gesto de arrastar a essa subvisualização, pois isso causou outros problemas no código (relatados em outras perguntas do SO e sem solução limpa). Então, tento adicionar o gesto à supervisualização.

Tentei o seguinte código, mas ele não funciona porque não detecta quando e onde o gesto COMEÇOU.

  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
                        
                    }

Tenho o seguinte código SwiftUI:

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

Aqui está o resultado.

Claramente pode ser visto que o retângulo interno em azul foi colocado no centro do retângulo externo. Eu tentei experimentar com o alinhamento de frames e posso ver que o alinhamento do retângulo interno só pode ser alterado alterando o alinhamento do frame do retângulo externo como segue:

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

Mas nada muda se eu alterar a propriedade de alinhamento do quadro do retângulo interno.

Quero entender esse comportamento mais claramente: se a visualização é centralizada por padrão e por que a modificação do alinhamento do quadro interno não altera nada.

Tenho o seguinte código no 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()

Vejo a seguinte saída:

Efetivamente, ele está recortando conteúdo tanto à esquerda quanto à direita do HStack. O que eu quero é que o recorte aconteça apenas no lado direito (à direita), não no lado esquerdo. Qual é a maneira correta de fazer isso?

Implementei uma linha do tempo de edição de vídeo de exemplo usando SwiftUI e estou enfrentando problemas. Então, estou dividindo o problema em partes e postando cada problema como uma pergunta separada. No código abaixo, tenho uma linha do tempo simples usando um HStackespaçador esquerdo, espaçador direito (representado como cor preta simples) e uma IU de aparador no meio. O aparador é redimensionado conforme as alças esquerda e direita são arrastadas. Os espaçadores esquerdo e direito também se ajustam em largura conforme as alças do aparador são arrastadas.

Problema : Quero manter as miniaturas de fundo (implementadas atualmente como retângulos simples preenchidos em cores diferentes) no aparador estacionárias enquanto o aparador é redimensionado. Atualmente, elas se movem conforme o aparador é redimensionado, como visto no gif abaixo. Como faço para consertar isso?

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()
}

Atualização : consegui resolver o problema da seguinte forma, mas ainda sinto que é meio que uma solução alternativa (pois configurei um deslocamento para a visualização de miniaturas). Por favor, poste uma solução melhor e mais precisa se você acha que há alguma (como usar uma máscara que também reduz a largura do quadro do aparador ao mesmo tempo).

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()
}

Estou tentando implementar uma interface de usuário de corte de vídeo no SwiftUI da seguinte maneira:

 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)")
            }
    }
}

Isso funciona para mover a mão esquerda do trimmer quando arrastado. O que eu preciso também é encolher a SimpleTrimmervisualização conforme as extremidades são arrastadas. Simplesmente não funciona, não importa o que eu faça (como ajustar o deslocamento e a largura do HStack principal, etc.).

Estou tentando projetar uma visualização de aparador de vídeo no SwiftUI da seguinte forma. O resultado é este. Minha pergunta é se posso ter a parte do meio (ou seja, tudo, exceto 20 pontos à esquerda e à direita e 5 pontos para cima e para baixo) transparente para que eu possa mostrar miniaturas atrás delas (talvez tendo um formato de clipe personalizado)?

  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)")
    }

}

Estou incorporando o SwiftUI VideoPlayerem um VStacke vejo que a tela fica preta (ou seja, o conteúdo desaparece mesmo que o player de vídeo seja girado automaticamente) quando o dispositivo é girado. O problema acontece mesmo quando eu uso AVPlayerViewController(as UIViewControllerRepresentable). Isso é um bug ou estou fazendo algo errado?

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)
    }

 }

Eu tenho uma visualização SwiftUI envolvida UIHostingControllere apresentada modalmente como formSheetno iPad. Eu tenho um botão concluído para descartar e um fechamento de retorno de chamada é passado do controlador de visualização pai para executar ações quando esse botão concluído é pressionado. O problema acontece no iPad, onde o usuário pode tocar fora da visualização e a visualização é descartada, perdendo assim o retorno de chamada.

Uma maneira de resolver isso seria acionar o fechamento de retorno de chamada na onDismissvisualização SwiftUI. Embora funcione, não tenho certeza se é o lugar certo e se é confiável o suficiente. A documentação só diz que onDismissé chamado quando a "visualização desaparece da tela". No entanto, e se colocarmos uma visualização no topo dessa visualização em uma hierarquia de navegação, ela onDismissainda será chamada?

Muitas vezes, somos obrigados a abrir uma visualização que deve ser apresentada em UIViewControlleruma visualização SwiftUI. Exemplos proeminentes disso UIDocumentInteractionControllere menos proeminentes são o SwiftyDropbox para abrir uma tela de login do Dropbox no Safari para autenticação. A técnica comum é criar uma subclasse UIViewControllersob demanda UIViewControllerRepresentablee apresentar o controlador de visualização a partir dela. Mas isso nunca funcionou para mim.

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()
   }
}

Quando invoco essa visualização a partir de uma visualização SwiftUI usando modificadores como:

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

Eu recebo dois erros:

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.

e

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

Gostaria de saber como apresentar esses controladores de visualização na visualização SwiftUI?

Parece que [[stitchable]]os kernels do Metal Core Image falham ao vincular em tempo de compilação devido ao Core Image sampler.coord()e sampler.sample(coord)símbolos não encontrados, OU, falham ao carregar em tempo de execução se eu adicionar outros sinalizadores de vinculador do Metal -fcikernel(o que não é necessário de qualquer maneira para kernels costuráveis).

Aqui está o link completo do projeto de teste no github . Sinta-se à vontade para baixá-lo e brincar.

Descobri que o principal culpado é esta linha no arquivo Metal que o vinculador não consegue resolver:

 float2 srcCoord = inputImage.coord();

Trechos do meu código:

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])
}

}

Aqui está o arquivo Metal:

 #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;
}

E aqui está o uso:

       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)")
}

}

E a saída:

     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.