
Learn to build a real SwiftUI app from start to finish, using VStack and HStack layouts, property wrappers, and dynamic content, including a map distance feature with a responsive ring.
Clarify course prerequisites by noting Swift proficiency, Mac with Xcode 11 or later, and optional SwiftUI familiarity; prepare learners to work with buttons and text, skipping canvas basics.
Access exercise files to code along with your SwiftUI course, using start and end state folders to follow steps and compare work with the finished state in the end folder.
Learn to build a SwiftUI layout with HStack and VStack, push a gear button to the right with spacer, and add distance evaluation text with a 300 by 300 circle.
Learn to layer views with z stacks to place a blue circle on a gray rectangle, ignore safe areas, and position the circle on top for map-based selection.
Beautify a SwiftUI button by styling a red circular icon with a plus symbol, using padding, background, and clipShape for a rounded look; plan to add the action later.
Wrap MKMapView in a swiftui view representable to create a map view for swiftui, implement makeUIView and updateUIView, and preview the result in canvas.
Add a center coordinate and annotations array to the map view, and implement a coordinator with MKMapView delegates to sync annotations and update the center from the delegate.
Explore how binding and state property wrappers drive a SwiftUI map view, enabling the center coordinate to update as you add MKPointAnnotation locations.
Explore how state and binding power data flow in SwiftUI, establishing a single source of truth and enabling two-way updates through dollar-prefixed bindings for shared coordinates and map views.
Create a distance manager as an observable object to calculate the distance between two core location points and publish the result for live updates in SwiftUI views.
Learn how the @Published property wrapper enables observable objects in SwiftUI to automatically signal changes and reload affected views, using a Location class example with observable object conformance.
Create a SwiftUI settings view featuring a bound slider for travel radius, starting at 300 with 100 km steps from 100 to 500 kilometers.
Learn to display dynamic content with ForEach in SwiftUI by binding a slider to a travel radius and rendering car icons in an HStack using a range.
Create an app icon in SwiftUI by placing a rounded rectangle filled with a red-to-pink linear gradient, then overlay a white map symbol using a ZStack.
Learn to present a settings view modally with a sheet in SwiftUI by toggling a boolean bound to isPresented, revealing and dismissing the view with a smooth transition.
Learn to dismiss a SwiftUI sheet manually by using the environment's presentationMode binding and a done button to call the dismiss function, with a top padding of about 150.
Create a generic settings defaults property wrapper that uses user defaults to persist small values by key, with a default, and implement get and set for seamless reuse.
Build an observable settings manager to persist the travel radius with a custom settings defaults wrapper, publish changes via Combine, and wire it into the SwiftUI settings view and slider.
Learn to build a SwiftUI ring by creating a ring background shape with a path, computing the center and radius, and stroking the arc with a defined thickness.
Design and animate a swiftui ring by composing a gradient-filled ring shape atop a ring background, driven by a computed percentage from user distance and travel radius.
Learn to animate a ring progress in swiftui by exposing a computed percentage via a getter/setter and using an animator pull data, creating a smooth, clockwise data animation.
Explore how SwiftUI provides out-of-the-box capabilities across iPhone, iPad, and iPod, including dark mode, dynamic type, and accessibility, with layout and padding handled automatically.
Apply your SwiftUI foundation to build apps with stacks, buttons, and text, and explore next steps with on-demand WWDC 19 sessions on state, observed object, and data.
SwiftUI is an amazing new framework. It's maybe the biggest leap in for the Apple development ecosystem since Swift was introduced in 2014. With SwiftUI you will build better apps with less code. It makes app development a lot faster, simpler and even works across all Apple platforms. SwiftUI gives you automatic support for dynamic type, darkmode, localisation and a lot more.
What this course is NOT: This course is not an introduction into Swift or Xcode. It is also not meant to be a comprehensive SwiftUI handbook.
What this course aims to do: This course wants to bring you beyond the standard tutorials of displaying some local or web based data in a list. It wants to address the questions that arise when creating an app with SwiftUI for the first time and cover topics that will enable you to understand app development with this new toolset and thus make you feel comfortable continue the journey of exploring SwiftUI on your own.
This course is going to take you through the process of creating an app step-by-step. Not only will you have finished a complete app after taking this course, you will also get profound knowledge about SwiftUI and its most important concepts like property wrappers and its connections to the Combine framework.
I am Brian Advent and I have been working as a developer and trainer, especially in the Apple ecosystem, for almost a decade now.
Build your own Apps with SwiftUI
In this course I am going to provides you with all the knowledge you need to create your own SwiftUI apps in no time. I have selected the topics, progression and features that we are going to cover in this course with great care and based it on my experiences with this new toolset since its inception. Building an app from start to finish will give you a headstart in working on your own projects with SwiftUI.
How and what you are going to learn
This course is project based which means that you will learn while working on a cool app project. Important theory will also be covered in distinct videos. In our sample project we will build a cool user interface, mix and match UIKit classes with SwiftUI, we are going to explore the most important property wrappers that are mostly responsible for the reactive magic of SwiftUI. We will also create custom shapes, animate them, store data on a device and so much more.
Among other things you are then going to learn:
Basics like VStacks, HStacks and ZStacks
Mix and match UIKit with SwiftUI
Use Property Wrappers
Create dynamic content with ForEach
Work with multiple views
Create your own shapes
Animate Shapes based on interactive data
Data persistence
...
I designed this SwiftUI course to be easily understandable for any developer who has a beginner-intermediate knowledge about the Swift programming language and the Xcode IDE.
This course comes with extensive exercise files (code files and assets) for every video, with a begin and end state of all projects. You'll be able to work alongside the instructor and will receive a verifiable certificate of completion upon finishing the course.