Kategorien-Archiv Xcode Swift DE

Hier geht es zu einem guten Regex-Generator

Ich war selber auf der Suche nach einem solchen Generator, denn das ist schon ein rechtes Gefummel. Mit diesem Generator kann man einfach einen String in ein Regex Umwandeln. Das ist dann eine prima Grundlage um das erzeugte Regex Pattern anzupassen. Dafür verwende ich einen der zahlreichen Regex-Tester. Davon gibt es ja genug.

Bitteschön. Hier hast Du ein fertiges Sample für ein Swift UI Hamburger Menü. Das Menü lässt sich bequem mit per Slide ausblenden oder durch Tap auf das Hamburger Symbol einblenden. Lege einfach ein neues SwiftUI Projekt als Single App mit den Standardeinstellungen an. Übernimm alles einfach per Copy Paste und spiele am Projekt rum.

//
//  ContentView.swift
//  SlideMenuSwiftSample
//
//  Created by T. Stephan on 03.05.20.
//  Copyright © 2020 eCommerce - Tobias Stephan. All rights reserved.
//

import SwiftUI

struct ContentView: View {
    @State var showHamburgerMenu = false
    
    
    var body: some View {
        
        
        let drag = DragGesture()
            .onEnded {
                if $0.translation.width < -100 {
                    withAnimation {
                        self.showHamburgerMenu = false
                    }
                }
        }
        
        return NavigationView {
            GeometryReader { geometry in
                ZStack(alignment: .leading) {
                    MainView(showHamburgerMenu: self.$showHamburgerMenu)
                        .frame(width: geometry.size.width, height: geometry.size.height)
                        .offset(x: self.showHamburgerMenu ? geometry.size.width/2 : 0)
                        .disabled(self.showHamburgerMenu ? true : false)
                    
                    if self.showHamburgerMenu {
                        MenuView()
                            .frame(width: geometry.size.width/2)
                            .transition(.move(edge: .leading))
                    }
                }
                .gesture(drag)
                
            }
            .navigationBarTitle("Side Menu", displayMode: .inline)
            .navigationBarItems(leading: (
                Button(action: {
                    withAnimation {
                        self.showHamburgerMenu.toggle()
                    }
                }) {
                    Image(systemName: "line.horizontal.3")
                        .imageScale(.large)
                }
            ))
        }
        
    }
}

struct MainView: View {
    @Binding var showHamburgerMenu: Bool
    
    var body: some View {
        Button(action: {
            withAnimation {
                self.showHamburgerMenu = true
            }
        }) {
            Text("Show Menu")
        }
    }
}

struct MenuView: View {
    var body: some View {
        VStack(alignment: .leading) {
            HStack {
                Image(systemName: "person")
                    .foregroundColor(.gray)
                    .imageScale(.large)
                NavigationLink(destination: ProfileView()) {
                    Text("Profile")
                        .foregroundColor(.gray)
                        .font(.headline)
                }
            }
            .padding(.top, 100)
            HStack {
                Image(systemName: "envelope")
                    .foregroundColor(.gray)
                    .imageScale(.large)
                NavigationLink(destination: MessagesView()) {
                    Text("Messages")
                        .foregroundColor(.gray)
                        .font(.headline)
                }
            }
            .padding(.top, 30)
            HStack {
                Image(systemName: "gear")
                    .foregroundColor(.gray)
                    .imageScale(.large)
                NavigationLink(destination: SettingsView()) {
                    Text("Settings")
                        .foregroundColor(.gray)
                        .font(.headline)
                }
            }
            .padding(.top, 30)
            Spacer()
        }
        .padding()
        .frame(maxWidth: .infinity, alignment: .leading)
        .background(Color(red: 32/255, green: 32/255, blue: 32/255))
        .edgesIgnoringSafeArea(.all)
    }
}

struct SettingsView: View {
    var body: some View {
        VStack{
            Text("Settings Subview")
        }
    }
}
struct MessagesView: View {
    var body: some View {
        VStack{
            Text("Messages Subview")
        }
    }
}
struct ProfileView: View {
    var body: some View {
        VStack{
            Text("Profile Subview")
        }
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

Dieser Beitrag gilt nur den kleinen Fallstricken. Apple prüft sehr genau und das ist ja auch sinnvoll. Die App selber muss zur Prüfung mit dem In App Kauf eingereicht werden. Du legst also vor einen In App Kauf fest. Der Zugriff auf die Daten des In App Kaufs ist erst nach Freigabe durch Apple möglich. Deshalb ist es sinnvoll die Prüfvorgang leicht und eindeutig für Apple zu gestalten.

Hier die Reihenfolge, in der ich vorgehe.
Wir gehen davon aus, dass die App bereits existiert und nun durch In-Kauf-Möglichkeiten ergänzt wird.

• zuerst definiere ich die eigenen Termins of Use in den App Informationen (mehr dazu weiter unten)
• dann Anlegen des ersten In-App-Kaufs
• Lokalisierung bei der Abo-Gruppe nicht vergessen, sonst erscheint immer „Fehlende Metadaten“

Auto-Renewable Subscriptions sind eine besondere Herausforderung. Hier die Regeln mit Bespielen von Apple.

• Unter Features den In-App Kauf anlegen
• Dann alle Metadaten für den In-Kauf festlegen
• Diesen In-App-Kauf in die Prüfung geben!
• Dann eine neue Binärdatei hochladen.
• abwarten, bis der In-App Kauf „Warten auf Prüfung“
• im Status „Warten auf Prüfung“ ist der In-App-Kauf für die Sandbox verfügbar

Fallstricke:

Das folgende promotional Bild wurde abgelehnt, weil der Text schlecht lesbar ist.

Das nun folgende Bild war dann erfolgreich.

Apple fordert in der App auch einen Link für Terms & Conditions sowie die Privacy Policy. Hier ein Generator für beides.

In Deiner App muss auf die Terms of use und die Privacy Policy verlinkt werden. Zusätlich muss der Standard Apple Vertrag durch die eigenen Terms of use ersetzt werden.

Folgendes Feedback habe ich dazu von Apple bekommen. Das erhält man, wenn man es nicht richtig macht 😉

Das Testen von In-App-Käufen geht durch Anlegen eines Sandbox User-Accounts. Wenn eine Autorenewable Subscription gekauft wird, gelten für die Sandbox folgene verkürzte Laufzeiten:

Rebeloperstore ist eine fertige Bilbliothek für In-App-Käufe. Hier eine Kurzanleitung als Ergänzung zu den umfassenden Videos von Rebeloperstore.com

Den Ordner Rebeloperstore 5 dem Projekt hinzufügen.

Im Bereich In-App-Käufer unter App-Store muss der Kauf der jeweiligen App zugeordnet werden.

In der AppDelegate.swift den Eintrag RebeloperStore.start() vornehmen

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        RebeloperStore.start()
        return true
    }

Im File RebelopersotreSetup.swift die Anpassungen vornehmen.
Vor allem den App spezifischen Secret Key nicht vergessen.

//
//  RebeloperStoreSetup.swift
//  RebeloperStore5
//
//  Created by Alex Nagy on 31/07/2019.
//  Copyright © 2019 Alex Nagy. All rights reserved.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

import Foundation

extension RebeloperStore {
    
    // -----------------------------------------------------------------------------
    // First save your in-app purchase ids in App Store Connect like:
    //
    // com.yourCompany.yourApp.sufix
    //
    // ex: com.Rebeloper.RebeloperStore5Example.nonConsumable
    //     ^- Bundle Identifier                 ^- sufix
    //
    // IMPORTANT: in the Rebeloper Store code the "com.yourCompany.yourApp" part
    // is fetched from your Info.plist file Bundle Identifier.
    // To create a "RegisteredPurchase" you have to add only the sufix.
    //
    // Notes:
    // 1. In RegisteredPurchase "consumable" and "non-consumable" in-app purchases
    // are added as ".regular"
    //
    // 2. Image urls are optional. They can be:
    //  a). none -> enter an emty String: ""
    //  b). in an asset catalog -> enter the name / path of the image
    //  c). a url -> enter the url of the image; has to be https!
    //
    // Now add your purchases below usig your in-app purchase sufixes.
    
    /*static let nonConsumable = RegisteredPurchase(imageUrl: "Icon-1024", sufix: "nonConsumable", purchaseType: .regular)
    static let consumable = RegisteredPurchase(imageUrl: "Icon-1024", sufix: "consumable", purchaseType: .regular)
    static let nonRenewing = RegisteredPurchase(imageUrl: "Icon-1024", sufix: "nonRenewing", purchaseType: .nonRenewing)
    static let autoRenewableWeekly = RegisteredPurchase(imageUrl: "Icon-1024", sufix: "autoRenewableWeekly", purchaseType: .autoRenewable)
    static let autoRenewableMonthly = RegisteredPurchase(imageUrl: "Icon-1024", sufix: "autoRenewableMonthly", purchaseType: .autoRenewable)*/
    static let WW1Year10Sites = RegisteredPurchase(imageUrl: "Icon-1024", sufix: "WW1Year10Sites", purchaseType: .autoRenewable)
    
    // -----------------------------------------------------------------------------
    // Create a list of your purchases if needed.
    // This can be useful if you're displaying them in a list.
    
    static var registeredPurchases: [RegisteredPurchase] = [
     /*   nonConsumable,
        consumable,
        nonRenewing,
        autoRenewableWeekly,
        autoRenewableMonthly,*/
        WW1Year10Sites

    ]
    
    // -----------------------------------------------------------------------------
    // If you're having auto-renewable in-app purchases
    // you must provide your app specific shared secret form App Store Connect.
    
    static let inAppPurchasesSharedSecret = "hier den Secret Key eintragen"
    
    // -----------------------------------------------------------------------------
    // When set to "true" you will find detailed logs in your console
    // when you're testing your in-app purchases.
    // Very usefull for debugging! Set it to "false" to turn it off.
    
    static let shouldLogRebeloperStore = true
}

Jeder In-App-Kauf muss angelegt werden. Der erste In-App-Kauf muss zur Prüfung übermittelt werden. Später können weitere ergänzt werden.

Wenn die In-App-Kauf den Status „Warten auf Prüfung“ erhält, dann gilt es halt abzuwarten. Die Prüfung des In-App-Kaufs geschieht unabhängig von der Prüfung der App. Mein Vorgehen ist das veröffentlichen der App ohne weitere In-App-Käufe. Danach definiere ich diese und warte die Prüfung ab. Dann werden die einzelnen in der RebelopestoreSetup eingetragen. Im Status Bereit zur Übermittlung sind die ProductIDs auch schon aus dem XCode Projekt abrufbar.

    static var registeredPurchases: [RegisteredPurchase] = [
        autoRenewableYearly,
        autoRenewSixmonth
    ]

Diese Methode Lädt die In App Purchases in eine eigene Liste, die wiederum mit dem List SwiftUI gelistet werden kann.

   func loadinapppurchases(){
        // MARK:- Populate with in-app purchases
        self.ListOfInAppPurchases.removeAll()
        
        RebeloperStore.inAppPurchases.observeNext { (inAppPurchases) in
            
            //            self.ListOfInAppPurchases.append(contentsOf: inAppPurchases)
            
            
        }
        .dispose(in: RebeloperStore.inAppPurchases.bag)
        
        var iIndex = -1
        for obj in RebeloperStore.registeredPurchases {
            RebeloperStore.getInfo(obj.sufix) { (product) in
                guard let product = product,
                    let _ = product.localizedPrice else { return }
                iIndex += 1
                let oInAppPurchase = InAppPurchase(id: product.productIdentifier, imageUrl: obj.imageUrl, registeredPurchase: RebeloperStore.registeredPurchases[iIndex] , title: product.localizedTitle, description: product.localizedDescription, price: product.localizedPrice!)
                self.ListOfInAppPurchases.append(oInAppPurchase)
            }
            
        }
    }

Um ein Podfile zu erstellen öffnen wir zuerst ein Terminal Fenster.

Man befindet sich ohnehin nach dem Öffnen des Terminalfensters im persönlichen User Verzeichnis. Wechsele nun in den Projektordner Deines XCode Projects. Das kannst Du auch ganz einfach bewerkstelligen, indem Du zu allererst im Terminalfenster mit dem Befehl CD beginnst und dann in XCode auf den Projektnamen klickst, und per Drag & Drop den Namen in das Terminalfenster ziehst.

…nun den Befehl:

pod init

eingeben und mit Return abschliessen.

Das war es, Dein Podfile ist nun angelegt. Wenn Du Dich nicht im richtigen Verzeichnis befunden hast, erhältst Du eine entsprechende Fehlermeldung, dann solltest Du den Pfad überprüfen.

Wenn das erfolgreich war, führe den Befehl

pod install

im selben Ordner aus.

Nach ebenfalls erfolgreichem Installationsverlauf, wurde eine Workspace-Datei erstellt.

Wir erhalten den Hinweis das Projekt künftig über die Appname.xcworkspace Datei zu öffnen.

Das wars!

Um ein Podfile zu bearbeiten, gib in Deinem Terminalfenster folgenden Befehl ein:

open -a TextEdit Podfile

Ich habe nun zum ersten mal den Picker unter SwiftUI verwendet. Einfache Erkenntnis – das OS entscheidet, welche Erscheinung Dein Picker annimmt. Natürlich kannst Du das auch selber entscheiden. Nun hatte ich aber das seltsame verhalten, dass bei der Auswahl eines Eintrags von 5 Pickern, alle Picker durchlaufen wurden. Meine Picker sind in in einer Form. Um da Form ein NavigationView. Lösung des Problems war die Section. Dieses Beispiel ist für Copy-Paste nicht geeignet, weil Dir die Datenquelle fehlt. Das soll lediglich der Veranschaulichung dienen.

import SwiftUI

struct ContentView: View {
    @State public var selectedCrossSection = 0
    @State private var selectedColor = 0
    @State private var selectedLength = 0
    @State private var selectedEyelet1 = 0
    @State private var selectedEyelet2 = 0

    var selCrossSectionStr = ""

    @ObservedObject var oListDatasource = ListDataSource()
    var body: some View {

        NavigationView{


            VStack (spacing: 10) {
                Form {
                    Section {
                        Picker(selection: self.$selectedCrossSection, label: Text("Querschnitt")) {

                            ForEach(self.oListDatasource.CrossSections, id: \.self) { item in
                                Text(item.CrossSection).tag(item.rowIndex)
                            }
                        }
                            //.pickerStyle(SegmentedPickerStyle()).foregroundColor(Color.orange)

                            .font(Font.custom("ArialMT", size: 12))
                            .onReceive([self.selectedCrossSection].publisher.first()) { (value) in
                                print(self.oListDatasource.CrossSections[self.selectedCrossSection].CrossSection)

                        }
                    }
                    Section {
                        Picker(selection: self.$selectedColor, label: Text("Farbe")) {

                            ForEach(self.oListDatasource.Colors) { item in
                                Text(item.Color).tag(item.rowIndex)
                            }
                        }
                            //.pickerStyle(SegmentedPickerStyle()).foregroundColor(Color.orange)
                            .font(Font.custom("ArialMT", size: 12))
                    }

                    Section {
                        Picker(selection: self.$selectedLength, label: Text("Länge")) {

                            ForEach(self.oListDatasource.Lengths) { item in
                                Text(item.Length).tag(item.rowIndex)
                            }
                        }
                        .font(Font.custom("ArialMT", size: 12))
                    }

                Section {
                    Picker(selection: $selectedEyelet1, label: Text("Öse 1")) {

                        ForEach(oListDatasource.Eyelets) { item in
                            Text(item.Eyelet).tag(item.rowIndex)
                        }
                    }
                    .font(Font.custom("ArialMT", size: 12))
                }
                Section {
                    Picker(selection: $selectedEyelet2, label: Text("Öse 2")) {

                        ForEach(oListDatasource.Eyelets) { item in
                            Text(item.Eyelet).tag(item.rowIndex)
                        }
                    }
                    .font(Font.custom("ArialMT", size: 12))
                }
                }

            NavigationLink(destination: ListItems(selectedCrossSection: selectedCrossSection)) {
                Text("Liste").frame(width: 100)

            }
            }


            .navigationBarTitle("Kabelshop")

        }


    }
}

Hier die Verfügbaren Styles

• Navigation view style.
• Wheel picker.
• Segmented picker.
• Date picker style.

Hier ein Beispiel für das SwiftUI Picker Element

struct ContentView: View {
    var strengths = ["Mild", "Medium", "Reif"]

    @State private var selectedStrength = 0

    var body: some View {
        NavigationView {
            Form {
                Section {
                    Picker(selection: $selectedStrength, label: Text("Sorte")) {
                        ForEach(0 ..< strengths.count) {
                            Text(self.strengths[$0])

                        }
                    }
                }
            }.navigationBarTitle("Wähle Deine bevorzugte Käsesorte")

        }
    }
}

So bentutz man die Zwischenablage aus dem Code. Das auslesen der Zwischenablage ist jedoch nur möglich, wenn sich die App im Vordergrund befindet.

// write to clipboard
UIPasteboard.general.string = "Hello world"

// read from clipboard
let content = UIPasteboard.general.string

Meine App habe ich nun auch als Mac OS App veröffentlichen wollen. Das geht ja nun mittlerweile. Bei der Prüfung ist die App jedoch abgelehnt worden, weil keine Hilfe hinterlegt und beim Klick auf das Help Menu kein Hilfetext angezeigt wurde. Mit folgender Ergänzung habe ich einfach die überflüssigen Menüpunkte entfernt.

//Insert in AppDelegate.swift
override func buildMenu(with builder: UIMenuBuilder) {
        super.buildMenu(with: builder)
        /* Do something */
        builder.remove(menu: .view)
        builder.remove(menu: .format)
        builder.remove(menu: .edit)
        builder.remove(menu: .file)
        builder.remove(menu: .window)
        builder.remove(menu: .help)
}