Serhii R's questions

Tenho uma tela no aplicativo iOS com NavigationStack (ou NavigationView) que contém diferentes elementos. Um deles é a Lista pesquisável, que está encapsulada no NavigationLink. Portanto, essa lista pesquisável aparece em uma nova tela.

E quando o usuário seleciona algum elemento da Lista, ele deve retornar automaticamente à tela anterior sem dois cliques adicionais nos botões Cancelar (se usar a pesquisa) e depois "Voltar".

Existe alguma maneira certa de fazer isso? Obrigado por qualquer conselho!

import SwiftUI

struct TheItem: Identifiable {
    let id = UUID()
    let name: String
}

class SomeModel: ObservableObject {
    
    @Published var selectedId: UUID?
    @Published var searchText: String = ""

    var items: [TheItem] = [
        TheItem(name:"Item 1"),
        TheItem(name:"Item 2"),
        TheItem(name:"Item 3"),
        // ...
        TheItem(name:"Item N")
    ]
    
    var filteredItems: [TheItem] {
        guard !searchText.isEmpty else { return self.items }
        return self.items.filter { item in
            item.name.lowercased().contains(self.searchText.lowercased())
        }
    }
    
    var selectedItemName: String {
        if selectedId != nil {
            return filteredItems.first(where: {$0.id == selectedId})?.name ?? "-"
        }
        return "-"
    }
    
    init () {
        selectedId = items.first?.id
    }
}

struct TestNavigationLinkBackkView: View {
    
    @EnvironmentObject private var model: SomeModel
    
    var body: some View {
        NavigationStack {
            NavigationLink(model.selectedItemName) {
                List {
                    Picker("Item", selection: $model.selectedId) {
                        ForEach(model.filteredItems) { item in
                            Text(item.name).tag(item.id)
                        }
                    }
                }
                .searchable(text: $model.searchText, placement: .navigationBarDrawer(displayMode: .always))
                .pickerStyle(.inline)
            }
        }
    }
}

#Preview {
    TestNavigationLinkBackkView()
        .environmentObject(SomeModel())
}

Eu uso o seletor segmentado no iOS, que contém poucos itens. Quando o usuário toca em um item não selecionado, este item é selecionado. Alguns itens podem conter subitens. Portanto, quando o usuário toca no tipo já selecionado, preciso mostrar a janela modal com subitens para escolher um deles. Mas os toques em itens já selecionados do seletor segmentado não estão funcionando. Tentei usar "pressão longa", mas não funcionou tão bem.

Eu gostaria de usar o design nativo do iOS, por isso não quero usar "botões" em vez do seletor segmentado.

Então a questão é como posso tocar em um item já selecionado do seletor segmentado para mostrar subitens e escolher um deles? Pode ser um “pressionamento longo” ou outra alternativa que seja intuitiva para o usuário.

import SwiftUI

struct CustomSegmentedPicker: View {
    
    @State private var showModalSelectD: Bool = false
    
    enum periods {
        case A, B, C, D, All
    }
    
    @State var predefinedPeriod: periods = periods.All
    @State var predefinedPeriodD: String = "D1"
    
    var body: some View {
        ZStack {
            Color.clear
                .sheet(isPresented: $showModalSelectD, content: {
                    List {
                        Picker("D", selection: $predefinedPeriodD) {
                            Text("D1").tag("D1")
                            Text("D2").tag("D2")
                            Text("D3").tag("D3")
                        }
                        .pickerStyle(.inline)
                    }
                })
            VStack {
                HStack {
                    Picker("Please choose a currency", selection: $predefinedPeriod) {
                        Text("A").tag(periods.A)
                        Text("B").tag(periods.B)
                        Text("C").tag(periods.C)
                        Text("D (\(predefinedPeriodD))").tag(periods.D)
                            .contentShape(Rectangle())
                            .simultaneousGesture(LongPressGesture().onEnded { _ in
                                print("Got Long Press")
                                showModalSelectD.toggle()
                            })
                            .simultaneousGesture(TapGesture().onEnded{
                                print("Got Tap")
                                showModalSelectD.toggle()
                            })
                        Text("All").tag(periods.All)
                    }
                    .pickerStyle(SegmentedPickerStyle())
                }
            }
        }
    }
}

Eu tenho o ImportDataView principal com uma lista de alguns selecionadores. Os selecionadores são semelhantes, mas preciso usar uma "seleção" diferente. Cada selecionador está em uma var separada (alguma visualização) da extensão ImportDataView. É possível usar uma visualização do seletor em vez de 3 (ou mais) e passar/vincular diferentes variáveis ​​de "seleção" (de ImportDataViewModel)?

Desde já, obrigado.

import SwiftUI

class ImportDataViewModel: ObservableObject {
   
    @Published var field1Index: Int?
    @Published var field2Index: Int?
    @Published var fieldNIndex: Int?
    
    func getFieldNamesFromCSV() -> [String] {
        return ["fieldFromFile1", "fieldFromFile2", "fieldFromFileN"]
    }
}

struct ImportDataView: View {
    
    @Environment(\.dismiss) var dismiss
    @EnvironmentObject var itVM: ImportDataViewModel
    
    var body: some View {
        NavigationView {
            List {
                HStack {
                    Text("Field 1  *")
                    Spacer()
                    chooseField1View
                }
                HStack {
                    Text("Field 2 *")
                    Spacer()
                    chooseField2View
                }
                HStack {
                    Text("Field N *")
                    Spacer()
                    chooseFieldNView
                }
            }
            .toolbar {
                ToolbarItem(placement: .cancellationAction) {
                    Button("Back", role: .cancel) {
                        dismiss()
                    }
                }
            }
        }
        
    }
}

extension ImportDataView {
    @ViewBuilder
    private var chooseField1View: some View {
        Picker(selection: $itVM.field1Index, label: EmptyView()) {
            ForEach(itVM.getFieldNamesFromCSV().indices, id: \.self) { index in
                Text(itVM.getFieldNamesFromCSV()[index]).tag(index as Int?)
            }
        }
    }
    
    @ViewBuilder
    private var chooseField2View: some View {
        Picker(selection: $itVM.field2Index, label: EmptyView()) {
            ForEach(itVM.getFieldNamesFromCSV().indices, id: \.self) { index in
                Text(itVM.getFieldNamesFromCSV()[index]).tag(index as Int?)
            }
        }
    }
    
    @ViewBuilder
    private var chooseFieldNView: some View {
        Picker(selection: $itVM.fieldNIndex, label: EmptyView()) {
            ForEach(itVM.getFieldNamesFromCSV().indices, id: \.self) { index in
                Text(itVM.getFieldNamesFromCSV()[index]).tag(index as Int?)
            }
        }
    }
}

struct ImportDataView_Previews: PreviewProvider {
    static var previews: some View {
        ImportDataView()
            .environmentObject(ImportDataViewModel())
            .preferredColorScheme(.light)
    }
}

Eu uso a variável "some View" separada para cada selecionador, mas entendo que é o caminho errado ao copiar/colar.

Espero ter apenas uma extensão "comum" var "some View" e usá-la para todos os campos de importação como este:

HStack {
   Text("Field 1  *")
   Spacer()
   chooseFieldCommonView(selectionFieldIndex: $itVM.field1Index)
}
HStack {
   Text("Field 2  *")
   Spacer()
   chooseFieldCommonView(selectionFieldIndex: $itVM.field2Index)
}
HStack {
   Text("Field N  *")
   Spacer()
   chooseFieldCommonView(selectionFieldIndex: $itVM.fieldNIndex)
}