Swift Programming

In SwiftUI, Alert is a view, a popup that appears to the user with a title, message, and a button. Buttons were added for the user to interact with this view and we can know their option.

We can show this popup in different usage situations, such as if we want the user to confirm if they really want to exit our app.

Using an alert in SwiftUI requires the .alert modifier.

This modifier expects two parameters:

The first parameter is isPresented and expects a property of type Bool of @State which we will now create. We will give it this property, which is a boolean, and when we change the value of the property to true in the execution of our app, such as when pressing a button, the notice will appear. And the Alert will disappear when the property value is false. When the user clicks the OK button, we change the value of isPresented in this case.

Content: This is the parameter in which we must create our alert. In this case, we use an initializer that expects a title, message, primary button, and secondary button.

struct ContentView: View {
    
    @State var isPresented: Bool = false
    
    var body: some View {
        Text("Suscríbete a SwiftBeta")
            .padding()
        Button("Aceptar") {
            isPresented = true
        }
        .alert(isPresented: $isPresented, content: {
            Alert(title: Text("Suscríbete a SwiftBeta"),
                  message: Text("Cada semana sacamos nuevo video en Youtube"),
                  primaryButton: Alert.Button.default(Text("Aceptar"), action: {
                    print("El user ha pulsado el botón de Aceptar")
                  }),
                  secondaryButton: .destructive(Text("Cancelar")))
        })
    }
}

In SwiftUI, Alert is a view, a popup that appears to the user with a title, message, and a button. Buttons were added for the user to interact with this view and we can know their option.

In SwiftUI Alert is a view, a popup that appears to the user with a title, message and a button. Buttons were added for the user to interact with this view and we can know their option. We can show this popup in different usage situations, such as if we want the user to confirm if they really want to Show an alert with a single button

SwiftUI allows us to display alarms to the client with its alert() modifier, but the way it works depends on whether you’re focusing on iOS 15 and later or if you also want to support iOS 13 and 14. I’ll show you the two methodologies here; However, the latest iOS 15 methodology is ideal as it expands on the standard SwiftUI buttons.

We should first check out the method for iOS 15. To display an alarm, create a boolean expression that decides whether the alarm should be noticeable, then connect it to a ready() modifier next to each of the buttons you want to display in the warning. All buttons are ready when touched, so you can assign an empty activity to the basic excuse.

Show an alert with a single button

SwiftUI allows us to display alarms to the client with its alert() modifier, but the way it works depends on whether you’re focusing on iOS 15 and later or if you also want to support iOS 13 and 14. I’ll show you the two methodologies here; However, the latest iOS 15 methodology is ideal as it expands on the standard SwiftUI buttons.

We should first check out the method for iOS 15. To display an alert, create a boolean expression that decides whether the alarm should be noticeable, then connect it to a ready() modifier next to each of the buttons you want to display in the warning. All buttons are ready when touched, so you can assign an empty activity to the basic excuse.

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

    var body: some View {
        Button("Show Alert") {
            showingAlert = true
        }
        .alert("Important message", isPresented: $showAlert) {
            Button("OK", role: .cancel) { }
        }
    }
}

To demonstrate this, the main method is to characterize some kind of bindable condition that decides whether the alert should be evident or not. Then, at that point, you couple that to your fundamental vision, which presents the alert when its condition turns out to be valid. For example, this source code creates a display alert boolean that tracks whether the “Drink Water” message should be displayed, sets that boolean when a button is tapped, and then at that point creates and connects an alert view using that boolean for what appears when the button is touched:

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

    var body: some View {
        Button("Show Alert") {
            showingAlert = true
        }
        .alert(isPresented: $showingAlert) {
            Alert(title: Text("Important message"), message: Text("Drink Water"), dismissButton: .default(Text("Got it!")))
        }
    }
}

The second way to approach generating alerts is to link to some discretionary express that conforms to the Identifiable protocol, which will cause the alarm to be displayed every time the value of the item changes.

There are two benefits to this strategy:

You can plug in any item you want at runtime, so your alert can display quite a few different bits of information.

SwiftUI naturally opens discretion when it has esteem, so you need to be sure it exists when you need to show caution; Don’t bother checking and opening the value yourself.
For example, this shows an alert with two unique qualities depending on the chosen soccer player:

struct FootballPlayer: Identifiable {
    var id: String { name }
    let name: String
}

struct ContentView: View {
    @State private var selectedShow: FootballPlayer?

    var body: some View {
        VStack(spacing: 20) {
            Text("What is your favorite TV show?")
                .font(.headline)

            Button("Select Ronaldo") {
                selectedShow = FootballPlayer(name: "Ronaldo")
            }

            Button("Select Messi") {
                selectedShow = FootballPlayer(name: "Messi")
            }
        }
        .alert(item: $selectedShow) { show in
            Alert(title: Text(show.name), message: Text("Great choice!"), dismissButton: .cancel())
        }
    }
}

To change a navigation bar color in SwiftUI in iOS we need to apply the toolbarBackground modifier to the content view of NavigationStack.

toolbarBackground accepts 2 parameters:

ShapeStyle: The style to display as the bar background.

ToolbarPlacement: The bars to place the style in. We want to change the navigation bar color, so we will set this to .navigationBar

In this Xcode example we will set the bar background color to blue:

struct ContentView: View {
    var body: some View {
        NavigationStack {
            List {
                Text("Hello, SwiftUI!")
            }
            .navigationTitle("Navigation Title")
            .toolbarBackground(

                // 1
                .blue,
                // 2
                for: .navigationBar)
        }
    }
}

1) We set the color to blue.

2) We set .navigationBar for ToolbarPlacement to apply background color to navigation bar.

Once we move the content up the navigation bar becomes visible and the color is blue.

Background visibility

To control background visibility we use a variation of .toolbarBackground modifier which accepts Visibility instead of ShapeStyle

Take a look at this example:

struct ContentView: View {
    var body: some View {
        NavigationStack {
            List {
                Text("Hello, SwiftUI!")
            }
            .navigationTitle("Navigation Title")
            .toolbarBackground(
                .blue,
                for: .navigationBar)
            .toolbarBackground(.visible, for: .navigationBar)

        }
    }
}

To run some code routinely, maybe to make a commencement clock or comparable, you ought to utilize Clock and the onReceive() modifier.

The capacity to run some code occasionally is a significant errand in iOS development.

For instance, this code makes a timer distributer that fires consistently, refreshing a label with the ongoing time:

How to use Timer in SwiftUI

1. You make a Timer and
2. Listen to it with the .onReceive modifier.

struct ContentView: View {
    @State var startDate = Date.now
    @State var timeElapsed: Int = 0
    
    // 1
    let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()

    
    var body: some View {
        Text("Time elapsed: \(timeElapsed) sec")
            // 2
            .onReceive(timer) { firedDate in

                print("timer fired")
                // 3
                timeElapsed = Int(firedDate.timeIntervalSince(startDate))

            }
            .font(.largeTitle)
    }
}

1) We make timer utilizing Timer.publish(every: 1, on: .primary, in: .common).autoconnect().

For this situation, we believe that our clock should set off each second.
We run it on the .main run circle since we use it to refresh the UI.
Last boundary is run circle mode, you can think it as a sort of need. For UI-related stuff, you use .common run loop.
The .autoconnect() part is advising the timer to begin once we pay attention to it.

2. We pay attention to a timer utilizing the .onReceive modifier.

3 Consistently, an onReceive conclusion will set off with a terminated date boundary. We utilize this to work out the time slipped by for this situation.

It means quite a bit to utilize .primary for the runloop choice, on the grounds that our timer will refresh the UI. With respect to the .familiar mode, that permits the clock to run close by other normal occasions – for instance, assuming that the text was in a parchment view that was moving.

As may be obvious, the onReceive() conclusion gets passed in some info containing the ongoing date. In the code above we relegate that directly to currentDate, yet you could utilize it to compute how long has passed since a past date.

To make a commencement timer or stopwatch, you ought to make a state to follow how long remaining parts, then, at that point, deduct from that when the timer fires.

How to cancel Timer in SwiftUI

To cancel or stop a timer use timer.upstream.connect().cancel().

We can add a Stop button to the timer:

struct ContentView: View {
    @State var startDate = Date.now
    @State var timeElapsed: Int = 0
    
    let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()
    
    var body: some View {
        VStack {
            Text("Time elapsed: \(timeElapsed) sec")
                .onReceive(timer) { firedDate in
                    print("timer fired")
                    timeElapsed = Int(firedDate.timeIntervalSince(startDate))
                }
            Button("Stop") {

                timer.upstream.connect().cancel()
            }
        }
        .font(.largeTitle)        
    }
}

Restart a timer in SwiftUI

The best way to restart a timer is to reproduce and reconnect it.

In this example, we reproduce a timer in the Resume button’s activity.

struct ContentView: View {
    @State var startDate = Date.now
    @State var timeElapsed: Int = 0
    
    // 1
    @State var timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()

    
    var body: some View {
        VStack {
            Text("Time elapsed: \(timeElapsed) sec")
                .onReceive(timer) { firedDate in
                    print("timer fired")
                    timeElapsed = Int(firedDate.timeIntervalSince(startDate))
                }
            Button("Pause") {
                timer.upstream.connect().cancel()
            }
            Button("Resume") {
                // 2
                timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()

            }
        }
        .font(.largeTitle)
    }
}

1. We need to have the option to reproduce a timer, so we change from let to @State var
2. We add a button to reproduce a timer