VoiceOver é um leitor de tela baseado em gestos, que faz com que pessoas consigam interagir com a interface gráfica sem ter que ver a tela. Pessoas com baixa visão e cegas dependem do VoiceOver para ter um feedback auditivo enquanto utilizam os dispositivos com iOS.

O VoiceOver por padrão já é ativo nos aplicativos da App Store sem a necessidade de modificações pelo desenvolvedor, entretanto existem boas práticas que podem facilitar uso do VoiceOver e melhorar a experiência de pessoas que usam esse recurso dentro do seu aplicativo.

Para melhorar a experiência do usuário quando estiver utilizando o VoiceOver é importante utilizar a feature do Xcode chamada accessibility inspector onde é possível visualizar valores de uma view como: Label, Value, Trait/Role, Default Action e Custom Action, uma boa prática é sempre escrever bem o Label e também se forem valores de dinheiro sempre utilizar sifrão nos valores do Value.

Caso queira aprender mais sobre o assunto, selecionamos alguns recursos que podem ser úteis na sua jornada de aprendizado

Acessibilidade em SwiftUI — Mais que o básico:

https://developer.apple.com/videos/play/wwdc2021/10119/

Design — Human Interface Guidelines — VoiceOver:

https://developer.apple.com/design/human-interface-guidelines/accessibility#VoiceOver

Ative e treine o VoiceOver no iPhone:

https://support.apple.com/pt-br/guide/iphone/iph3e2e415f/ios

Melhore a experiência do VoiceOver no seu App:

https://developer.apple.com/news/?id=v56qu1b3

Artigo — Melhores práticas para implementar Voice Over:

https://medium.com/capital-one-tech/ios-accessibility-best-practices-for-the-voiceover-user-experience-dc08112ef16

Vídeo — Tutorial básico de VoiceOver e Opções avançadas:

https://www.youtube.com/watch?v=UK-oZerWyjc

Vídeo — Como pessoas cegas usam tecnologia:

https://www.youtube.com/watch?v=tTg8QT4NjvA

Como Criar Experiências Espaciais Acessíveis:

https://developer.apple.com/videos/play/wwdc2023/10034

Créditos:

Emily Yukari Morimoto

Henrique Kenzo Higa

Lucas Zanatta Baggiotto

Marina Scabello Martin

Vinicius Serpa Pansan

VoiceOver: O que é e passos para implementar no seu app! was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.

• O que é?

É uma tecnologia tátil que transmite feedback a partir de vibrações, toque e force feedback, trazendo mais sensações ao usuário. Possibilita que a pessoa tenha uma experiência “real” a partir do objeto virtual, permitindo a percepção de coisas como, peso, pressão e textura do item digital.

• Como implementar em um código?

Existe um modificador chamado sensoryFeedback() que permite a utilização de alguns haptics simples, que podem criar vibrações para o feedback tátil de algumas ações. Um exemplo é a utilização do modificador em um botão de confirmação, fazendo o iphone vibrar ao concluir a ação:

struct ContentView: View {
  @State private var taskIsComplete = false

  var body: some View {
    Button ("Mark Complete") {
      taskIsComplete = true
    }
    .sensoryFeedback(success, trigger: taskIsComplete)
  }
}

Há algumas formas de transmitir o feedback a partir de suas vibrações no código, como:

Há algumas formas de transmitir o feedback a partir de suas vibrações no código, como:

UIImpactFeedbackGenerator() : gera um feedback a partir de um toque do usuário.

• Dentro de UIImpactFeedbackGenerator() existem as opções de .light, .medium e .heavy, para definir a intensidade do feedback

UINotificationFeedbackGenerator(): feedback gerado a partir de uma notificação ou alerta recebido.

• Dentro de UINotificationFeedbackGenerator() existem as opções de .success, .warning e .error, para definir o tipo da vibração

UISelectionFeedbackGenerate(): ao selecionar um ícone, gera um feedback

• Como alterar a sensibilidade do Haptic feedback?

Abra Configurações > Acessibilidade > Toque > Haptic Touch > Selecione Rápido ou Lento.

Recursos:

• How to add haptic effects using sensory feedback
• What Are Haptics? Meaning, Types, and Importance
• Adding Hapict Feedback in SwiftUI
• Delivering Rich App Experiences with Haptics
• Como alterar sensibilidade do Haptic Touch

Créditos:

Emily Yukari Morimoto

Henrique Kenzo Higa

Lucas Zanatta Baggiotto

Marina Scabello Martin

Vinicius Serpa Pansan

Haptics: O que é e passos para implementar no seu app! was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.

Primeiramente o que é um GeoJSON? É um tipo de arquivo derivado do JSON(JavaScript Object Notation), desenvolvido para agrupar dados geoespaciais em um padrão aberto. Um GeoJSON suporta alguns tipos de geometrias, quando se trata de como as coordenadas serão apresentadas:

• Point
• LineString
• Polygon
• MultiPoint
• MultiLineString
• MultiPolygon

Este é um exemplo de um GeoJSON, nesse caso ele mostra os pontos da pista de Interlagos — SP:

{
"type": "FeatureCollection",
"name": "br-1940",
"bbox": [ -46.700536, -23.706404, -46.694033, -23.696978 ],                                                                        
"features": [
{ "type": "Feature", "properties": { "id": "br-1940", "Location": "Sao Paulo", "Name": "Autódromo José Carlos Pace - Interlagos", "opened": 1940, "firstgp": 1973, "length": 4309, "altitude": 765 }, "bbox": [ -46.700536, -23.706404, -46.694033, -23.696978 ], "geometry": { "type": "LineString", "coordinates": [ [ -46.699905, -23.703744 ], [ -46.699329, -23.705785 ], [ -46.699268, -23.706 ], [ -46.699207, -23.706124 ], [ -46.699069, -23.706312 ], [ -46.698998, -23.706365 ], [ -46.698896, -23.706403 ], [ -46.698795, -23.706404 ], [ -46.698684, -23.706383 ], [ -46.698626, -23.706355 ], [ -46.698446, -23.706203 ], [ -46.698271, -23.706025 ], [ -46.698202, -23.705978 ], [ -46.698112, -23.705949 ], [ -46.698021, -23.705944 ], [ -46.697889, -23.705983 ], [ -46.697609, -23.70614 ], [ -46.697387, -23.706224 ], [ -46.697222, -23.706263 ], [ -46.697071, -23.706281 ], [ -46.696933, -23.706288 ], [ -46.69673, -23.706266 ], [ -46.696575, -23.706235 ], [ -46.696384, -23.706172 ], [ -46.696205, -23.706077 ], [ -46.696028, -23.70595 ], [ -46.695885, -23.705812 ], [ -46.695772, -23.705665 ], [ -46.695688, -23.705527 ], [ -46.695618, -23.705372 ], [ -46.695344, -23.704543 ], [ -46.695228, -23.704127 ], [ -46.69503, -23.703421 ], [ -46.694788, -23.702519 ], [ -46.694363, -23.701041 ], [ -46.69421, -23.700508 ], [ -46.694102, -23.700134 ], [ -46.694052, -23.69996 ], [ -46.694033, -23.69985 ], [ -46.694045, -23.699747 ], [ -46.694073, -23.699677 ], [ -46.694134, -23.699594 ], [ -46.694244, -23.699524 ], [ -46.694372, -23.699475 ], [ -46.694557, -23.69944 ], [ -46.69511, -23.69934 ], [ -46.695326, -23.699318 ], [ -46.69546, -23.699327 ], [ -46.695624, -23.699348 ], [ -46.695779, -23.69939 ], [ -46.695916, -23.699464 ], [ -46.696046, -23.699534 ], [ -46.696176, -23.699632 ], [ -46.696301, -23.699759 ], [ -46.696472, -23.699958 ], [ -46.697034, -23.700653 ], [ -46.697364, -23.701081 ], [ -46.697645, -23.701447 ], [ -46.697953, -23.701817 ], [ -46.698115, -23.702023 ], [ -46.69824, -23.702178 ], [ -46.698327, -23.702266 ], [ -46.698424, -23.702321 ], [ -46.698562, -23.702366 ], [ -46.698714, -23.702384 ], [ -46.698942, -23.702379 ], [ -46.699094, -23.702356 ], [ -46.699215, -23.702321 ], [ -46.699323, -23.702276 ], [ -46.699508, -23.702184 ], [ -46.6996, -23.702109 ], [ -46.699661, -23.702035 ], [ -46.69972, -23.701928 ], [ -46.699765, -23.701783 ], [ -46.699821, -23.701569 ], [ -46.699867, -23.701373 ], [ -46.699929, -23.701013 ], [ -46.699941, -23.700864 ], [ -46.699938, -23.700713 ], [ -46.699899, -23.700598 ], [ -46.699836, -23.70054 ], [ -46.699792, -23.700519 ], [ -46.699737, -23.700502 ], [ -46.699662, -23.700494 ], [ -46.699583, -23.700512 ], [ -46.6995, -23.700542 ], [ -46.699276, -23.700698 ], [ -46.699186, -23.700747 ], [ -46.699116, -23.700774 ], [ -46.699041, -23.700788 ], [ -46.698972, -23.700793 ], [ -46.698896, -23.700784 ], [ -46.698792, -23.700749 ], [ -46.698669, -23.700656 ], [ -46.6986, -23.700562 ], [ -46.698563, -23.700459 ], [ -46.698557, -23.700371 ], [ -46.698572, -23.700269 ], [ -46.698614, -23.700189 ], [ -46.69871, -23.70006 ], [ -46.698797, -23.69998 ], [ -46.699104, -23.699705 ], [ -46.699262, -23.699539 ], [ -46.699371, -23.699391 ], [ -46.69945, -23.699193 ], [ -46.699511, -23.698947 ], [ -46.699539, -23.698798 ], [ -46.699554, -23.698664 ], [ -46.699544, -23.698554 ], [ -46.699497, -23.698479 ], [ -46.699458, -23.698434 ], [ -46.699395, -23.698415 ], [ -46.699343, -23.698403 ], [ -46.699276, -23.698413 ], [ -46.699198, -23.698442 ], [ -46.698823, -23.698833 ], [ -46.698499, -23.699161 ], [ -46.698443, -23.699203 ], [ -46.698322, -23.69928 ], [ -46.698211, -23.699325 ], [ -46.698119, -23.69935 ], [ -46.698006, -23.699367 ], [ -46.697901, -23.699378 ], [ -46.69778, -23.699379 ], [ -46.69759, -23.699354 ], [ -46.697445, -23.699311 ], [ -46.697291, -23.69923 ], [ -46.697135, -23.699114 ], [ -46.697048, -23.699009 ], [ -46.696955, -23.698891 ], [ -46.696706, -23.698532 ], [ -46.696431, -23.69811 ], [ -46.69612, -23.697649 ], [ -46.6961, -23.697595 ], [ -46.696095, -23.697531 ], [ -46.696114, -23.697468 ], [ -46.69615, -23.6974 ], [ -46.696219, -23.697341 ], [ -46.696382, -23.697263 ], [ -46.696619, -23.697184 ], [ -46.6971, -23.697018 ], [ -46.697194, -23.696995 ], [ -46.697314, -23.696978 ], [ -46.697556, -23.697002 ], [ -46.697768, -23.697035 ], [ -46.698232, -23.697126 ], [ -46.698386, -23.697174 ], [ -46.698692, -23.697291 ], [ -46.698843, -23.697352 ], [ -46.699203, -23.69753 ], [ -46.699346, -23.697619 ], [ -46.699468, -23.697719 ], [ -46.699592, -23.697824 ], [ -46.699693, -23.697933 ], [ -46.699783, -23.698061 ], [ -46.699865, -23.698224 ], [ -46.699931, -23.698398 ], [ -46.700035, -23.698753 ], [ -46.700148, -23.6992 ], [ -46.700223, -23.699621 ], [ -46.700352, -23.70007 ], [ -46.700435, -23.700408 ], [ -46.700507, -23.700642 ], [ -46.700531, -23.700812 ], [ -46.700536, -23.701043 ], [ -46.700522, -23.701317 ], [ -46.700489, -23.701522 ], [ -46.700433, -23.701761 ], [ -46.700336, -23.702105 ], [ -46.700053, -23.703195 ], [ -46.699905, -23.703744 ] ] } }
]
}

Para informações mais detalhadas sobre a estrutura e funcionamento de um GeoJSON deixo aqui o link para outro artigo:

O que é e como funciona o GeoJSON.

Agora iremos utilizar ele em nosso aplicativo, queremos pegar essas coordenadas, criar uma PolyLine e mostra-lá em nosso mapa, nesse exemplo estarei utilizando UIKit, no entanto o decoder pode ser utilizado em SwiftUI também.

O primeiro passo é criar um decoder para o GeoJSON, para que o nosso aplicativo possa ler e interpretar ele.

Vamos nomear a função de loadGeoJSON, ela irá receber uma String com o nome do arquivo que foi salvo no Xcode e irá nos retornar um overlay, que é a nossa MKPolyline.

Obs: não esqueça de importar o MapKit em seu projeto!

 func loadGeoJSON(filePath: String) -> [MKOverlay]? {
        do {
            let data = try Data(contentsOf: URL(fileURLWithPath: filePath))
            let geoJSON = try MKGeoJSONDecoder().decode(data)
            let overlays = geoJSON.compactMap { $0 as MKGeoJSONObject }.flatMap { geoJSONObject -> [MKOverlay] in
                if let feature = geoJSONObject as? MKGeoJSONFeature, let geometry = feature.geometry.first {
                    if let polyline = geometry as? MKPolyline {
                        return [polyline]
                    }
                }
                return []
            }
            return overlays
        } catch {
            print("Error loading GeoJSON: \(error)")
            return nil
        }
    }

Caso tenha algum problema na hora de decodificar o GeoJSON, o código irá imprimir uma mensagem de erro e a função irá retornar vazia.

Veja que nesse caso o código está desenvolvido para utilizar da geometria de MultiLineString e criar um MKPolyLine, no entanto podem ser utilizadas outras geometrias compatíveis com GeoJSON, necessitando de poucas alterações.

Após isso, precisamos chamar a função em nosso código, aqui vai um exemplo de como podemos fazer isso, utilizando o GeoJSON de Interlagos.

let routeManager = RouteManager(mapView: nil)

        if let overlays = routeManager.loadGeoJSON(filePath: Bundle.main.path(forResource: "Interlagos", ofType: "geojson")!) {
            routes.addGeoJSONRoute(name: "Interlagos", overlays: overlays)
        }

Nesse caso, o código pega as informações do GeoJSON e já salva diretamente na minha classe routes, que recebe os atributos de todas as minhas rotas.

Dentro da classe Routes, vamos criar a função que irá adicionar na tela a rota criada a partir da PolyLine fornecida pelo GeoJSON.

Vamos nomea-la como addGeoJSONRoute, ela irá receber o nome da rota e a overlay que é do tipo MKOverlay.

 func addGeoJSONRoute(name: String, overlays: [MKOverlay]) {
        var points: [RoutePoint] = []
        for overlay in overlays {
            if let polyline = overlay as? MKPolyline {
                for i in 0..<polyline.pointCount {
                    let coordinate = polyline.points()[i].coordinate
                    let routePoint = RoutePoint(coordinate: coordinate, timestamp: Date())
                    points.append(routePoint)
                }
            }
        }
        addRoute(name: name, points: points)
    }

E dessa maneira, fazendo as adaptações para adicionar na sua ViewController, já podemos ter a rota do GeoJSON em nosso mapa.

Para efetivamente criar a rota no mapa, utilizo de uma extension que funciona como um Delegate para a minha MapView.

extension MapViewComponent: MKMapViewDelegate {
    func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
        if let polyline = overlay as? MKPolyline {
            let renderer = MKPolylineRenderer(polyline: polyline)
            renderer.strokeColor = .blue
            renderer.lineWidth = 4
            return renderer
        }
        return MKOverlayRenderer(overlay: overlay)
    }
}

Com apenas algumas linhas de código você agora pode ler e decodificar diferentes tipos de GeoJSONs e integrá-los em seus projetos de maneira eficiente. Experimente implementar esses conceitos em seus projetos e aproveite todas as funcionalidades que o GeoJSON oferece.

Como traçar uma rota em Swift a partir de um GeoJSON was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.

Neste artigo, vamos falar sobre como editar um áudio de algumas formas diferentes, como adicionando um equalizador, alterando seu volume e seu tom, usando o framework AVFoundation (AV representa Audio e Video). Não vamos comentar aqui sobre como gravar e armazenar o áudio dentro do dispositivo do usuário, portanto já assumimos que o código consegue gravar e reproduzir o áudio gravado em um AVAudioPlayerNode.

Como alterar o volume de um player de áudio

Primeiro, vamos criar os players de áudio para alterar seu volume posteriormente.

var player1: AVAudioPlayerNode = AVAudioPlayerNode()
var player2: AVAudioPlayerNode = AVAudioPlayerNode()
var player3: AVAudioPlayerNode = AVAudioPlayerNode()
var player4: AVAudioPlayerNode = AVAudioPlayerNode()

Para alterar o volume do player, somente é necessário alterar o atributo volume do AVAudioPlayerNode.
Para isso, criamos uma função que recebe o volume desejado e a referência de qual player que deve ter seu volume alterado. Nesse caso, foi criado um enum que checa qual áudio foi selecionado, porém, se o seu código apenas possui um player, você apenas precisa receber o volume de parâmetro na função.

func changeVolume(volume: Float, track: AudioEnum){
    if tracksRecorded[track] == true{
        
        switch track.numero{
        case 0:
            player1.volume = volume
            
        case 1:
            player2.volume = volume
            
        case 2:
            player3.volume = volume
            
        case 3:
            player4.volume = volume
            
        default:
            player1.volume = volume
            
        }
    }
}

Na nossa View, criamos um array que armazena os valores dos volumes dos áudios.

Também criamos um Slider personalizado para alterar o volume, porém um Slider padrão também pode ser usado aqui.

@State var volume: [Float] = [1,1,1,1]

//Esse slider serve para alterar o volume do primeiro áudio
iPhoneVolumeSlider(volume: $volume[0])
      .onChange(of: volume[0])
  {
      recordController.changeVolume(volume: volume[0],track: .audio1)
  }

Como alterar o pitch de um player de áudio

Primeiro precisamos criar um AVAudioUnitTimePitch. Como nesse código queremos alterar o pitch de todos os quatro áudios, vou criar quatro AVAudioUnitTimePitch diferentes.

var pitchControl1: AVAudioUnitTimePitch = AVAudioUnitTimePitch()
var pitchControl2: AVAudioUnitTimePitch = AVAudioUnitTimePitch()
var pitchControl3: AVAudioUnitTimePitch = AVAudioUnitTimePitch()
var pitchControl4: AVAudioUnitTimePitch = AVAudioUnitTimePitch()

Para ter o pitch funcionando, precisamos criar duas coisas antes, uma AVAudioEngine e um AVAudioMixerNode, que vão servir para gerenciar todos os efeitos de áudio diferentes que vão ser adicionados aos players. Aqui está o código usado para criar elas.

var mixer: AVAudioMixerNode = AVAudioMixerNode()
var engine: AVAudioEngine = AVAudioEngine()

func startEngine(){
    //Conecta o mixer na engine
    engine.attach(mixer)
    
    //Conecta o nodo de origem (mixer) com o de saida (engine.outputNode), se o formato for nulo ele pega o formato do arquivo de entrada
    engine.connect(mixer, to: engine.outputNode, format: nil)

    //A engine deve ser inicializada antes dos nodos, se houver algum erro uma mensagem de erro vai ser printada
    do{
        try engine.start()
    }
    catch {
        print("Error initializing engine")
    }
    
}

Agora, antes de alterar o valor do pitch diretamente, precisamos adicionar os pitchControls que criamos na engine e conectar elas com o player e o mixer que também criamos.

Antes de reproduzirmos o áudio, precisamos ter o seguinte bloco de código. Nesse caso já foi adicionado o equalizador, pois todos os componentes precisam estar conectados para o App não crashar.

var mixer: AVAudioMixerNode = AVAudioMixerNode()
var engine: AVAudioEngine = AVAudioEngine()


engine.attach(player1)
engine.attach(equalizer1)
engine.attach(pitchControl1)
//Conecta o Player no Equalizer
//Mesmo que ainda não tenhamos o equalizador criado, precisamos considerar que quando ele for criado
//ele já esteja adicionado na ordem a seguir
engine.connect(player1, to: equalizer1, format: nil)
engine.connect(equalizer1, to: pitchControl1, format: nil)
engine.connect(pitchControl1, to: mixer, format: nil)

Por último, vamos criar uma função para alterar o pitch de todos os audios.

func changePitch(pitch: Float){
    pitchControl1.pitch = pitch
    pitchControl2.pitch = pitch
    pitchControl3.pitch = pitch
    pitchControl4.pitch = pitch
}

Como criar um equalizador de áudio

Como fizemos no pitch, precisamos criar quatro equalizadores diferentes do tipo AVAudioUnitEQ, pois cada um vai ser atrelado a um player na hora de conectar eles na engine.

var equalizer1 : AVAudioUnitEQ = AVAudioUnitEQ()
var equalizer2 : AVAudioUnitEQ = AVAudioUnitEQ()
var equalizer3 : AVAudioUnitEQ = AVAudioUnitEQ()
var equalizer4 : AVAudioUnitEQ = AVAudioUnitEQ()

Precisamos inicializar esse equalizador com algumas configurações padrões antes de podermos conectar ele na engine e alterar seus valores.

IMPORTANTE: Antigamente no código, eu tinha as funções de inicializar o equalizador na função de gravar áudio, porém, ao fazer isso o código demora mais para ser executado e o gravador perdia alguns milissegundos de gravação.
Eu fortemente recomendo colocar o código abaixo na função de parar a gravação, pois não haverá nenhuma perda para o usuário.

//Como nesse código queremos alterar o Bass (Baixo) e o Treble (Agudo) do som,
//colocamos algumas configurações iniciais de cada um deles.
func createEqualizer(audioEqualizer: AVAudioUnitEQ) {
    audioEqualizer.bypass = false
    
    let bass = audioEqualizer.bands[0]
    bass.filterType = .lowShelf
    bass.frequency = 55
    bass.bandwidth = 0.71
    bass.bypass = false
    
    let treble = audioEqualizer.bands[1]
    treble.filterType = .highShelf
    treble.frequency = 5800
    treble.bandwidth = 0.64
    treble.bypass = false
    
}

//Essa função foi recortada para mostrar apenas o equalizador
public func stopRecording(track: AudioEnum) {
        
    //Adiciona o equalizador no array a medida que a pessoa grava
    let audioEqualizer = AVAudioUnitEQ(numberOfBands: 2)
    
    //Inicializa o equalizador
    createEqualizer(audioEqualizer: audioEqualizer)
    
    switch track.numero{
    case 0:
        print("Gravando audio 1")
        equalizer1 = audioEqualizer
    case 1:
        print("Gravando audio 2")
        equalizer2 = audioEqualizer
    case 2:
        print("Gravando audio 3")
        
        equalizer3 = audioEqualizer
    case 3:
        print("Gravando audio 4")
        
        equalizer4 = audioEqualizer
    default:
        print("Error when recording in switch case")
    }
    
}

Agora, vamos repetir o código usado no pitch, para conectar o equalizador na engine.

engine.attach(player1)
engine.attach(equalizer1)
engine.attach(pitchControl1)
//Conecta o Player no Equalizer
engine.connect(player1, to: equalizer1, format: nil)
engine.connect(equalizer1, to: pitchControl1, format: nil)
engine.connect(pitchControl1, to: mixer, format: nil)

Para alterar os valores do Bass (Baixo) e do Treble (Agudo), vamos criar uma função que seleciona eles e altera seu gain (o que precisamos alterar em cada um).

//Funcao pra mudar o gain do Treble
func changeTreble(gain: Float, track: AudioEnum){
    if tracksRecorded[track] == true{
        
        switch track.numero{
        case 0:
            let treble1 = equalizer1.bands[1]
            treble1.gain = gain
        case 1:
            let treble2 = equalizer2.bands[1]
            treble2.gain = gain
        case 2:
            let treble3 = equalizer3.bands[1]
            treble3.gain = gain
        case 3:
            let treble4 = equalizer4.bands[1]
            treble4.gain = gain
        default:
            let treble1 = equalizer1.bands[1]
            treble1.gain = gain
        }
        
    }
}

//Funcao pra mudar o gain do Bass
func changeBass(gain: Float, track: AudioEnum){
    if tracksRecorded[track] == true{
        
        switch track.numero{
        case 0:
            let bass1 = equalizer1.bands[0]
            bass1.gain = gain
        case 1:
            let bass2 = equalizer2.bands[0]
            bass2.gain = gain
        case 2:
            let bass3 = equalizer3.bands[0]
            bass3.gain = gain
        case 3:
            let bass4 = equalizer4.bands[0]
            bass4.gain = gain
        default:
            let bass1 = equalizer1.bands[0]
            bass1.gain = gain
        }
    }
}

Espero que este Medium tenha ensinado você a respeito de algumas funcionalidades do AVFoundation, e que você consiga aplicar o que aprendeu em seu código.

Como alterar volume, pitch e criar um equalizador de áudio usando AVFoundation was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.

Anteriormente, escrevi um artigo discutindo os básicos de Swift Data. Você pode ver esse artigo clicando no link:

Introdução ao SwiftData

Se você já viu alguma coisa sobre SwiftData, já deve ter percebido que para cada vez que você precisa usar uma função, é preciso reescreve-la em todas as Views que forem utiliza-la. Isso acaba deixando o código muito poluído e extenso.

Nesse artigo vou mostrar como deixar o código mais limpo e enxuto, sem perder nenhuma funcionalidade do SwiftData. Abaixo tem uma pequena prévia de como vai ficar no final.

Mesmo que queira tentar deixar a função em um arquivo separado, ela não vai funcionar, já que essas funções que usam SwiftData precisam estar em uma View.

E como vamos resolver isso?

Bem, podemos usar uma classe que conforme com o protocolo ObservableObject. Ou seja, vamos fazer uma ViewModel para poder componentizar a declaração e chamada de funções do SwiftData.

Sem mais enrolações. Vamos começar.

Primeiro, vamos criar um novo arquivo e chamá-lo de ViewModel. Só para contexto, estou utilizando o mesmo código que utilizei para fazer o outro artigo.

Legal, já temos a nossa ViewModel. Agora, vamos pegar todas aquelas funções que criamos anteriormente e colocar aqui dentro.

Quando fizer isso, vai notar que terão erros. Esses erros acontecem porque o context não foi declarado em nenhum lugar para que pudesse ser utilizado.

Vamos resolver isso da seguinte forma: Colocaremos o context como parâmetro nas funções, assim é possível utilizar essas funções.

Só esclarecendo que, context é do tipo ModelContext. Então a nova classe ficaria assim:

Ótimo! Já temos a nossa ViewController. Agora só precisamos configurar para que possamos utilizá-la no aplicativo.

Para isso, vamos até o arquivo <nome do projeto>App e adicionar o macro @StateObject e declarar como valor a ViewModel que criamos mais cedo, não esquecendo que precisamos também passar essa ViewModel no arquivo principal do aplicativo.

Adicionando tudo, o seu arquivo App deve ficar semelhante a isso:

Agora, se você for no(s) arquivos do seu app, reparará que tem alguns erros em todos os lugares que alguma das funções que utilizava foi chamada. Isso acontece por dois motivos: O primeiro porque não está sendo colocado o context como um parâmetro; o segundo porque a ViewModel não foi declarada na View em que está sendo utilizada essas funções.

Com os erros corrigidos, o arquivo deve ficar mais ou menos assim:

Se observar, na linha 7, declarei uma variável @EnviromentObjec chamada vm que é do tipo ViewController. E então, toda vez que preciso usar uma função do SwiftData, utilizo vm para chama-la.

E voilà, temos agora um aplicativo utilizando SwiftData totalmente componentizado.

Agora é com você! Crie e explore as novas possibilidades que você tem. Se quiser o código atualizado, o link está aqui em baixo:

GitHub - RaphaelIniesta/SwiftDataDemo

Keep Coding e até a próxima! Tchau, tchau!

Aprofundando em SwiftData was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.

Neste artigo será mostrado como utilizar SwiftData sem depender do SwiftUI em seu código. Desta maneira, por exemplo, projetos em UIKit poderão usufruir das vantagens sem necessariamente ter que utilizar CoreData para isso. O único requisito é que o dispositivo alvo tem que possuir a versão do sistema operacional superior ou igual a estas iOS 17.0+, iPadOS 17.0+, macOS 14.0+, Mac Catalyst 17.0+, tvOS 17.0+, watchOS 10.0+ e visionOS 1.0+.

O SwiftData é uma framework criada pela Apple com o propósito de salvar dados de maneira persistente no dispositivo de maneira fácil e intuitiva. Dessa forma, a framework utiliza código na linguagem moderna e permite fáceis integrações, como, por exemplo com o iCloud (CloudKit).

Em primeiro lugar é importante ressaltar que este código possui uma básica implementação de um fetch e insert, mas também é possível fazer outras operações de maneira semelhante. Neste exemplo é necessário considerar que exista uma classe (Account) que será guardada e um Enum (CustomError) que será utilizado para indicar erro em result.

*OBS: É possível implementar de outras maneiras, com @escaping e DispatchQueue.main, por exemplo*

  class DataController {
      
      @MainActor
      public var container: ModelContainer = {
          let schema = Schema([
              Account.self,
          ])
          let modelConfiguration = ModelConfiguration(schema: schema, isStoredInMemoryOnly: false, cloudKitDatabase: .none)
  
          do {
              return try ModelContainer(for: schema, configurations: [modelConfiguration])
          } catch {
              fatalError("Failed to create ModelContainer: \(error)")
          }
      }()
      
      @MainActor
      public func insertAccount(_ account: Account) {
          self.container.mainContext.insert(account)
      }
  
      @MainActor
      public func getAccounts() -> Result<[Account], CustomError> {
          do {
              let descriptor: FetchDescriptor<Account> = FetchDescriptor<Account>()
              let accounts: [Account] = try self.container.mainContext.fetch(descriptor)
              return .success(accounts)
          }
          catch {
              return .failure(.fetchError)
          }
      }
  
  }

No código foi utilizado o @MainActor em cada função, isto porque é um requisito para funcionar com o SwiftData e para indicar que a função deve ser utilizada na fila principal de maneira assíncrona. Dessa forma, ao chamá-la será preciso tratá-la corretamente, por exemplo, com o uso da estrutura Task.

@MainActor
    public var container: ModelContainer = {
        let schema = Schema([
            Account.self,
        ])
        let modelConfiguration = ModelConfiguration(schema: schema, isStoredInMemoryOnly: false, cloudKitDatabase: .none)

        do {
            return try ModelContainer(for: schema, configurations: [modelConfiguration])
        } catch {
            fatalError("Failed to create ModelContainer: \(error)")
        }
    }()

Essa parte do código, a variável container é inicializada com um bloco que define o esquema do modelo, especifica a configuração do modelo e tenta criar uma instância de ModelContainer. O ModelContainer é o responsável por gerenciar os objetos salvos e suas interações no SwiftData.

O esquema do modelo representa uma estrutura “Schema” que mapeia classes para dados no armazenamento e ajuda na migração desses dados entre versões.

A configuração do modelo é definida pelo esquema e algumas outras propriedades, por exemplo: “isStoredInMemoryOnly : false” para indicar se os dados salvos não serão salvos permanentemente e “cloudKitDatabase: .none” para não utilizar no CloudKit.

Após a declaração do esquema e configuração do modelo é necessário instancia-lo com a utilização de um bloco “do/catch” para tratamento de erros.

@MainActor
    public func insertAccount(_ account: Account) {
        self.container.mainContext.insert(account)
    }

Nesse trecho de código é uma função que insere um modelo dentro do container persistente. Note que, .mainContext refere-se a uma propriedade de instância projetado para operar na fila principal de execução, então caso a operação seja muito pesada e possa atrapalhar na experiência do usuário, talvez uma opção melhor seja criar e operar em um backgroundContext.

@MainActor
    public func getAccounts() -> Result<[Account], CustomError> {
        do {
            let descriptor: FetchDescriptor<Account> = FetchDescriptor<Account>()
            let accounts: [Account] = try self.container.mainContext.fetch(descriptor)
            return .success(accounts)
        }
        catch {
            return .failure(.fetchError)
        }
    }

Na função getAccounts, é usado um bloco de “do/catch” para realizar a busca no container já que temos uma operação que pode resultar em um crash, erro que interrompe a execução do programa. Para realizar a operação é necessário ter um FetchDescriptor, uma estrutura responsável por “filtrar” quais resultados devem serem buscados. Nesse caso, nenhum parâmetro é passado, assim ela retornará todos os elementos de um determinado tipo, Account nesse caso.

Referências

• SwiftData | Apple Developer Documentation
• MainActor | Apple Developer Documentation
• Task | Apple Developer Documentation
• Schema | Apple Developer Documentation

Swift Data com UIKit was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.

1. Criar Collection View

private let colectionView: UICollectionView = {
        let layout = UICollectionViewFlowLayout()
        layout.scrollDirection = .vertical
        
        let colectionView = UICollectionView(frame: .zero, collectionViewLayout: layout)
        
        colectionView.backgroundColor = .clear
        
        colectionView.register(CollectionViewCell.self, forCellWithReuseIdentifier: CollectionViewCell.identifier)
        colectionView.translatesAutoresizingMaskIntoConstraints = false
        
        return colectionView
}()

Aqui você já deve decidir alguns fatores da sua collection, como a direção do scroll, no meu caso a vertical e a o cor de fundo do conjunto.
CollectionViewCell → View de cada célula da collection, o item que vamos customizar.

2. Criar um arquivo separado para View da sua célula customizada

class CollectionViewCell: UICollectionViewCell {

 static let identifier = "ActivityCell"
}

Aqui o identifier serve como o nome dessa configuração da célula.

2.1 Criar função para receber todos as variáveis da célula e iniciar as Constraints

func configData(title: String, description: String) {
        self.activityLabel.text = title
        self.descriptionLabel.text = description
               
        setConstraints()
}

Para tornar o tutorial mais simples eu vou trabalhar apenas com as variáveis de título e descrição da célula e estas tem que ser iniciadas junto com a célula.

2.2 Criar um função de Reuse da célula

Para usar o scroll e garantir que as células não serão sempre iguais, é necessário reiniciar as células com valores vazios, o código abaixo cumpre essa função. Caso você esteja trabalhando com cores ou outras variáveis, é necessário resetá-las nesta parte do código.

override func prepareForReuse() {
        super.prepareForReuse()
        
        self.background.backgroundColor = nil
        self.activityLabel.text = nil
        self.descriptionLabel.text = nil
        self.dateLabel.text = nil
}

3. Criar um Data Source para a Collection

Sua Collection precisa de um Data Source, este que carrega as configurações da sua Collection View. O trecho de código completo do DataSource se encontra abaixo, e será dividido em trechos para uma explicação mais detalhada de cada uma de suas partes.

class ActivityCollectionDataSource: NSObject, UICollectionViewDataSource {
    private var activities: [String]
    private var title: [String]
    
    init(activities: [String], title: [String]) {
        self.activities = activities
        self.title = title
    }
    
    func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        return activities.count
    }
    
    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: CollectionViewCell.identifier, for: indexPath) as? CollectionViewCell
        else{
            fatalError("Failed to dequeue")
        }
        
        cell.configData(title: activities[indexPath.row], description: activities[indexPath.row])
        
        return cell
    }
}

Para declarar e inicializar as variáveis da célula, você deve utilizar o trecho de código abaixo.

private var activities: [String]
private var title: [String]
    
init(activities: [String], title: [String]) {
   self.activities = activities
   self.title = title
}

A função abaixo vai realizar a contagem das células diferentes que devem ser dispostas na Collection.

func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
   guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: CollectionViewCell.identifier, for: indexPath) as? CollectionViewCell
   else{
       fatalError("Failed to dequeue")
   }
        
   cell.configData(title: activities[indexPath.row], description: activities[indexPath.row])
        
   return cell
}

No trecho acima, a criação da célula é feita apartir da saída da mesma da fila (dequeue). Caso algo de errado aconteça, o FatalError acaba sendo ativado e o aplicativo crasha.
Como no meu aplicativo a CollectionView é essecial, isso foi o que mais fez sentido para a minha aplicação, mas caso ache necessário, você pode implementar um tratamento de erro.

Após o dequeue a configuração da célula é chamada e os parâmetros da mesma são passados pela linha (row) em que ela se encontra.

4. Criar um Delegate

import UIKit
import Foundation

class CollectionViewDelegate: NSObject, UICollectionViewDelegate, UICollectionViewDelegateFlowLayout {
    
    func collectionView(_ collectionView: UICollectionView, didDeselectItemAt indexPath: IndexPath) {
        //
    }
    
    func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, minimumLineSpacingForSectionAt section: Int) -> CGFloat {
        return 20
    }
    
    func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexpath: IndexPath) -> CGSize {
        return CGSize(width: UIScreen.main.bounds.width, height: 121)
    }
    
}

O Delegate acima serve, principalmente para criar o FlowLayoult das células.

• minimumLineSpacingForSectionAt — Trata da distância entre as células
• sizeForItemAt — Trata do tamanho da célula

5. Configurações finais

agora só falta chamar o Delegate e o DataSorce para a ViewController onde a Collection View vai aparecer.

5.1 Criar as variáveis

var collectionViewDelegate: CollectionViewDelegate = CollectionViewDelegate()
var collectionViewDataSource: UICollectionViewDataSource?

5.2 Inicializar na ViewDidLoad

é na chamada do DataSource que você deve chamar onde a informação que vai na célula está armazenada, aqui eu chamei de activitiesTest só para con firmar que a célula funcionava.

collectionViewDataSource = ActivityCollectionDataSource(activities: activitiesTest, title: activitiesTest)

colectionView.delegate = collectionViewDelegate
colectionView.dataSource = collectionViewDataSource

E esse foi o tutorial, espero que ele possa ter ajudado você com a implementação da sua Collection View!

Criando uma CollectionView com células customizadas (UIKit) was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.

Você já baixou um aplicativo em que nada parecia conversar visualmente? Pois é, criar um app que tenha uma identidade visual coesa é de extrema importância para que o usuário não tenha essa sensação ao utilizar em seu aplicativo.

Não existe bem uma forma ou ordem correta de se criar uma identidade visual para o seu app, mas para te ajudar com os primeiros passos, vou explicar um pouco do meu processo. Espero que ajude!

1- Quais são suas referências?

Saber em que sua identidade se baseará, facilita muito na hora de escolher a tipografia, as cores, as ilustrações, entre outros. Por isso, recomendo que você comece montando um moodboard, com referências, em que você colocará imagens, texto e amostras de objetos que tenham a ver com o público-alvo e que conversem entre si.

Com o moodboard feito você já terá uma base de qual estilo visual seu app irá seguir, se é Clean/minimalista, Fun, Retro/Vintage, Illustrative, entre muitos outros.

2- Quais cores você irá utilizar?

Seguindo seu moodboard, defina sua paleta de cores, pensando em como elas serão aplicadas no Light e no Dark Mode, lembrando sempre de escolher cores contrastantes.

É bom fazer uma paleta que te possibilitará fazer todas as aplicações necessárias. No meu caso, costumo escolher as cores primárias e depois vou adicionando as variações dela.

3- Qual tipografia irá usar?

Escolher uma tipografia pode ser difícil, mas é uma tarefa muito importante e vale a pena gastar um pouco de tempo dando atenção a ela.
Saber o que você quer transmitir com seu app ajuda muito nessa escolha. Com o auxílio do seu moodboard, observe as sensações transmitidas e procure tipografias correspondentes a elas. Por exemplo, estilos como Clean/minimalista costumam ter fontes simples, com boa legibilidade e pouca complexidade gráfica, como glifos ou fontes cursivas.

4- Elementos gráficos

Me arrisco em dizer que essa é umas das partes mais importantes da identidade, pois são os elementos gráficos que capturam o olhar. Por isso, crie apenas elementos essenciais para o app, afinal, queremos criar algo agradável e não visualmente sobrecarregado.
Aqui está um exemplo de um app em que usei um elemento gráfico para compor a tela a partir do próprio ícone:

Essas foram minhas dicas de hoje, realmente espero que ajude você a começar o seu projeto. Lembrando que o jeito certo de criar uma identidade é a forma como funciona melhor para você. Com calma e dedicação, tenho certeza de que encontrará o seu método. Espero que tenha gostado da dica e até logo!

Você já baixou um aplicativo em que nada parecia conversar visualmente? was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.

Em minha carreira como desenvolvedora eu tinha apenas experiência com SwiftUI. Logo, quando me vi em um projeto em Swift com UIkit em Viewcode, me deparei com um padrão de construção de layout um pouco peculiar para mim. Tive bastante dificuldade em entender a lógica de layout dessa linguagem, porque me deparei com as constraints e confesso que fiquei um pouco desesperada no início. Entretanto, usei tanto elas que desenvolvi um certo carinho e por isso resolvi criar esse Medium com o intuito de desvendar o básico delas e ensiná-las.

No UIKit, as constraints (ou restrições) são regras usadas para definir a posição e o tamanho de elementos de interface de usuário de forma declarativa e flexível. Elas fazem parte do Auto Layout, um sistema que permite criar layouts dinâmicos que se adaptam a diferentes tamanhos de tela e orientações de dispositivos iOS. Sendo assim, com o uso das constraints é possível que a visualização de elementos se ajuste a qualquer alteração de tamanho de tela sem que seja necessário colocar as informações manualmente.

Nesse sentido, o primeiro passo a se fazer é colocar translatesAutoresizingMaskIntoConstraints igual a false, logo você "autoriza" a criação de ajustes de tamanho no contexto usado.

Com o exemplo a seguir, vemos o básico das constraints.

Lembre-se, a construção das constraints deve ser legível e compreensível, um ponto que você precisa saber é que a ultima linha é necessária para ativar as constrains para seu layout.

Você pode colocar as constraints de acordo com sua view ou colocar elas de acordo com algum outro contexto, sendo eles: imagens, labels ou outros parâmetros…

Agora vamos entender alguns tipos de constraints:

• TopAnchor: refere-se a parte superior do item que você deseja modificar.
• LeadingAnchor: refere-se o lado no qual se inicia a leitura.
• BottomAnchor: refere-se ao lado inferior do contexto no qual você quer colocar o ajuste de visualização.
• TrailingAnchor: refere-se ao lado no qual se encerra a leitura.
• Center: refere-se ao centro, sendo necessário definir o eixo em que está trabalhando, podendo ser X ou Y, e respectivamente usar centerXAnchor ou centerYAnchor.

Agora que você sabe para que servem as constrains e em qual contexto você deve usá-la, vai ficar muito mais fácil alterar os tamanhos do seu layout em UIKit. Agora é com você, espero ter ajudado e até uma próxima!

Como usar as constraints em Swift? was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.

Para esse tutorial usarei como exemplo o conteúdo sobre a Bíblia do thiagobodruk disponível no GitHub.

📌 Para ter acesso aos arquivos que serão usados, abra o link abaixo: https://github.com/thiagobodruk/bible/tree/master/json

1. Em primeiro lugar, você deve fazer download do arquivo que você deseja, em XML ou JSON, escolhendo a linguagem e a versão desejada da bíblia.

2. Em segundo lugar, você deverá colocar no seu Xcode o arquivo JSON ou XML baixado.

3. Agora, iremos criar uma estrutura que conversará com o arquivo JSON:

▶️ Crie um arquivo chamado BookModel.

import Foundation

struct BookModel: Codable {
    let abbrev: String
    let chapters: [[String]]
    let name: String
}

abbrev: Livros bíblicos abreviados (“Gn” -> Gênesis).

chapters: Capítulos bíblicos, sendo um Array com os versículos.

name: Nome dos livros bíblicos.

4. Em seguida iremos realizar um Decode para uma estrutura que aceite os dados do JSON:

▶️ Crie um arquivo chamado BibleController.

import Foundation

class BibleController {
    
    var booksAA: [BookModel] = []
    
    func fetchAA() {
        do {
            if let path = Bundle.main.path(forResource: "pt_aa", ofType: "json"),
               let jsonData = try String(contentsOfFile: path).data(using: .utf8) {
                
                let books = try JSONDecoder().decode([BookModel].self, from: jsonData)
                self.booksAA = books
            }
        } catch {
            print("Error fetching data: \(error)")
        }
    }
}

Veja a seguir o passo a passo do código:

1. Crie uma variável para conversar com o BookModel.
2. Faça uma função de fetchAA.
3. Não esqueça de colocar o nome do arquivo corretamente e o seu tipo.

Consumir arquivos XML ou JSON em Swift sem o uso de uma API pode parecer uma tarefa desafiadora, mas com um pouco de conhecimento e prática, você perceberá que é mais simples do que parece.

Espero que este tutorial tenha sido útil e que você se sinta mais confiante para enfrentar desafios semelhantes no futuro.

Good Code!

Como consumir arquivos XML ou JSON em Swift? was originally published in Apple Developer Academy | Mackenzie on Medium, where people are continuing the conversation by highlighting and responding to this story.