SDWebImageSwiftUI
3.1.3 - Data Race
Se você suporta o iOS 15+/MacOS 12+ e não se importa com o formato de imagem animado, tente a assíncimagem de Swiftui
SdwebimageswiftUi é uma estrutura de carregamento de imagem Swiftui, com base no sdwebimage.
Ele traz todos os seus recursos favoritos da SDWebImage, como carregamento de imagem assíncrona, cache de memória/disco, reprodução de imagem animada e performances.
A estrutura fornece as diferentes estruturas de visualização, que a API corresponde à diretriz da estrutura Swiftui. Se você estiver familiarizado com Image , você achará fácil usar WebImage e AnimatedImage .
Na v3.0.0, o SDWebImageswiftUi pode ser compilado para a plataforma Visionos. No entanto, devido ao falta de suporte ao gerenciador de pacotes (precisam de atualização de ferramentas), ainda não oferecemos suporte a Cocoapods/SPM.
Você só pode usar a dependência do gerenciador de pacotes do Xcode para desenvolver o Visionos.
Para executar o exemplo do Visionos, você precisa clonar e adicionar SDWebImage e SDWebImageSwiftUI , abra o SDWebImageSwiftUI.xcworkspace e arraste essas pastas para se tornar dependência do pacote local, consulte: editar um pacote dependência como um pacote local
Se você realmente deseja criar a estrutura em vez de usar a dependência do pacote do Xcode, seguindo as etapas manuais abaixo:
SDWebImage.xcodeproj E CONSTRUIR SDWebImage LARGO PLAPATURA DO VIANÇO (Alterar MACH_O_TYPE para biblioteca estática, se necessário)Carthage/Build/visionOS e Copie SDWebImage.framework para eleSDWebImageSwiftUI.xcodeproj e construa SDWebImageSwiftUI visionOS alvo Como o SDWebImageswiftlui é construído sobre o SDWebImage, ele fornece os recursos fora da caixa e os recursos poderosos avançados que você pode desejar nos aplicativos do mundo real. Verifique nosso wiki quando precisar:
Você também pode obter todos os benefícios da comunidade existente com a SDWebimage. Você pode ter suporte massivo de formato de imagem (gif/apng/webp/heif/avif/svg/pdf) via plugins de codificadores, suporte de fotokit via sdwebimagephotosplugin, integração do Firebase via Firebaseui, etc.
Além de todos esses recursos, fazemos otimização para Swiftui, como a ligação, visualiza o modificador, usando o mesmo padrão de design para se tornar um bom cidadão Swiftui.
Essa estrutura está em desenvolvimento fortemente, é recomendável usar a versão mais recente o máximo possível (incluindo a dependência do SDWebImage).
Essa estrutura segue a versão semântica. Cada alterações da API de intervalo de origem atingirá uma versão importante.
Esse uso do projeto mantém um formato de Changelog para registrar as alterações. Verifique o Changelog.md sobre as alterações entre as versões. As alterações também serão atualizadas na página de lançamento.
Todos os relatórios de emissão, solicitações de recursos, contribuições e estrelas do Github são bem -vindos. Esperança de feedback e promoção ativos se você achar útil essa estrutura.
O iOS 14 (MacOS 11) apresenta o Swiftui 2.0, que mantém a mais compatível com a API, mas altera muitos comportamentos internos, que quebram a função do SDWebImageswiftUi.
Da v3.0.0, SdwebImageswiftlui Drop iOS 13 Suporte. Para usar no iOS 13, consulte a versão mais recente v2.x (ou usando o ramo 2.x).
Como o SDWebImage 6.0 introduzirá a base de código SWIFT/OBJC mista, este repositório migrará para o repo SDWebImage Core.
Mas não se preocupe, usaremos a sobreposição automática do módulo cruzado, o que significa que você pode usar:
import SwiftUI
import SDWebImagePara trabalhar como:
import SwiftUI
import SDWebImage
import SDWebImageSwiftUI // <-- Automatic infer this
Você vinculará automaticamente o SDWebImageSwiftUI , e a nomeação desta biblioteca ainda será preservada no SPM Target. Portanto, a transição é suave para a maioria de vocês, não quero bater outra versão importante. O 3.x é a versão final do SDWebImageswiftlui Repo dedicado
Nota: Para um usuário super avançado, se você estiver usando uma cadeia de ferramentas Swift personalizada, não deixe de passar -Xfrontend -enable-cross-import-overlays
O SDWebImageswiftlui está disponível no Swift Package Manager.
Para integração de aplicativos, você deve usar o Xcode 12 ou superior, para adicionar este pacote ao seu alvo de aplicativos. Para fazer isso, verifique a adição de dependências de pacotes ao seu aplicativo sobre o tutorial passo a passo usando o Xcode.
Para o autor da estrutura downstream, você deve criar um arquivo Package.swift no seu repositório Git e adicione a seguinte linha para marcar sua estrutura dependente de nossos sdwebimageswiftlui.
let package = Package (
dependencies : [
. package ( url : " https://github.com/SDWebImage/SDWebImageSwiftUI.git " , from : " 3.0.0 " )
] ,
) Sdwebimageswiftlui está disponível através de Cocoapods. Para instalá -lo, basta adicionar a seguinte linha ao seu PODFILE:
pod 'SDWebImageSwiftUI' Sdwebimageswiftlui está disponível através de Cartago.
github "SDWebImage/SDWebImageSwiftUI"
WebImage para carregar a imagem de rede var body : some View {
WebImage ( url : URL ( string : " https://nokiatech.github.io/heif/content/images/ski_jump_1440x960.heic " ) ) { image in
image . resizable ( ) // Control layout like SwiftUI.AsyncImage, you must use this modifier or the view will use the image bitmap size
} placeholder : {
Rectangle ( ) . foregroundColor ( . gray )
}
// Supports options and context, like `.delayPlaceholder` to show placeholder only when error
. onSuccess { image , data , cacheType in
// Success
// Note: Data exist only when queried from disk cache or network. Use `.queryMemoryData` if you really need data
}
. indicator ( . activity ) // Activity Indicator
. transition ( . fade ( duration : 0.5 ) ) // Fade Transition with duration
. scaledToFit ( )
. frame ( width : 300 , height : 300 , alignment : . center )
} NOTA: Esta WebImage usando Image para implementação interna, que é a melhor compatível para o sistema de layout e animação Swiftui. Mas, diferentemente Image de Swiftui, que não suporta imagem animada ou imagem vetorial, WebImage também suporta a imagem animada (por padrão da v2.0.0).
No entanto, a animação WebImage fornece um caso de uso comum simples, por isso ainda é recomendável usar AnimatedImage para controles avançados, como renderização progressiva de animação ou renderização de imagens vetoriais.
@ State var isAnimating : Bool = true
var body : some View {
WebImage ( url : URL ( string : " https://raw.githubusercontent.com/liyong03/YLGIFImage/master/YLGIFImageDemo/YLGIFImageDemo/joy.gif " ) , isAnimating : $isAnimating ) ) // Animation Control, supports dynamic changes
// The initial value of binding should be true
. customLoopCount ( 1 ) // Custom loop count
. playbackRate ( 2.0 ) // Playback speed rate
. playbackMode ( . bounce ) // Playback normally to the end, then reversely back to the start
// `WebImage` supports advanced control just like `AnimatedImage`, but without the progressive animation support
} NOTA: Para indicador, você também pode ser personalizado. Por exemplo, o iOS 14/WatchOS 7 apresenta o novo ProgressView , que pode ser facilmente usado via:
WebImage ( url : url )
. indicator ( . activity )Ou você pode apenas escrever como:
WebImage ( url : url )
. indicator {
Indicator { _ , _ in
ProgressView ( )
}
}AnimatedImage para reproduzir animação var body : some View {
Group {
AnimatedImage ( url : URL ( string : " https://raw.githubusercontent.com/liyong03/YLGIFImage/master/YLGIFImageDemo/YLGIFImageDemo/joy.gif " ) , placeholderImage : . init ( systemName : " photo " ) ) // Placeholder Image
// Supports options and context, like `.progressiveLoad` for progressive animation loading
. onFailure { error in
// Error
}
. resizable ( ) // Resizable like SwiftUI.Image, you must use this modifier or the view will use the image bitmap size
. indicator ( . activity ) // Activity Indicator
. transition ( . fade ) // Fade Transition
. scaledToFit ( ) // Attention to call it on AnimatedImage, but not `some View` after View Modifier (Swift Protocol Extension method is static dispatched)
// Supports SwiftUI ViewBuilder placeholder as well
AnimatedImage ( url : url ) {
Circle ( ) . foregroundColor ( . gray )
}
// Data
AnimatedImage ( data : try ! Data ( contentsOf : URL ( fileURLWithPath : " /tmp/foo.webp " ) ) )
. customLoopCount ( 1 ) // Custom loop count
. playbackRate ( 2.0 ) // Playback speed rate
// Bundle (not Asset Catalog)
AnimatedImage ( name : " animation1.gif " , isAnimating : $isAnimating ) // Animation control binding
. maxBufferSize ( . max )
. onViewUpdate { view , context in // Advanced native view coordinate
// AppKit tooltip for mouse hover
view . toolTip = " Mouseover Tip "
// UIKit advanced content mode
view . contentMode = . topLeft
// Coordinator, used for Cocoa Binding or Delegate method
let coordinator = context . coordinator
}
}
} NOTA: AnimatedImage suporta o URL da imagem ou os dados da imagem para formato de imagem animado. Que usam o ImageView animado do SDWebImage para implementação interna. Preste atenção que, desde essa base no Uikit/Appkit representável, algum sistema avançado de layout e animação Swiftui pode não funcionar conforme o esperado. Você pode precisar de Uikit/Appkit e Animação Core para modificar a visualização nativa.
Nota: AnimatedImage Alguns métodos como .transition , .indicator e .aspectRatio têm a mesma nomeação que os métodos de protocolo SwiftUI.View . Mas os args recebem o tipo diferente. Isso ocorre porque AnimatedImage suporta a serem usados com componente e animação Uikit/Appkit. Se você encontrar ambiguidade, use a declaração de tipo completo em vez da sintaxe da expressão de pontos.
Nota: Alguns dos métodos no AnimatedImage retornarão some View , um novo conteúdo modificado. Você perderá o método modificador relacionado ao tipo. Para este caso, você pode reordenar a chamada do método ou usar a visualização nativa (na verdade SDAnimatedImageView ) no .onViewUpdate , use a API UIKIT/APPKIT para resgate.
// Using UIKit components
var body : some View {
AnimatedImage ( name : " animation2.gif " )
. indicator ( SDWebImageProgressIndicator . default ) // UIKit indicator component
. transition ( SDWebImageTransition . flipFromLeft ) // UIKit animation transition
}
// Using SwiftUI components
var body : some View {
AnimatedImage ( name : " animation2.gif " )
. indicator ( Indicator . progress ) // SwiftUI indicator component
. transition ( AnyTransition . flipFromLeft ) // SwiftUI animation transition
}Por que temos dois tipos de visão diferentes aqui, é por causa do limite atual do SwiftUi. Mas nosso objetivo é fornecer a melhor solução para todos os casos de uso.
Se você não precisar de imagem animada, prefira usar WebImage primeiro. Que se comporta a visualização sem costura como Swiftui embutido. Se o Swiftui funcionar, ele funciona. Se Swiftui não funcionar, também :)
Se você precisar de uma imagem animada simples, use WebImage . Que fornecem o suporte básico de imagem animada. Mas não suporta a renderização progressiva da animação, nem a imagem vetorial, se você não se importa com isso.
Se você precisar de uma imagem animada poderosa, AnimatedImage é o que escolher. Lembre -se de que também suporta a imagem estática, você não precisa verificar o formato, basta usar como ele. Além disso, algum recurso poderoso, como cor de tonalidade Uikit/Appkit, imagem vetorial, configuração de imagem de símbolo, imagem em camadas de TvOS, disponível apenas no AnimatedImage , mas não está atualmente em Swfitui.
Mas, como AnimatedImage use UIViewRepresentable e dirigido pelo UIKIT, atualmente pode haver alguns pequenos problemas incompatíveis entre o Layout e o Sistema de Layout e Swifttui, ou Bugs relacionados ao próprio Swiftui. Tentamos o nosso melhor para combinar o comportamento swifttu e fornecemos a mesma API que WebImage , que facilita a alternância entre esses dois tipos, se necessário.
ImageManager para o seu próprio tipo de visualização O ImageManager é uma classe que está em conformidade com o protocolo ObservableObject do ObservableObject. Qual é a fonte de dados do WebImage principal que fornecemos.
Para um caso de uso avançado, como carregar a imagem no gráfico de visualização complicado que você não deseja usar WebImage . Você pode vincular diretamente seu próprio tipo de visualização com o gerente.
Parece familiar como SDWebImageManager , mas é construído para o mundo Swifttu, que fornece a fonte da verdade para o carregamento de imagens. É melhor você usar @ObservedObject do Swiftui para vincular cada instância do gerente para sua instância de visualização, que atualiza automaticamente o corpo da sua exibição quando o status da imagem foi alterado.
struct MyView : View {
@ ObservedObject var imageManager = ImageManager ( )
var body : some View {
// Your custom complicated view graph
Group {
if imageManager . image != nil {
Image ( uiImage : imageManager . image! )
} else {
Rectangle ( ) . fill ( Color . gray )
}
}
// Trigger image loading when appear
. onAppear { self . imageManager . load ( url : url ) }
// Cancel image loading when disappear
. onDisappear { self . imageManager . cancel ( ) }
}
}Essa estrutura é baseada no SDWebImage, que suporta personalização e configuração avançadas para atender à demanda de diferentes usuários.
Você pode registrar vários plugins de codificadores para formato de imagem externa. Você pode registrar vários caches (diferentes caminhos e configuração), vários carregadores (URLs de urlsession e fotos). Você pode controlar a data de expiração do cache, tamanho, download de prioridade, etc. Tudo em nosso wiki.
O melhor lugar para colocar esse código de configuração para o aplicativo Swiftui, é o AppDelegate.swift :
func application ( _ application : UIApplication , didFinishLaunchingWithOptions launchOptions : [ UIApplication . LaunchOptionsKey : Any ] ? ) -> Bool {
// Add WebP/SVG/PDF support
SDImageCodersManager . shared . addCoder ( SDImageWebPCoder . shared )
SDImageCodersManager . shared . addCoder ( SDImageAVIFCoder . shared )
SDImageCodersManager . shared . addCoder ( SDImageSVGCoder . shared )
SDImageCodersManager . shared . addCoder ( SDImagePDFCoder . shared )
// Add default HTTP header
SDWebImageDownloader . shared . setValue ( " image/webp,image/apng,image/*,*/*;q=0.8 " , forHTTPHeaderField : " Accept " )
// Add multiple caches
let cache = SDImageCache ( namespace : " tiny " )
cache . config . maxMemoryCost = 100 * 1024 * 1024 // 100MB memory
cache . config . maxDiskSize = 50 * 1024 * 1024 // 50MB disk
SDImageCachesManager . shared . addCache ( cache )
SDWebImageManager . defaultImageCache = SDImageCachesManager . shared
// Add multiple loaders with Photos Asset support
SDImageLoadersManager . shared . addLoader ( SDImagePhotosLoader . shared )
SDWebImageManager . defaultImageLoader = SDImageLoadersManager . shared
return true
}Para mais informações, é realmente recomendado verificar nossa demonstração, para aprender o uso detalhado da API. Você também pode ter uma verificação na documentação da API mais recente, para uso avançado.
Swiftui tem um comportamento conhecido (Bug?) Ao usar a visão Stateful em List/LazyStack/LazyGrid . Somente a visualização de nível superior pode conter seu próprio @State/@StateObject , mas a subestrutura perderá o estado quando rolar para fora da tela. No entanto, o WebImage/animado é de estado. Para garantir que o estado mantenha sincronizado mesmo quando role para fora da tela. Você pode usar alguns truques.
Veja mais: https://twitter.com/fatbobman/status/1572507700436807683?s=21&t=z4fkawtmvjsgl-wkdjgreq
Em suma, não é recomendável fazê -lo:
struct ContentView {
@ State var imageURLs : [ String ]
var body : some View {
List {
ForEach ( imageURLs , id : . self ) { url in
VStack {
WebImage ( url ) // The top level is `VStack`
}
}
}
}
}Em vez disso, usando esta abordagem:
struct ContentView {
struct BodyView {
@ State var url : String
var body : some View {
VStack {
WebImage ( url )
}
}
}
@ State var imageURLs : [ String ]
var body : some View {
List {
ForEach ( imageURLs , id : . self ) { url in
BodyView ( url : url )
}
}
}
} Button de Swiftui aplica a sobreposição ao seu conteúdo (exceto Text ) por padrão, esse é um erro comum para escrever código como este, que causa comportamento estranho:
// Wrong
Button ( action : {
// Clicked
} ) {
WebImage ( url : url )
}
// NavigationLink create Button implicitly
NavigationView {
NavigationLink ( destination : Text ( " Detail view here " ) ) {
WebImage ( url : url )
}
} Em vez disso, você deve substituir o .buttonStyle para usar o estilo simples ou o .renderingMode para usar o modo original. Você também pode usar o modificador .onTapGesture para manuseio de toque. Veja como desativar a cor de sobreposição para imagens dentro do botão e navegação
// Correct
Button ( action : {
// Clicked
} ) {
WebImage ( url : url )
}
. buttonStyle ( PlainButtonStyle ( ) )
// Or
NavigationView {
NavigationLink ( destination : Text ( " Detail view here " ) ) {
WebImage ( url : url )
. renderingMode ( . original )
}
} Ambos os suporte WebImage/AnimatedImage para renderizar a imagem do vetor, usando os codificadores externos SVG/PDF . No entanto, eles são diferentes internamente.
AnimatedImage : Use a tecnologia da imagem do símbolo da Apple e do desenho vetorial, suporta mudanças de tamanho dinâmico sem detalhes de perda. E usa a implementação e as APIs baseadas em Uikit/Appkit. Se você quiser, passe .context(.imageThumbnailPixelSize: size) para usar a renderização do bitmap e obter mais pixels.WebImage : desenha a imagem vetorial em uma versão de bitmap. Que assim como o PNG normal. Por padrão, usamos o tamanho do conteúdo da imagem vetorial (tamanho da tela SVG ou tamanho da caixa de mídia PDF). Se você quiser, passe .context(.imageThumbnailPixelSize: size) para obter mais pixels. Para renderização de bitmap, você também pode tingir os ícones SVG/PDF com cores personalizadas (como imagens de símbolos), usar o .renderingMode(.template) e .tint(:) ou .foregroundColor(:) Modificador, que corresponde ao comportamento SwiftUI.Image .
var body : some View {
WebImage ( url : URL ( string : " https://dev.w3.org/SVG/tools/svgweb/samples/svg-files/w3c.svg " ) )
. resizable ( )
. renderingMode ( . template )
. foregroundColor ( . red ) // or `.tint(:)`, `.accentColor(:)`
. scaledToFit ( )
} var body : some View {
AnimatedImage ( url : URL ( string : " https://dev.w3.org/SVG/tools/svgweb/samples/svg-files/w3c.svg " ) , context : [ . imageThumbnailPixelSize : CGSize ( width : 100 , height : 100 ) ] )
. resizable ( )
. renderingMode ( . template )
// seems `.foregroundColor(:)` does effect `UIView.tintColor`, use `tint(:)` or `.accentColor(:)` instead.
// Or you can use `onViewCreate(:)` to get native `SDAnimatedImageView` and set `tintColor` (AppKit use `contentTintColor`)
. tint ( . red )
. scaledToFit ( )
}Veja mais: Configurando e exibindo imagens de símbolo em sua interface
O próprio SDWebImage suporta muitos carregadores personalizados (como armazenamento de Firebase e PhotosKit), caches (como Yycache e Pincache) e codificadores (como Webp e Avif, até Lottie).
Aqui está o tutorial para configurar esses componentes externos com o ambiente Swiftui.
Você pode colocar o código de configuração dentro do seu método Swiftui App.init() .
@ main
struct MyApp : App {
init ( ) {
// Custom Firebase Storage Loader
FirebaseApp . configure ( )
SDImageLoadersManager . shared . loaders = [ FirebaseUI . StorageImageLoader . shared ]
SDWebImageManager . defaultImageLoader = SDImageLoadersManager . shared
// WebP support
SDImageCodersManager . shared . addCoder ( SDImageWebPCoder . shared )
// AVIF support
SDImageCodersManager . shared . addCoder ( SDImageAVIFCoder . shared )
}
var body : some Scene {
WindowGroup {
ContentView ( )
}
}
} Ou, se o seu aplicativo tiver uma classe complicada AppDelegate , coloque o código de configuração:
class AppDelegate : NSObject , UIApplicationDelegate {
func application ( _ application : UIApplication , didFinishLaunchingWithOptions launchOptions : [ UIApplication . LaunchOptionsKey : Any ] ? = nil ) -> Bool {
SDImageCachesManager . shared . caches = [ YYCache ( name : " default " ) ]
SDWebImageManager . defaultImageCache = SDImageCachesManager . shared
return true
}
}
@ main
struct MyApp : App {
@ UIApplicationDelegateAdaptor ( AppDelegate . self ) var appDelegate
var body : some Scene {
WindowGroup {
ContentView ( )
}
}
} Para alguns dos carregadores personalizados, você precisa criar a estrutura URL com algumas APIs especiais, para que o SDWebImage possa recuperar o contexto de outros SDKs, como:
let storageRef : StorageReference
let storageURL = NSURL . sd_URL ( with : storageRef ) as URL ?
// Or via convenience extension
let storageURL = storageRef . sd_URLRepresentation let asset : PHAsset
let photosURL = NSURL . sd_URL ( with : asset ) as URL ?
// Or via convenience extension
let photosURL = asset . sd_URLRepresentationPara alguns codificadores personalizados, você precisa solicitar a imagem com algumas opções para controlar o comportamento, como imagens vetoriais SVG/PDF. Porque Swiftui.Image ou WebImage não suporta o gráfico vetorial.
let vectorURL : URL ? // URL to SVG or PDF
WebImage ( url : vectorURL , context : [ . imageThumbnailPixelSize : CGSize ( width : 100 , height : 100 ) ] ) let lottieURL : URL ? // URL to Lottie.json
WebImage ( url : lottieURL , isAnimating : $isAnimating )Para caches, você realmente não precisa se preocupar com nada. Apenas funciona após a configuração.
Os suportes do SDWebImageswiftlui para usar quando o seu Target de aplicativo tiver uma versão de destino de implantação menor que o iOS 14/MacOS 11/TvOS 14/WatchOS 7., Que fará uma ligação fraca de Swiftui (Combinar) para permitir a redação do código com a verificação disponível no tempo de execução.
Para usar a implantação atrasada, você deve fazer as seguintes:
Adicionar -weak_framework SwiftUI -weak_framework Combine na configuração de construção Other Linker Flags do seu alvo do aplicativo. Você também pode fazer isso usando a caixa de seleção Optional Framework do Xcode, há o mesmo efeito.
Você deve notar que todas as estruturas Swiftui de terceiros também devem ter essa configuração de construção, não apenas apenas SDWebImageswiftUi. Ou ao executar no dispositivo iOS 12, ele acionará o erro DYLD de tempo de execução na inicialização.
Para a versão de destino da implantação abaixo do iOS 12.2 (a primeira versão que Swift 5 tem tempo de execução no sistema iOS), você deve alterar a versão Min Deployment Target da SDWebImagesWiftUi. Isso pode causar algum efeito colateral na otimização do compilador e desencadear avisos maciços para algumas estruturas.
No entanto, para o iOS 12.2+, você ainda pode manter a versão do MIN de implantação no iOS 14, sem avisos extras ou desempenho desacelerado para o cliente iOS 14.
Porque o Swift use a versão MIN de implantação do destino para detectar se deve vincular o Swift Runtime de aplicativo, ou o sistema embutido um ( /usr/lib/swift/libswiftCore.dylib ).
post_install do | installer |
installer . pods_project . targets . each do | target |
target . build_configurations . each do | config |
config . build_settings [ 'IPHONEOS_DEPLOYMENT_TARGET' ] = '11.0' # version you need
end
end
end Para o usuário do Cartago, você pode usar carthage update --no-build para baixar a dependência e alterar a versão de destino de implantação do projeto Xcode e criar a estrutura binária.
Para o usuário do SWIFTPM, você deve usar a dependência local (com o submódulo Git) para alterar a versão de destino da implantação.
Para o usuário do Cartago, a estrutura binária construída usará a evolução da biblioteca para suportar a implantação reversa.
Para o usuário do Cocoapods, você pode pular a validação da versão da plataforma no PodFile com:
platform :ios , '14.0' # This does not effect your App Target's deployment target version, just a hint for CocoaPodsAdicione todo o código Swiftui com a anotação disponível e a verificação de tempo de execução, como este:
// AppDelegate.swift
func application ( _ application : UIApplication , didFinishLaunchingWithOptions launchOptions : [ UIApplication . LaunchOptionsKey : Any ] ? ) -> Bool {
// ...
if #available ( iOS 14 , * ) {
window . rootViewController = UIHostingController ( rootView : ContentView ( ) )
} else {
window . rootViewController = ViewController ( )
}
// ...
}
// ViewController.swift
class ViewController : UIViewController {
var label : UILabel = UILabel ( )
override func viewDidLoad ( ) {
super . viewDidLoad ( )
view . backgroundColor = . white
view . addSubview ( label )
label . text = " Hello World iOS 12! "
label . sizeToFit ( )
label . center = view . center
}
}
// ContentView.swift
@ available ( iOS 14 . 0 , macOS 11 . 0 , tvOS 14 . 0 , watchOS 7 . 0 , * )
struct ContentView : View {
var body : some View {
Group {
Text ( " Hello World iOS 14! " )
WebImage ( url : URL ( string : " https://i.loli.net/2019/09/24/rX2RkVWeGKIuJvc.jpg " ) )
}
}
} Para executar o exemplo usando Swiftui, seguindo as etapas:
SDWebImageSwiftUI.xcworkspace , aguarde o acabamento do swiftpm baixando a dependência do teste.SDWebImageSwiftUIDemo (ou outras plataformas) Esquema e execute o aplicativo de demonstração. NOTA: O Podfile aqui é porque a história usamos Cocoapods para integrar Libs à demonstração, mas agora usamos o SPM.
Como o Swiftui tem como objetivo suportar todas as plataformas da Apple, nossa demonstração também faz isso, uma base de código, incluindo:
Dicas de demonstração:
Switch (clique com o botão direito do mouse no macOS/toque no watchOS) para alternar entre WebImage e AnimatedImage .Reload (clique com o botão direito do mouse no macOS/botão no relógio) para limpar o cache.Swipe Left (botão de menu no TVOS) para excluir um URL de imagem da lista.O SDWebImageswiftlui possui um teste de unidade para aumentar a qualidade do código. Para Swiftui, não há uma solução oficial de teste de unidade fornecida pela Apple.
No entanto, como Swiftui é um sistema de layout baseado no Estado e atribuído, existem projetos de código aberto que fornecem a solução:
.frame Modificador, valor .image Value). Usamos isso para testar AnimatedImage e WebImage . Ele também permite o inspeção do UIView/NSView nativo.Para executar o teste:
pod install no diretório raiz para instalar a dependência.SDWebImageSwiftUI.xcworkspace , aguarde o acabamento do swiftpm baixando a dependência do teste.SDWebImageSwiftUITests e comece a testar.Já configuramos o pipeline de IC, cada PR executará o caso de teste e fará o upload do relatório de teste para o CodeCov.
Além de todas as coisas acima, este projeto também pode garantir a seguinte função disponível na plataforma Swift para a própria SdWebimage.
O que significa que este projeto é um caso de uso central e dependência a jusante, que impulsionou o próprio desenvolvimento futuro da SDWebImage.
Dreampiggy
O SDWebImageswiftlui está disponível sob a licença do MIT. Consulte o arquivo de licença para obter mais informações.
