SwiftUI on Andrew Bancroft

SwiftUI Fundamentals

Mon, 08 Apr 2024 00:00:00 +0000

Developing for iOS is a valuable and in-demand skill, but if you haven’t developed in the Apple world before, it can be surprisingly different.

In this course, SwiftUI Fundamentals, you’ll quickly get up and running using Xcode 15, Swift, and SwiftUI to establish the foundational skills you need to build great user interfaces for iOS.

Resources

SwiftUI Fundamentals

Course Outline

First, you’ll see the tools and learn how to use SwiftUI to create single-screen applications with adaptive user interfaces that work on multiple devices.

Next, you’ll learn how to bring your own style to a SwiftUI user interface by customizing its appearance.

Finally, you’ll explore working with data-driven controls and understand navigation options for multi-screen applications.

When you’re finished with this course, you’ll know current best practices, iOS architecture, and the most important ideas you need to feel comfortable bringing your developer skills into the iOS and Apple developer world.

1 - Building Single-view Applications

Topics in this module include…

Version Check: What You Need to Get Started
The Night Watch Scenario
Creating a Single-view App
Understanding the SwiftUI Framework
Creating Xcode Previews
Understanding Views
Combining and Laying out Views
Understanding the SwiftUI Layout System
Aligning and Positioning Views

2 - Customizing UI Appearance

Topics in this module include…

Applying View Modifiers
Developing a SwiftUI Mindset
Using Icons and Symbols
Implementing Custom View Modifiers

3 - Creating Data-driven Lists

Topics in this module include…

Preparing to Work with Lists
Understanding Lists
Creating a List
Controlling a List with Data
Using Loops to Supply Content for Lists
Adding Sections and Headings
Creating Grid Layouts

4 - Building iOS Apps with Multiple Screens

Topics in this module include…

Defining Apps with Multiple Screens
Implementing Navigation Stacks
Adding Navigation to an Existing Project
Extracting Reusable Subviews
Creating a Tabbed Application
Recapping Multi-view Applications

5 - Adding Behavior and Working With Data

Topics in this module include…

Preparing to Add Basic Behavior
Extending the Data Model
Understanding the View Update Cycle in SwiftUI
Adding Basic Behavior
Connecting a Subview to a Parent View’s Data
Using Classes as Data Models
Sharing a Data Model through the SwiftUI Environment
Bringing the Data Model and Behavior to the Night Watch App

6 - Putting It All Together

Topics in this module include…

Applying What You’ve Learned
Integrating the Extended Data Model
Adding the Mark Complete Behavior
Adding a Toolbar and Toggle Control
Implementing Swipe and Move Actions for a List
Resetting the List
Showing an Alert
Adding Images to a SwiftUI Application
Continuing your iOS Developer Journey

iOS 17 Fundamentals

Sun, 10 Dec 2023 00:00:00 +0000

Developing for iOS is a valuable and in-demand skill, but it can be surprisingly different if you haven’t developed for Apple platforms before.

In this course, iOS 17 Fundamentals, you’ll quickly get up and running using Xcode 15, Swift 5, and SwiftUI to build great iOS apps and tap into the latest features of iOS 17.

Resources

iOS 17 Fundamentals

Course Outline

First, you’ll see the tools and learn the core principles for designing iOS apps with adaptive, accessible, and localized user interfaces that work on multiple devices.

Next, you’ll explore how to tackle some of the most common scenarios you’ll run into when you’re building an app for iOS 17, like performing common networking tasks, managing data, adding push notifications to your application, and implementing widgets.

Finally, you’ll learn how to take your app and publish it on the App Store. When you’re finished with this course, you’ll know current best practices, iOS architecture, and the most important ideas you need to feel comfortable bringing your app ideas to iOS 17.

1 - Preparing to Build iOS 17 Applications

Topics in this module include…

Version Check: What You Need to Get Started
How to Learn iOS Development
Introducing “Improvado” - An App for Continuous Improvement
Transitioning an App to iOS 17
Supporting Older Versions of iOS
What Every iOS 17 App Needs

2 - Designing Applications for iOS 17

Topics in this module include…

Introducing Apple’s Human Interface Guidelines
Making an Adaptive User Interface
Adding and Customizing Layout Variations
Supporting Dynamic Type
Implementing Dark Mode
Working with SFSymbols 5
Making Apps Accessible
Localizing an iOS Application

3 - Performing Common Networking Tasks

Topics in this module include…

Understanding URL Sessions
Checking Network Connectivity
Sending HTTP Requests
Requesting Data from REST APIs
Inspecting HTTP Responses
Handling Networking Errors
Organizing Networking Code
Integrating Networking Tasks with SwiftUI

4 - Managing Data

Topics in this module include…

Understanding Data Management Scenarios
Encoding and Decoding Data
Managing Preferences with UserDefaults
Synchronizing Settings with iCloud Key-value Store
Configuring Apps with Property Lists
Performing File Management Tasks

5 - Adding Push Notification Support

Topics in this module include…

Understanding Notification Scenarios
Requesting Permission to Deliver Notifications
Sending Local Notifications
Sidebar: Understanding the Delegation Design Pattern
Responding to Local Notifications
Configuring an Xcode Project for Remote Notifications
Testing Remote Notifications
Making Notifications Actionable
Sending Silent Background Notifications
Setting Up a Remote Notification Server

6 - Implementing Widgets

Topics in this module include…

Adding a Widget to an Xcode Project
Configuring a Widget
Sharing Data between an App and a Widget
Making Widgets Configurable
Creating Interactive Widgets

7 - Publishing to the App Store

Topics in this module include…

Preparing to Publish Your App
Adding an App Icon
Creating an iOS App Launch Screen
Building a Release Version of Your App
Configuring an App in App Store Connect
Submitting an App for Review

Building iOS User Interfaces with SwiftUI

Sun, 22 Aug 2021 00:00:00 +0000

Designing efficient and dynamic apps is essential for taking your iOS developer skills to the next level.

In this course, Building iOS User Interfaces with SwiftUI, you’ll build upon the basic knowledge of iOS development you’ve already gained in order to build compelling iOS apps that engage your users.

Resources

Building iOS User Interfaces with SwiftUI

Course Outline

First, you’ll see the tools and learn how to create iOS apps with adaptive user interfaces that work on multiple devices.

Next, you’ll learn how to manage iOS projects and define the building blocks of your own iOS applications.

Finally, you’ll explore working with data-driven controls and understand navigation options.

1 - Designing Interfaces with SwiftUI

In this introductory module, we begin where the iOS Getting Started course left off and prepare you to handle next-level interface building with SwiftUI.

Topics in this module include…

Preparing to Design User Interfaces with SwiftUI
The Snowhaven Renovation Scenario
Defining SwiftUI Views
Creating Basic Designs and Layouts
Representing Data in User Interfaces
Customizing the Appearance of Views
Changing the Size and Scale of Views
Adding Effects to Views
Layering Views with ZStacks
Implementing Navigation and Displaying a Modal View

2 - Handling User Input

There’s no such thing as an app without data. In this module, I set you up for building dynamic, interactive applications by unpacking questions like:

How do we model real-world objects and concepts as data that SwiftUI can work with?
How do we integrate data into an app, so it’s usable in the right views at the right time?
And how do we load data that’s been saved… display it… and, most importantly, for this module…change it using different editing controls with SwiftUI…

Topics in this module include…

Working with Data in SwiftUI
Establishing an App’s Data Flow
Loading and Displaying Data
Editing Text Data with Text Fields
Persisting (or Cancelling) Data Changes
Working with Picker Views
Switching Between Binary Options with Toggles
Editing Numeric Data with Text Fields
Displaying Editing Controls in a Form

3 - Bringing Apps to Life with Drawing, Animation, and Gestures

SwiftUI provides you with all the tools necessary to make your apps even more dynamic by responding to user gestures like taps and swipes… The framework also gives you everything you need to express your creativity by drawing your own graphics, and adding animations throughout your apps to bring things to life.

Topics in this module include…

Understanding the SwiftUI Drawing System
Drawing with Paths
Using GeometryReader
Applying Transformations to Paths
Building Reusable Shapes
Understanding Animations
Adding Basic Animation
Animating View Hierarchy Changes with Transitions
Combining Multiple Animations and Transitions
Responding to Gestures

4 - Integrating SwiftUI and UIKit

By now, you know that SwiftUI is wonderful, but… it’s not the only Apple UI framework used in today’s Apple Developer world. UIKit is still very widely used and even includes some UI components that are not currently available in the SwiftUI framework.

As we wrap up the course, I explore the answer to this question: How can we, as developers, mix SwiftUI and UIKit to leverage the power of both frameworks?

Topics in this module include…

Preparing to Integrate SwiftUI and UIKit
Representing UIKit ViewControllers in SwiftUI
Making SwiftUI Views Compatible with UIKit
Representing UIKit Views in SwiftUI
Sharing State Between SwiftUI and UIKit
Coordinating User Interaction Between UIViewControllers and SwiftUI
Coordinating User Interaction Between UIViews and SwiftUI
Applying the Finishing Touches

Feedback Welcome!

From the beginning my unwavering goal is to help you filter the noise and learn as efficiently as possible. My hope is that this course benefits you in your iOS development career!

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

iOS 14 Getting Started

Fri, 04 Dec 2020 00:00:00 +0000

Developing for iOS is a valuable and in-demand skill, but if you haven’t developed in the Apple world before, it can be surprisingly different.

In this course, iOS 14: Getting Started, you’ll quickly get up and running using Xcode 12, Swift 5, and SwiftUI to build great iOS apps and tap into the latest features in iOS 14.

Resources

iOS 14 Getting Started

Course Outline

First, you’ll see the tools and learn how to create iOS apps with adaptive user interfaces that work on multiple devices.

Next, you’ll learn how to manage iOS projects and define the building blocks of your own iOS applications.

Finally, you’ll explore working with data-driven controls and understand navigation options.

1 – Preparing to Build iOS Applications

Prepare to implement iOS apps by understanding what’s involved from a big picture standpoint.

We begin at the beginning to bring you up to speed and set the foundation for the remainder of the course.

Topics in this module include…

What You Need for Building iOS Apps
Creating an iOS Project with Xcode
Exploring an iOS Project
How to Learn iOS
The Night Watch Scenario
Working with Xcode Projects
Grasping the Basics of the Xcode Development Environment
Summary

2 - Building Single View Applications

Building single view applications is the starting point for most of us who are learning to build iOS apps because they allow us a simplified architecture that focuses on a single screen performing a single responsibility.

Topics in this module include…

Preparing to Build Single View Apps
Understanding the SwiftUI Framework
Understanding Views
Combining and Laying out Views
Understanding the SwiftUI Layout System
Aligning and Positioning Views
Customizing UI Appearance
Developing a SwiftUI Mindset
Using Icons and Symbols
Managing Views with Groups

3 - Creating Data-driven Lists

Just about any day in which you use an iPhone or iPad for more than a few minutes, you’ll almost certainly end up in an app that uses a List View.

It’s the most common way to show a structured, scrollable series of items, and List Views are a core competency for an iOS developer working in SwiftUI, so it’s the first complex control we dive into.

Topics in this module include…

Preparing to Work with Lists
Understanding Lists
Creating a List
Controlling a List with Data
Using ForEach to Supply List Content
Adding Sections and Headings

4 - Building iOS Apps with Multiple Screens

Here I cover how to create apps multiple screens and how to think about and enable navigation between them.

Topics in this module include…

Defining Apps with Multiple Screens
Implementing Navigation Views
Adding Navigation to an Existing Project
Extracting Reusable Subviews
Creating a Tabbed Application
Recapping Multi-view Applications

5 - Adding Behavior and Working With Data

The thing that makes an app come alive is the behavior we add, and the dynamic responses to that behavior that get reflected in the user interface.

In any application, a user interface has one critical job: to accurately represent the data of our application in what it displays on the screen.

In SwiftUI, data and behavior go hand-in-hand, and I cover how to respond to user interaction in this module.

Topics in this module include…

Preparing to Add Basic Behavior
Extending the Data Model
Understanding the View Update Cycle in SwiftUI
Adding Basic Behavior
Connecting a Subview to a Parent View’s Data
Using Classes as Data Models
Sharing a Data Model through the SwiftUI Environment
Bringing the Data Model and Behavior to the Night Watch App

6 - Putting It All Together

There’s nothing like practicing your skills in new contexts to refine them and solidify what you’ve learned.

We go into some additional controls and techniques for building apps with SwiftUI before concluding the course.

Topics in this module include…

Applying What You’ve Learned
Integrating the Extended Data Model
Adding the Mark Complete Behavior
Adding a Toolbar and Toggle Control
Implementing Swipe and Move Actions for a List
Resetting the List
Showing an Alert
Creating an Adaptive UI
Adding and Customizing Layout Variations
Getting Ready for the App Store

7 - Publishing to the App Store

Finishing an app and getting it out the door to your users is one of the best feelings in the world.

Beyond the emotional aspect of publishing an app though, more and more employers want to see job candidates who have published at least one app to the App Store.

So in this final module, I complete the journey by setting you up to get an app into the App Store and bolster your resume!

Topics in this module include…

Preparing to Publish Your App
Adding Images and App Icons
Responding to Dark Mode
Creating an iOS App Launch Screen
Submitting an App for Review
Continuing Your iOS Developer Journey

Feedback Welcome!

From the beginning my unwavering goal is to help you filter the noise and learn as efficiently as possible. My hope is that this course benefits you in your iOS development career!

I welcome feedback on this course, and on other iOS development courses you might be interested in seeing in the Pluralsight library. Happy learning!

What Are All of the Possible Environment Keys in SwiftUI?

Tue, 08 Sep 2020 05:11:48 +0000

This is merely a breadcrumb for finding the Apple Developer documentation page where all of the possible SwiftUI Environment keys are listed.

Resources

Apple Documentation ➡️ SwiftUI ➡️ State and Data Flow ➡️ EnvironmentValues

How to Use @FetchRequest in SwiftUI

Sat, 03 Aug 2019 03:11:48 +0000

Once you’ve passed an NSManagedObjectContext instance to your SwiftUI View, you’ll need to pull data out of your Core Data persistent store with a fetch request.

First Things First

The remainder of this how-to assumes that you’ve already got a way to initialize the Core Data stack. Ticking the ‘Use Core Data’ checkbox when you start a new app will place some boilerplate code in AppDelegate.
@Environment(\.managedobjectcontext) must be assigned before the View is initialized for @FetchRequest to work.
Code examples are taken from my “Blog Idea List” sample project that includes a single Core Data Entity named BlogIdea:

Resources

Blog Idea List SwiftUI Example Xcode Project

You can refer to my introduction to using Core Data with SwiftUI to review all of the steps in one spot. It includes an example project with all of the pieces stitched together!

Breaking Down the Code

There are three key components to this:

A way to configure an NSFetchRequest with an NSSortDescriptor added. Your app will blow up 💥 if you don’t have one added to your fetch request.
The @FetchRequest property wrapper in your SwiftUI view.
A SwiftUI View that displays the results of the executed fetch request.

The following code snippets provide you an example of how to weave all three components together.

Comments with ❇️ symbols will explain the details inline.

BlogIdea.swift

import Foundation
import CoreData

// ❇️ BlogIdea code generation is turned OFF in the xcdatamodeld file
public class BlogIdea: NSManagedObject, Identifiable {
    @NSManaged public var ideaTitle: String?
    @NSManaged public var ideaDescription: String?
}

extension BlogIdea {
    // ❇️ The @FetchRequest property wrapper in the ContentView will call this function
    static func allIdeasFetchRequest() -> NSFetchRequest<BlogIdea> {
        let request: NSFetchRequest<BlogIdea> = BlogIdea.fetchRequest() as! NSFetchRequest<BlogIdea>
        
        // ❇️ The @FetchRequest property wrapper in the ContentView requires a sort descriptor
        request.sortDescriptors = [NSSortDescriptor(key: "ideaTitle", ascending: true)]
          
        return request
    }
}

ContentView.swift

import SwiftUI

struct SwiftUIView: View {
    // ❇️ The BlogIdea class has an `allIdeasFetchRequest` static function that can be used here
    @FetchRequest(fetchRequest: BlogIdea.allIdeasFetchRequest()) var blogIdeas: FetchedResults<BlogIdea>

    var body: some View {
        List(self.blogIdeas) { blogIdea in
            Text(blogIdea.ideaTitle ?? "")
        }
    }
}

Note that you don’t actually need to hold a reference to the @Environment’s managedObjectContext.

@Environment’s managedObjectContext must be set! But you don’t have to “call” it or use it directly to make the fetch request “go”.

Where’s the Call to Perform the Fetch Request?

With most Core Data apps, you’re going to see a call to fetch(_:) somewhere in your code.

This happens “behind the scenes” when you use the @FetchRequest property wrapper in your SwiftUI view. No need to use your managed object context to perform the fetch request manually.

For a more complete guide to using Core Data with SwiftUI, you can refer to the introduction I published. It includes an example project with all of the pieces stitched together!

How to Pass NSManagedObjectContext to a SwiftUI View

Fri, 02 Aug 2019 03:11:48 +0000

Step one to using Core Data with SwiftUI is to initialize the Core Data stack and pass an instance of your NSManagedObjectContext to your view.

First Things First

The remainder of this how-to assumes that you’ve already got a way to initialize the Core Data stack. Ticking the ‘Use Core Data’ checkbox when you start a new app will place some boilerplate code in AppDelegate.
Code examples are taken from my “Blog Idea List” sample project that includes a single Core Data Entity named BlogIdea:

Resources

Blog Idea List SwiftUI Example Xcode Project

You can refer to my introduction to using Core Data with SwiftUI to review all of the steps in one spot. It includes an example project with all of the pieces stitched together!

Breaking Down the Code

There are two key components to this:

the Core Data Stack
the SwiftUI @Environment’s managedObjectContext variable.

“Passing in” your managed object context will probably happen early on in your app’s launch sequence. SceneDelegate is where I pass mine in with the Blog Idea List app.

On the receiving end is your SwiftUI View. An @Environment property wrapper needs to be set up in order to pull out the managed object context so you can use it.

The following code snippets provide you glimpses into both sides of the coin. Comments with ❇️ symbols will explain the details inline.

SceneDelegate.swift

 2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22

                     

class="lnt"> 1 language-swift" data-lang="swift">func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) { if let windowScene = scene as? UIWindowScene { let window = UIWindow(windowScene: windowScene)

// ❇️ Get the managedObjectContext from the persistent container // ❇️ This assumes you've left the Core Data stack creation code within AppDelegate let managedObjectContext = (UIApplication.shared.delegate as! AppDelegate).persistentContainer.viewContext

// ❇️ Pass it to the ContentView through the  // ❇️ managedObjectContext @Environment variable let contentView = ContentView() .environment(\.managedObjectContext, managedObjectContext)

window.rootViewController = UIHostingController(rootView: contentView)

self.window = window window.makeKeyAndVisible() } class="p">}

ContentView.swift

import SwiftUI

struct SwiftUIView: View {
    // ❇️ Access the @Environment's managedObjectContext variable
    // ❇️ and keep a reference to use later
    @Environment(\.managedObjectContext) var managedObjectContext

    var body: some View {
        // ❇️ Use self.managedObjectContext however you need within your SwiftUI view!
    }
}

For a more complete guide to using Core Data with SwiftUI, you can refer to the introduction I published. It includes an example project with all of the pieces stitched together!

Apple's SwiftUI Essentials Tutorial Series as Playgrounds

Sat, 06 Jul 2019 03:11:48 +0000

Resources

Why Playgrounds?

I’ve been making my way through Apple’s SwiftUI tutorials.

If you’re anything like me, you learn by tinkering with things. Change the modifiers, reposition Text, use a different Image, and see what happens.

BUT.

Without macOS Catalina, iterating quickly on these tinker sessions involves starting and stopping a simulator to see the changes.

#annoying, right?

However… since you can use SwiftUI in a Playground, I decided to take my learning experience out of the sample Xcode projects that Apple provides, and turn them into Playgrounds.

I’ve pushed them to GitHub, just in case they’d be useful to you.

Repository Structure

Each tutorial in the Essentials series has its own completed Playground.

Download or clone the repository to experiment with the SwiftUI tutorials individually in a Playground environment.

Run the playground, and show the live preview to see it in action.

Creating and Combining Views

All resources required for generating the SwiftUI preview have been added under the Resources folder.

Helper code for loading the JSON data file and generating images in the UI at different sizes has been placed in the Data Helpers.swift file.

Model Objects.swift contains the code for the Landmark and Coordinates types.

Handling User Input

All resources required for generating the SwiftUI preview have been added under the Resources folder.

Helper code for loading the JSON data file including the new isFavorite property, and generating images in the UI at different sizes has been placed in the Data Helpers.swift file.

Model Objects.swift contains the code for the Landmark and Coordinates types. It also adds the UserData bindable object.

Using SwiftUI in a Playground

Thu, 13 Jun 2019 04:00:18 +0000

If you’re looking for a quicker way to iterate while you’re building SwiftUI views, and you don’t have macOS Catalina installed, you might enjoy the Playground experience more than you enjoy pressing command + R every time you make a change and want to see it in the user interface.

How do you do it? Here’s a code snippet to copy-paste into a Playground to get you going.

 1import UIKit
 2import PlaygroundSupport
 3import SwiftUI
 4
 5// Make a SwiftUI view
 6struct ContentView: View {
 7    var body: some View {
 8        Text("SwiftUI in a Playground!")
 9    }
10}
11
12// Make a UIHostingController
13let viewController = UIHostingController(rootView: ContentView())
14
15// Assign it to the playground's liveView
16PlaygroundPage.current.liveView = viewController
17
18// RUN!

SwiftUI is Declarative. What Does That Mean?

Tue, 04 Jun 2019 03:11:48 +0000

“Declarative” is one of Swift UI’s four core principles.

Aside from taking for granted that declarative is just “better” than whatever else, how about a visual to understand the declarative way of thinking?

Imagine yourself in a restaurant (sit-down or fast food, whichever).

When you want a burger, which best describes what you do?

or…

Saying what you want (aka, being “declarative”) is what the most probable thing you’d do in a restaurant.

That’s exactly the recipe you use when you’re working with SwiftUI.

In Summary

Taking First Steps With SwiftUI

Mon, 03 Jun 2019 03:11:48 +0000

Resources

Tutorial Reference

Enabling SwiftUI

Opting in to using SwiftUI is as easy as creating a new project with Xcode 11 and clicking the “Use SwiftUI” checkbox.

Starting Point

Xcode will give you two structs to start with:

One that describes the View’s content and layout
One that declares a preview for that View

View

1struct ContentView: View {
2    var body: some View {
3        // This is where you describe the view's content, layout, and behavior
4    }
5}

A view’s content, layout, and behavior get described in the body property.

Preview

1struct ContentView_Previews : PreviewProvider {
2    static var previews: some View {
3        ContentView()
4    }
5}

Seeing What You’re Doing

Xcode gives you a canvas so that you can visually see what your SwiftUI code is doing.

Open it by clicking Editor > Editor and Canvas

Wait, Where’s the Canvas?

If you don’t have the option to view the canvas in Xcode, it’s because this feature requires you to be running macOS Catalina.

Don’t feel left out of the SwiftUI fun, though! Just press command + R to see everything load up in the iOS 13 Simulator.

If you’re learning, you might opt to use SwiftUI in a Playground for a more convenient workflow!

Syncing Changes Between SwiftUI Code and Xcode’s Canvas

Changing and saving your SwiftUI view code automatically updates the canvas preview.

Changing the view using Xcode’s view inspector automatically updates your SwiftUI code!

I love this quote:

Your code is always the source of truth for the view. When you use the inspector to change or remove a modifier, Xcode updates your code immediately to match.

Combining Views: The Key is Stacks

1struct ContentView: View {
2    var body: some View {
3        // This is where you describe the view's content, layout, and behavior
4    }
5}

A view’s content, layout, and behavior get described in the body property.

body only returns a single view, though.

To combine multiple views together, you use a stack.

Stacks can be vertical (VStack), horizontal (HStack), or “back-to-front” (ZStack).

Spacing Things Out

Use a Spacer to make a containing view expand out to use all of its parent view

 1struct ContentView : View {
 2    var body: some View {
 3        VStack(alignment: .leading, spacing: nil) {
 4            Text("Turtle Rock")
 5                .font(.title)
 6            
 7            HStack{
 8                Text("Joshua Tree National Park")
 9                    .font(.subheadline)
10                
11                Spacer() // Make the horizontal stack use up all the horizontal space of the parent VStack
12                
13                Text("California")
14                    .font(.subheadline)
15            }
16        }
17    }
18}

Giving Views Some Breathing Room

Use the padding() modifier to give a view some breathing room.

SwiftUI on Andrew Bancroft

SwiftUI Fundamentals

Course Outline

1 - Building Single-view Applications

2 - Customizing UI Appearance

3 - Creating Data-driven Lists

4 - Building iOS Apps with Multiple Screens

5 - Adding Behavior and Working With Data

6 - Putting It All Together

iOS 17 Fundamentals

Course Outline

1 - Preparing to Build iOS 17 Applications

2 - Designing Applications for iOS 17

3 - Performing Common Networking Tasks

4 - Managing Data

5 - Adding Push Notification Support

6 - Implementing Widgets

7 - Publishing to the App Store

Building iOS User Interfaces with SwiftUI

Course Outline

1 - Designing Interfaces with SwiftUI

2 - Handling User Input

3 - Bringing Apps to Life with Drawing, Animation, and Gestures

4 - Integrating SwiftUI and UIKit

Feedback Welcome!

iOS 14 Getting Started

Course Outline

1 – Preparing to Build iOS Applications

2 - Building Single View Applications

3 - Creating Data-driven Lists

4 - Building iOS Apps with Multiple Screens

5 - Adding Behavior and Working With Data

6 - Putting It All Together

7 - Publishing to the App Store

Feedback Welcome!

What Are All of the Possible Environment Keys in SwiftUI?

How to Use @FetchRequest in SwiftUI

First Things First

Breaking Down the Code

Where’s the Call to Perform the Fetch Request?

How to Pass NSManagedObjectContext to a SwiftUI View

First Things First

Breaking Down the Code

Apple's SwiftUI Essentials Tutorial Series as Playgrounds

Why Playgrounds?

Repository Structure

Creating and Combining Views

Building Lists and Navigation

Handling User Input

Using SwiftUI in a Playground

SwiftUI is Declarative. What Does That Mean?

In Summary

Taking First Steps With SwiftUI

Enabling SwiftUI

Starting Point

Seeing What You’re Doing

Wait, Where’s the Canvas?

Syncing Changes Between SwiftUI Code and Xcode’s Canvas

Combining Views: The Key is Stacks

Spacing Things Out

Giving Views Some Breathing Room