Forem: Samuel Owino

SwiftUI User Notifications

Samuel Owino — Tue, 07 Jun 2022 05:42:45 +0000

Push user-facing notifications to the user's device from a server or generate them locally from your app

Notifications can also toell your app to download information and update it's interface.
Notifications can display an alert, play a sound or badge the app's icons.

You can generate notifications locally from your app or remotely from a server that you manager.

Local Notifications
The app creates the notification content and specfiers a condition, like a time or location, that triggers the delivery of the notification.

Remote Notifications
Your company's server generates push notifications, and Apple Push NOtification Server (APNs) handles the delivery of those notifications tot he user's devices.

Use this framework to do the following:

Define the types of notifications that your app supports
Define any custom actions associated with your notification types.
Schedule local notifications for deliery
Process already delivered notifications
Respond to the user-selected actions.

The system makes every attempt to de;liver local and remote notifications ina timely manner, but deliervy isn't guranteed.

Topics

Essentials
Notifiaction Management
Remote notififications
Notification Requests
Notification Content
Triggers
Notification Category and User Actions
Notification Reponses
Notification Service App Extension
Entitlements

Essentials

Asking permission to use notifications

Request permission to display alert, play sound or badge the app's icon in response to a notification

Because the user might consider notification-based interactions disruptive, you must obtain permission to use them.

Explicitly Request Authorization in Context

To ask for authorization, get the shared UNUserNotificationCenter instance and call it's requestAuthorization(options:completionHandler) method.

Specify all of the interaction types that your app employs. For example, you can request authorization to display alerts, add a badge to the app icon or play sound.



let center = UNUserNotificationCenter.current()
center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
    if let error = error {
        //Handle the error here
    }

    //Enable or disable feature based on the authorization.
}

Make the request in a context that helps the user to understand why your app needs authorization.

Use Provisional Authorization to Send trial Notifications

When you explicitly ask for permission to send notifications, users must decide whether to permit or deny perimissions before they've seen a notification from your app.

Even if you carefully set the context before requesting authorization, users may not have enough information to make a decision and might reject the authorization.

Use provisional authorization to send notifications on a trial basis. Users can then evaluate the notification and decide whether to authorize them.

The system delivers provisional notifications quetly- they don't interrupt the user with a sound or banner or appear on the lock screen. Instead, they only appear in the notification center's history.
These notification also include buttons, prompting the user to keep or turn off the notification.

To request provisional authorization, add the provisional optional when requesting permission to send notifications.



let center = UNUserNotificationCenter.current()
center.requestAuthorization(options: [.a;ert, .sound, .badge, .provisional]) { granted, error in
    if let error = error {
        //Handle the error here.
    }

    //Provisional authorization granted.
}

Unlike explicitly requesting authorization, this code doesn't prompt the user for permission to receive notifications. Instead, the first time you call this method, it automcatlcally grants authorization. However, until the user either explicitly keeps or turns off the notification, the authorization status is UNAuthorizationStatus.provisional.

Customize Notifications Based on the current Authorizations

Always check your app's authorization status before scheduling local notifications.
Users can change your app's authorization settings at any time. They can also change the type of interactions allowed by your app - which may cause you to alter the number or type of notifications your app sends.

To provide the best experience for your users, call the notification center's getNotificationSettings(completionHandler) method to get the current notification settings. Then customize the notification based on these settings.



let center = UNUserNotificationCenter.current()
center.getNotificationSettings { settings in
    guard (settings.authorizationStatus == .authorized) ||
          (settings.authorizationStatus) == .provisional) else { return }

    if settings.alertSetting == .enabled {
        //Schedule an alert-only notification
    } else {
        //Schedule a notification with a badge and sound
    }

}

SwiftUI Text

Samuel Owino — Sun, 05 Jun 2022 14:46:02 +0000

A view that displays one or more lines of read only text

SwiftUI draws the text with a body font by default, you can apply a different font like title using the font() modifier.

Text("F1 Hamilton")
    .font(.caption)

Use a system font or a custom font

You can use the font() modifier to set a system or custom font.

Text("A man liveth")
    .font(.system(size: 14, weight: .light, design: .serif))

Line limit

Sets the maximum number of lines that the text can occupy on the view.

Text("Sweet are the uses of adversity which, like the toad, ugly and venomous, wears yet a precious jewel in his head")
    .lineLimit(1)

Multiline Text Allignment(alignment:)

Sets the alignment of multiple text in this view.

Text("William Shakespeare was an English playwright, poet and actor. He is widely regarded as the greatest writer in the English language and the world's greatest dramatist. He is often called England's national poet and the \"Bard of Avon\" ")
    .multilineTextAlignment(.center)

Line Spacing

Sets the amount of space between lines of text in this view.

func lineSpacing(_ lineSpacing: CGFloat) -> some View

lineSpacing is the distance between the top of one line of text and the bottom of another.

Text("FROM off a hill whose concave womb reworded
A plaintful story from a sistering vale,
My spirits to attend this double voice accorded,
And down I laid to list the sad-tuned tale;
Ere long espied a fickle maid full pale,
Tearing of papers, breaking rings a-twain,
Storming her world with sorrow's wind and rain.

Upon her head a platted hive of straw,
Which fortified her visage from the sun,
Whereon the thought might think sometime it saw
The carcass of beauty spent and done:
Time had not scythed all that youth begun,
Nor youth all quit; but, spite of heaven's fell rage,
Some beauty peep'd through lattice of sear'd age.")
    .lineSpacing(20)

SwiftUI ViewModifiers

Samuel Owino — Sat, 04 Jun 2022 07:04:52 +0000

A view modifier is a modifier that you apply to a view such as Text or Label or another modifier such as chained font() or foreground() producing a different version of the original modifier.

Protocol

protocol ViewModifier

Basic Usage

Text("Hello World!")
    .bold()
    .font(.title)
    .foregoround(.yellow)

Creating a Custom View Modifiers

1 Create a struct that conforms to the ViewModifier Protocol

struct PrimaryTitleTextModifier: ViewModifier {}

2 Compose properties and return them as a view

struct PrimaryTitleStyle: ViewModifier {
    func body(content: Content) -> some View {
        content
            .font(.title)
            .padding()
            .overlay {
                RoundedRectangle(cornerRadius: 15)
                    .stroke(lineWidth: 6)
            }
            .foregroundColor(.black)
    }
}

struct SecondaryTitleStyle: ViewModifier {
    func body(content: Content) -> some View {
        content
            .font(.title3)
            .padding()
            .overlay {
                RoundedRectangle(cornerRadius: 15)
                    .stroke(lineWidth: 6)
            }
            .foregroundColor(.gray)
    }
}

3 Define an extension to View that itself integrates the new modifier

extension View {
    func applyPrimaryTitleStyle() -> some View {
        modifier(PrimaryTitleStyle)
    }
}

4 Apply the property to any view like so...

Text("Tsavo National Park")
    .applyPrimaryTitleStyle()

SwiftUI App Life Cycle

Samuel Owino — Fri, 03 Jun 2022 16:02:24 +0000

Xcode offers two options for app life cycle when you open a new Xcode project:

UIKit AppDelegate
SwiftUI

SwiftUI

Projects created with SwiftUI option generate an AppNameApp.swift root file.
This file becomes the app's main entry point.

This file contains a struct that conforms to App protocol

@main
struct TsavoNationalParkApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

ContentView is also added to the main Window.
@main just above the struct declaration tells the system that this is the main entry point in the app.

SwiftUI WindowGroup

A scene that represents a group of identical structured windows.

struct WindowGroup<Content> where Content : View

WindowGroup is used to create a view hierarchy for the app. The hierarchy that you declare for the view's contents serves as template for each window that the view displays.

SwiftUI takes care of platform specific behaviours, for example on macOS and iPadOS, users can open more than one window from the group simulatenously. In macOS users can gather multiple windows together into a tabbed interface.

Every window created from the group maintains independent state. For example, you cannot share State or StateObjects between windows.

@main

main() initializes and runs the application.

If you preceded your app's App Protocol conformer with the @main attribute, the system calls the conformer's main() to launch the app in a system appropriate way.

@main
struct TsavoNationalParkApp: App {
    //window group - scene enclosed
}

Scene

A scene is a part of the operating system with a lifecycle managed by the system.

You create an App by combining one or more instances that conform to the Scene Protocol in the apps's body.
You can use inbuilt scenes such as WindowGroup or compose custom scenes from other scenes.

Create custom scenes by creating a struct that conforms to the scene protocol

struct PlayerSettingScene: Scene {
    var body: some Scene {
        WindowGroup{
            PlayerSettingsContentView()
        }
    }
}

A scene acts as a container for a viwe hierarchy that you want to display to the user. The system descides when and how to display the scene to the user in a way that is platform appropriate.

You can check whether a scene is active or in some other state by reading the scenePhase environment value.

struct PlayerProfileScene: Scene {

    @Environemnt(\.scenePhase) private var scenePhase 

    var bodu: some Scene {
        WindowGroup {
            PlayerProfileContentView()
        }
    }
}

The scene protocol provides scene modifiers, defined as protocol methods with default implementation, that you use to configure the scene

@main
struct PlayerProfileScene: Scene {

    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase){ newScenePhase in
            if newScenePhase == ScenePhase.background {
                //empty cache
                //perform some network calls
            }
        }
    }
}

@Environment.PresentationMode

This indicates whether a view has been presented by another view

Depreacated as of iOS 15.5
Apple recommends using isPresented and dismiss environment objects instead

struct ProfileDetailsView: View {

    @Environment(\.presentationMode) private var presentationMode

    var body: some View {
        Button("< Exit") {
            presentationMode.wrappedValue.dismiss() //Close this view
        }
    }
}

@Environment.isPresented

A Boolean value that indicated whether the view is currently presented.

Immutable.

var isPresented: Bool { get }

// Value can be read from the @Environmment property wrapper

@Environment(\.isPresented) private var isPresented

This behaves differently from onAppear() which swift ui can call multiple times such as on back navigation.

@Environment.dismiss

Use property wrapper value to get a handle on the currenct DismissAction instance on the currenct view.

Calling the instance performs the dismiss() action

Immutable

var dismiss: DismissAction { get }

struct WeaponSelectorSheet: View {

    @Environment(\.dismiss) private var dismiss

    var body: some View {
        VStack{
            Label("Select weapon")
            ...

            Button("Save and Resume Game"){
                dismiss()
            }
        }
    }
}