SwiftUI Masterclass 2025 – iOS App Development & SwiftData

Hiking is a fun and enjoyable outdoor activity for friends and families! In this tutorial, we will develop a creative card design for a fictional hiking app using the SwiftUI framework. You know, the main goal of this iOS project is to show you how to put together different layout containers by creating a quite complex design.

Data-driven iOS app development with Apple's new SwiftData framework.

Learn how to develop and iOS 18 application with the SwiftData framework.

Advanced iOS App Design with Apple's SwiftUI Framework.

Learn how to create a complex Pinch and Zoom feature with SwiftUI gestures by developing this fun and engaging mobile app. The primary learning goal of this short and engaging iOS project is to get familiar with almost every SwiftUI gesture.

We will learn how to implement a long-press gesture, a double-tap gesture, a sophisticated drag gesture, and finally, a magnification gesture.

But not only that, we will cover how to use SwiftUI Materials and SF Symbols as well.

Learn how to develop a modern iOS application with SwiftUI framework in Xcode from scratch.

Learn how to develop a complex iOS app layout with SwiftUI's grid system in Xcode using Swift programming language.

Learn how to develop quickly an e-commerce mobile application and create an outstanding prototype with the SwiftUI framework using Xcode editor.

This SwiftUI project will teach you how Core Data and the SwiftUI framework integration works in a real-world example. Since Xcode editor is shipped with a brand new core data file template therefore it is worth knowing how to get started.

In this SwiftUI tutorial, we're going to develop a standalone Notes application with the SwiftUI framework for Apple Watch.

What are the main learning objectives in a nutshell?

1. First, we will get familiar with watchOS's input interfaces such as dictation, scribbling, adding emojis, and even typing from a phone to the watch.

2. Second, we are going to save data permanently on the watch. Then we will decode and fetch this data. To do the serialization operations, we will use the Codable protocol.

3. Besides developing all the basic functionalities for this Apple Watch app, we will also make a slick UI design across the whole application.

4. Finally, we are willing to go the extra mile by adding some additional pages to this watchOS app with some awesomeness and an extra feature.

By the end of this section, you will get a full-featured Apple Watch application that could be a good fit in your professional app portfolio. If this is something you want to develop, then let's open Xcode and start coding along with me!

Learn how to create a modern iOS app with SwiftUI framework in Xcode. Core topics: Horizontal scroll view, haptic feedbacks, playing sounds.

Hands-on SwiftUI tutorials with real projects.

Learn how to create a multiplatform app for iPhone, iPad, and macOS devices using the SwiftUI framework.

Learn how to develop a to-do application and store data permanently using Core Data and SwiftUI frameworks in Xcode.

In this advanced SwiftUI tutorial, we will learn how to create a custom swipe motion with gestures.

There are only two technical requirements for this SwiftUI Masterclass course:

1. macOS from Apple (free - available in the App Store)

2. Xcode from Apple (free - available in the App Store)

Personal Prerequisites:

• Willing to create awesome SwiftUI apps by following the instructor step by step

• You do not need any other prior programming experience or knowledge

Click on the Resources button below to download the Xcode guide in PDF format.

This SwiftUI Reference Guide is featuring all major updates and improvements of Apple’s native user interface framework. It covers not only the basics but more advanced topics as well such as asynchronous task, pull to refresh, search bar, custom swipe action buttons, remote image from an URL, visual effect blur, dismissing the keyboard, markdown text, new alerts & action sheets API, etc.

SwiftUI provides views, controls, and layout structures for declaring your app’s user interface. The framework provides event handlers for delivering taps, gestures, and other types of input to your app, and tools to manage the flow of data from your app’s models down to the views and controls that users will see and interact with.

Define your app structure using the App protocol, and populate it with scenes that contain the views that make up your app’s user interface. Create your own custom views that conform to the View protocol, and compose them with SwiftUI views for displaying text, images, and custom shapes using stacks, lists, and more. Apply powerful modifiers to built-in views and your own views to customize their rendering and interactivity. Share code between apps on multiple platforms with views and controls that adapt to their context and presentation.

This SwiftUI Reference Guide is featuring all major updates and improvements of Apple’s native user interface framework. It covers not only the basics but more advanced topics as well such as asynchronous task, pull to refresh, search bar, custom swipe action buttons, remote image from an URL, visual effect blur, dismissing the keyboard, markdown text, new alerts & action sheets API, etc.

SwiftUI provides views, controls, and layout structures for declaring your app’s user interface. The framework provides event handlers for delivering taps, gestures, and other types of input to your app, and tools to manage the flow of data from your app’s models down to the views and controls that users will see and interact with.

Define your app structure using the App protocol, and populate it with scenes that contain the views that make up your app’s user interface. Create your own custom views that conform to the View protocol, and compose them with SwiftUI views for displaying text, images, and custom shapes using stacks, lists, and more. Apply powerful modifiers to built-in views and your own views to customize their rendering and interactivity. Share code between apps on multiple platforms with views and controls that adapt to their context and presentation.

Declarative syntax

SwiftUI uses a declarative syntax, so you can simply state what your user interface should do. For example, you can write that you want a list of items consisting of text fields, then describe alignment, font, and color for each field. Your code is simpler and easier to read than ever before, saving you time and maintenance.

This declarative style even applies to complex concepts like animation. Easily add animation to almost any control and choose a collection of ready-to-use effects with only a few lines of code. At runtime, the system handles all of the steps needed to create a smooth movement, and even deals with interruption to keep your app stable. With animation this easy, you’ll be looking for new ways to make your app come alive.

Design tools

Xcode includes intuitive design tools that make building interfaces with SwiftUI as easy as dragging and dropping. As you work in the design canvas, everything you edit is completely in sync with the code in the adjoining editor. Code is instantly visible as a preview as you type, and any change you make to that preview immediately appears in your code. Xcode recompiles your changes instantly and inserts them into a running version of your app — visible, and editable at all times.

Xcode

Xcode adds powerful new team development features, perfect for working with Xcode Cloud as well as with GitHub, Bitbucket, and GitLab collaboration features. Initiate, review, comment, and merge pull requests directly within Xcode. See your teammates’ comments right inside your code. And quickly compare any two versions of your code files.

Easy setup

Take advantage of a complete workflow to manage pull requests directly within Xcode. Create new requests, see a queue of pull requests ready for your review, and quickly view, build, and test results generated locally or by Xcode Cloud.

Teams Comments Online

Comments that your teammates make on code during review display inline within the code editor, along with the name and avatar of the reviewer.

Quick compare

Jump into a comparison view of any two versions of your source code, in any editor, while retaining your current editing context.

Cloud signing

Apps are code-signed using an Apple-hosted service that manages all of your certificates, making App Store submission easier and more reliable. Just sign in to Xcode using your Apple ID, and your Mac is configured for development and deployment based on your membership roles and permissions.

Bottom bar

The always-visible bottom bar shows useful information, such as line and column, and offers direct access to quickly compare different versions of code.

Vim mode

Many common key combinations and editing modes familiar to Vim users are supported directly within the code editor, using the new bottom bar to show mode indicators.

CarPlay simulator

This new simulator for Mac offers complete control over screen size, resolution, and variable input methods, so you can test your CarPlay experience across many different car platforms.

Instant crash reports and feedback

Crash reports from your TestFlight users appear in Xcode Organizer within just a few minutes, complete with user feedback so your testers can tell you exactly what was happening when they experienced the crash. The crash log displays inline and you can jump to the related code with just a click.

Custom documentation

Auto-generate your documentation comments written in Markdown into a documentation set, usable from within the Xcode documentation window. Write your documentation comments inside source files or in documentation extension Markdown files, and choose to share the resulting documentation output bundle with others.

iOS

Focus, connect and explore.

iOS is the world’s most advanced mobile operating system. With iOS, you can build apps that connect people in new ways with SharePlay, help them focus on the moment with new notification APIs, and provide new tools for exploring with augmented reality, Safari extensions, and nearby interactions. You can even improve the discovery of your app on the App Store, provide better in-app purchase experiences, and more with the latest capabilities for apps on the App Store.

Resource from the Apple Developer website.

“The best way to build an app is with Swift and SwiftUI.” – Apple, WWDC

Introducing the SwiftUI framework. In this reference guide, we will learn everything about the latest improvements and features of Apple’s native user interface framework.

But before we dive into the details, let's go through the tools you need to build an app, so can follow along with me.

Since you have Xcode installed on your computer, therefore now it's time to launch it and create a new project by choosing the first option on the Welcome screen, as I show you.

By doing that, Xcode will start the project setup process, which requires some additional information about the app we want to create.

First, we will create a new iPhone app using the App template under the iOS category in the new window.

Introducing the SwiftUI framework

In this reference guide, we will learn everything about the latest improvements and features of Apple’s native user interface framework.

Apple Developer

But before we dive into the details, I would like to highlight the major requirements so you can follow along with me. Also, You can get more information about app development and all the necessary tools at the following official website:

https://developer.apple.com

Xcode

First and foremost, you will need the Xcode application installed on your computer. To get the latest version of Xcode, you will need to open the App Store on your computer and download it using your personal or business Apple account.

It’s worth mentioning that the Xcode editor is free, which is fantastic! Also, a yearly membership in the Apple Developer Program is not required to get started developing applications. However, if you want to publish your apps to the App Store, then it is highly recommended.

Please notice that since the file size of Xcode is enormous, therefore it will take some time when the download is done. While Xcode is downloading, you can continue watching the rest of this video.

The SwiftUI Link is a control for navigating to a URL. We can create a link by providing a destination URL and a title.

The title tells the user the purpose of the link. This can be a string, a button, or a custom view that acts as a label.

The following example creates a link to the apple.com website and it displays the title string as a link-styled view.

When a user taps or clicks a Link, the default behavior depends on the contents of the URL and its associated application.

Links were designed for the web, but we can add them to our applications and let the system decide where to open the linked document.

For example, a SwiftUI Link can trigger to call a phone number, open the default email client, or other apps that Apple provides schemes for.

Customizations.

As with other views, we can style links using standard view modifiers depending on the view type of the link’s label. For example, a text label could be modified with a font or foreground color modifier to customize the appearance.

Alternatively, we can add the same styling options that we also use on buttons.

Custom Link View.

Also, there is another initializer we can use to create a custom button-like view for the Link.

To use this new link initializer, we need to put the destination parameter first, and then we can create and customize any view that users can tap on to navigate to a URL.

In this example, we created a well noticeable stylized view with a system symbol and a text view wrapped into a horizontal view container.

How to add color gradients to text in SwiftUI?

Using the Foreground Style modifier, we can easily add any gradient color to text in SwiftUI.

Let's look at how it works with some examples.

In this SwiftUI tutorial, we will learn how to load and display an image asynchronously from the Internet. Note that the SwiftUI AsyncImage view uses the shared URLSession instance to load an image from a specified URL and then display it on the screen. Until the remote image loads, the view displays either a standard or a custom-built placeholder.

To gain more control over the loading process, we can use the initializer, which takes a content closure that receives an Async Image Phase to indicate the state of the loading operation.

By doing that, we can control what to display on the screen. In a nutshell, we can return a view that's appropriate for the current phase, such as success, failure, or empty phase.

Alright! Without further ado, let's create a new project in Xcode and start coding along with me.

Choose the best answer from the choices given in each question.

By creating this new iOS 16 application, you can learn advanced SwiftUI features like Alternate App Icons beside the primary process.

Getting started

In this course, our primary goal is to develop a well-designed card component for a hiking application with the SwiftUI framework. All right, let's get started.

First of all, go ahead and open the resources folder downloaded from this section.

As you will see in each SwiftUI project of this course, there are three additional folders and a supplementary workbook file inside it.

In the pink folder, you will find all the resource materials which we need to create the application.

Next, you will find the source code of the finished project in the green folder. The source code of the completed project can help you when you get stuck and need quick assistance.

And finally, we will save our new project in the blue folder.

Workbook

Awesome! Now let's open the workbook document and quickly examine the app design and the main learning objectives.

We will learn how to put together different content containers by creating this impressive design during the development.

Not only that, but we will also cover how to develop reusable components, organize resource files and extend the functionalities of the built-in SwiftUI features.

Moreover, this mini-application will have some amazing features as well.

At the end of this course, you will get an impressive Card app with such a settings screen where users can change the application icon with different alternate app icons.

And finally, this project-oriented course suits beginner and somewhat advanced app developers.

In this SwiftUI tutorial, we will continue developing this application by creating a well-designed card component with a gradient circle and an image on top of it.

In the development process, we will learn how to overlay any content containers on top of each other. Besides that, we will discover how we can create a useful color extension to keep our code neat and easy to read.

In this SwiftUI tutorial, we will develop a Header view for the Card component. As you see on the screen, there are three easily distinguished elements that this Header has.

Let's talk about it a little bit.

While a huge bold text grabs your attention in the top part, then there is a custom-made button right beside it. At the bottom of this Header, you can also notice a subheader with some text.

It's pretty easy to develop such a layout design in the SwiftUI framework, so without further ado, let's launch Xcode and deep dive into coding.

There are two primary objectives of this SwiftUI tutorial.

The first objective is to learn how to develop a custom button style with a distinguished design properly. The second thing is developing a new feature with a function that can randomly change the Card's image.

By the end of this tutorial, the Card's look and design will be completed.

In this SwiftUI tutorial, we will develop a fantastic, complex animation. As you can see in the demo, several translucent circle shapes move around inside the center of the Card.

While they unpredictably move from one place to a different place, they also scale up or down randomly.

By the end of this class, we will learn how to develop this motion effect programmatically in SwiftUI.

If you want to learn this, launch Xcode and start coding with me.

In this SwiftUI tutorial, we will learn how to present a sheet view using a boolean in SwiftUI. So when a user presses the custom button with the hiking icon, then a new Settings view will be presented.

As you can notice in this demo, this Sheet has a so-called detent that holds the Sheet in the middle of the window, so it only covers the whole window once we drag and pull it up to the top.

Besides getting familiar with how sheets work in SwiftUI, we will also develop a good-looking header section for the Settings.

In this SwiftUI tutorial, we are going to create a new section about the application in the Settings Sheet. During the development process, we will learn some exciting techniques on how to make a reusable UI component with SwiftUI's labeled content.

As you can notice in this demo, each row in the list view has got its own colored iconography, text label, and content. Moreover, we can also use a SwiftUI weblink for the labeled content.

By the end of this lesson, you will know how to develop a similarly impressive and professional List for your own iPhone or iPad application.

In the final SwiftUI tutorial of this session, we will be creating an impressive feature for this mini-application. The ability to change the app's icon programmatically has been around for quite a few years on the iOS and iPadOS platforms.

This nifty feature allows users to switch between a predefined set of alternate icons. Please keep in mind that the app icon can only be changed at the user's request, and the system always provides the user with confirmation of such a change.

Sometimes we feel discouraged. Sometimes we are vastly disappointed too. If so, by practicing solitude we can feel better and focused. This is when we create amazing things. Please join me to develop this beautiful iOS application with SwiftUI.

• Chapter 1: Setting up the new application

• Chapter 2: Let’s build up the Onboarding Screen

• Chapter 3: Let’s build up the Home Screen

• Chapter 4: Complex SwiftUI Gestures

• Chapter 5: Animation - Part 1

• Chapter 6: Animation - Part 2

• Chapter 7: Final Touches

1. ADVANCED APP DESIGN
   The main goal of this mini project is to inspire you on what we can accomplish with the SwiftUI framework.

2. COMPLEX SWIFTUI GESTURES
   We will create such a custom button with complex gestures that we can not find in Apple’s stock user interface library.

3. PARALLAX EFFECT
   By using multiple movements in the opposite direction (parallax effect) we can add depth to this amazing onboarding screen.

The standard user interface library is a great starting point for each iOS project when it comes to app development and design. However, if we want our application to stand out in the App Store, then we need to learn how to create something new, something unique.

You know, my goal with this iOS project is to inspire you on what we can accomplish with SwiftUI. Therefore, if you want to learn advanced app design in SwiftUI, then fire up Xcode and start coding along with me.

In this SwiftUI tutorial, we will create a fully-fledged Onboarding Screen in Xcode. As you can see, this screen consists of three main parts.

• The first section is the Header.

• The second one is the Center.

• And finally, the Footer is the last section.

We will create them step-by-step in top-down order like a waterfall. That's being said, we'll start with creating a large title with a subheader for the Header section. After that, we will create a ring and put a professional illustration on top of it.

And at the end of the tutorial, we will focus on developing the layout of the complex button component.

Each design of these UI elements is the final version without animations and interactivity. The only exception is the Red button at the bottom. So we can navigate to the Home screen and back from it to the Onboarding.

By the end of this class, we will have a fantastic Onboarding screen waiting for us to put some life into it later on.

In this SwiftUI tutorial, we will continue our development work where we finished in the previous class. Our goal is to create a complete design of the Home screen. So when we tap on the main button on the Onboarding screen, then this elegant and aesthetically pleasing design shows up.

As you may notice, the Home screen layout consists of three parts, similar to its counterpart. It's pretty simple, so it shouldn't be too hard to create it, I guess.

During the development, we will get familiar with the new button styles in the latest release of SwiftUI. And to make this lesson slightly more challenging for you, we will also learn how to create a reusable UI component.

The sole purpose of this SwiftUI tutorial is to develop the snappy feature of the custom button. Nothing more, nothing less. But it is a good thing since this is the one feature that makes this application so great.

That's said, let's see how this unique behavior works in action.

1. The first thing worth knowing about it. By the end of this lecture, users can drag and swipe the Button in the right direction.

2. The second point. And by doing that, the Button's shape will grow horizontally as well.

3. The third point. When we stop dragging the Button halfway and we release our fingers from the screen, then watch out for what's happening. Did you see that the Button snapped to back its starting position? Awesome!

4. The fourth point. Now let's see what happens when we swipe the Button more than halfway, shall we? And there it is!

The Button snapped to the right edge of this component, and this will trigger the screen change. How cool is that! Let's do it again!

As you can see, this behavior is quite complex. And we need to develop these four main features in order to make it works. Alright, without further ado, let's open Xcode and start working on it.

In this SwiftUI tutorial, we will give life to this application by adding ultra-fine animations. First, we will animate the Header, the Footer, and the Center part of the Onboarding screen.

Then we will animate the transition from the initial screen to the Home screen as well.

As you can see on the Home screen, there is an illustration of a woman. While she is meditating, we will make her levitate by moving her position up and down continuously.

We will also learn how to develop a one-time animation when a UI element first appears on the screen.

Then we will figure out how to delay a specific animation using the main activity thread of the device. We will even cover how to repeat animations forever.

As you can see, there are many things to learn about how animation works in the SwiftUI framework.

And you know, by the end of the first part of the animation series, this application will become more professional due to those small details we will focus on.

In the second part of this animation series, we will develop something really cool feature with SwiftUI. As you can see in this demo, users can drag and move the illustration on the screen. And when it happens, then it will not only go to the right and the left directions, but it will also rotate until to a certain point.

On top of that, as you can see, we will reposition the Ring in the opposite direction with a blur effect. This opposite movement creates an illusion of viewport changing. And, the combination of these actions will create a beautiful parallax effect at the end.

But we won't stop there since we will also improve the user experience by providing a low-key indicator. This particular user interface element with a two-directional arrow symbol will suggest what is going to happen if users start dragging and moving the main Image.

How cool is that? Finally, I will share with you a pretty awesome SwiftUI technique as well. Did you notice that with this dragging gesture, we change different parts on the screen? One of them is the large Title at the top.

Now, if you are an experienced developer, then you may think that changing the string value of any Text view is not that hard at all. And partially, it is true. However, when it comes to adding animation to this value change, you will be surprised.

But do you know what? You need to watch the whole video to get my solution for a problem you can face when you try it yourself.

AVFoundation

AV Foundation is a full-featured framework for working with time-based audiovisual media on iOS, Mac OS, Watch OS, and TV OS. We can easily play, create, and edit movies, sound files and build powerful media functionality into any apps using this framework.

Haptics

Haptics engages people's sense of touch to enhance the experience of interacting with onscreen interfaces. We can play various types of haptics in addition to visual and auditory Feedback to enhance touch gestures or toggling a switch. On top of that, we can use it to highlight, deny or confirm any other user interactions.

Learn how to create advanced Pinch and Zoom features with SwiftUI gestures by developing this fun and engaging iPhone and iPad mobile application in Xcode editor. We will cover how to implement SwiftUI’s double-tap gesture, drag gesture, long-press gesture, and magnification gesture. Besides all of that, we will develop a modern user interface drawer as well.

Learn how to create advanced Pinch and Zoom features with SwiftUI gestures by developing this fun and engaging iPhone and iPad mobile application in Xcode editor. We will cover how to implement SwiftUI’s double-tap gesture, drag gesture, long-press gesture, and magnification gesture. Besides all of that, we will develop a modern user interface drawer as well.

In this SwiftUI course, our ultimate goal is to develop a fancy pinch and zoom feature by implementing various gestures that this robust framework provides us.

By developing this engaging iOS project, you will learn more about how a long-press gesture, a double-tap gesture, a sophisticated drag gesture, and finally, magnification gestures work together.

Not only that, but we will also cover how to use SwiftUI background Materials and SF Symbols as well.

By the end of this engaging course, you will have a functional app with a practical and reusable feature on your iPhone and iPad devices.

In this tutorial, first, we will create a simple design for the project by putting a front page of a fictional magazine on the screen. Of course, we will improve it in the following sections.

Also, after creating this layout, we will develop a very basic feature by adding a double-tap gesture to this image. So when users double-tap on the cover, then it will be scaled up or scaled down depending on the actual state of the image scale property.

As you can see in this demo, this is a pretty simple feature to develop.

Yet, it plays a fundamental role in the entire project development so we can build more complex functionalities on top of it.

In this tutorial, we will develop a sophisticated drag gesture for this SwiftUI application. What I mean by saying developing a sophisticated gesture is how this specific drag feature works in various situations.

In this SwiftUI tutorial, we will learn how to implement a long-press gesture in our application. As you can see in this demo, there is a button with a double circle symbol at the top-left corner of the screen. If you take a closer look at this SF Symbol, then you can notice that this symbol uses a primary and a semi-transparent color, making a duotone color combination.

SF Symbols provides four rendering modes that enable multiple options when applying color to symbols.

And this duotone rendering mode is one of the built-in features that SF Symbols provides us, but there is much more to talk about. That is why we need to discuss how to implement different rendering modes in our SwiftUI app.

We will have another great feature added to this app by utilizing the long-press gesture by the end of this tutorial.

In this SwiftUI tutorial, we will develop a new Control Interface for this application. As you can see in this demo, this UI component consists of three buttons. And it is placed at the bottom of the screen. Also, SwiftUI background material is used in its container so users can notice a frosted-ice-like semi-transparent background.

The middle button will reset the page to its original position and scale. The first magnifying symbol with the minus sign will decrease the scale value by one each time when users tap on it. On the contrary, the magnifying symbol with the plus sign will increase the scale value by one.

Of course, this zoom-in and a zoom-out feature have their constraints in both ranges, so we need to ensure we take care of these boundaries. On top of that, these buttons are optimized to work in both light and dark modes using a custom accent color created by us.

In this short SwiftUI tutorial, we will learn how to add a magnification gesture for the Pinch and Zoom application. You know, every magnification gesture tracks the distance between two fingers, indicating if it's moving closer or away from each other.

This magnification motion would then scale the cover image to larger or smaller depending on the fingers' movement. Our application will get another practical feature by the end of this lesson.

In this tutorial, we will develop a new Drawer user interface in SwiftUI. As you can see in this demo, we can open and close this container with the adaptive SF chevron symbol.

Also, we will use the SwiftUI material as a background for this interface. Of course, it looks great in both light and dark mode.

In this SwiftUI tutorial, we will develop the last feature for this application. As you can see in this demo, there are two thumbnails of the cover images in the Drawer, and we can switch between them by clicking them.

While we are developing this new feature, we will also learn about the importance of data fetching and modeling. This part will be especially useful for beginner developers who have just started iOS app development.

Nevertheless, the ultimate goal of this lesson is to inspire you to create similar user interfaces for your own application. You know, with this example, you can create a slide-in container with multiple images or other files with ease in the feature.

For example, you can use this knowledge to develop a sophisticated UI component with more content for any e-commerce or other document-based applications.

What will you learn and what are the main objectives of this SwiftUI project?

• How to set up a new iOS project with the new SwiftUI App Life Cycle.

• How to develop a unique Onboarding screen

• How to use the new AppStorage in SwiftUI

• How to save and load data using UserDefaults

• How to create custom Views with SwiftUI

• How to retrieve local data using Structs in Swift

• How to display multiple Views automatically with For Each loop

• How to use scroll view, horizontal view, vertical view containers

• How to create an outstanding Settings view

• How to add Icons to the App

• How to use the improved Canvas and Previews in Xcod

• How to test the iOS app in Xcode Simulator

• Get familiar with the new Xcode

LEARNING OBJECTIVES

What will you learn and what are the main objectives of this SwiftUI project?

• How to set up a new iOS project with the new SwiftUI App Life Cycle.

• How to develop a unique Onboarding screen

• How to use the new AppStorage in SwiftUI

• How to save and load data using UserDefaults

• How to create custom Views with SwiftUI

• How to retrieve local data using Structs in Swift

• How to display multiple Views automatically with ForEach loop

• How to use scroll view, horizontal view, vertical view containers

• How to create an outstanding Settings view

• How to add Icons to the App

• How to use the improved Canvas and Previews in Xcode

• How to test the iOS app in Xcode Simulator

• Get familiar with the new Xcode

What will you learn and what are the main objectives of this SwiftUI project?

• How to set up a new iOS project with the new SwiftUI App Life Cycle.

• How to develop a unique Onboarding screen

• How to use the new AppStorage in SwiftUI

• How to save and load data using UserDefaults

• How to create custom Views with SwiftUI

• How to retrieve local data using Structs in Swift

• How to display multiple Views automatically with ForEach loop

• How to use scroll view, horizontal view, vertical view containers

• How to create an outstanding Settings view

• How to add Icons to the App

• How to use the improved Canvas and Previews in Xcode

• How to test the iOS app in Xcode Simulator

• Get familiar with the new Xcode

By the end of this class, we’re going to develop a fully functional Onboarding screen with SwiftUI’s new Page Tab View. In order to make this onboarding screen display some content we will create a new reusable card view for the fruits in Xcode.

As you can notice we can see only one card at one time but we can activate the next card by moving our finger horizontally on the screen. This paging functionality with the little circle indicators at the bottom of the card is a built-in feature that we can utilize in SwiftUI with writing only a couple lines of code.

All right, without further ado, let’s open the Fructus project in Xcode and start coding, shall we?

Learn how to create a data model and work with local data in Swift 5. IIn this SwiftUI lecture, we’re going to cover the basics of data. First, we will create a data model, then create a local data file that will store all of the information about the fruits in this encyclopedia app.

Second, we will learn how to integrate and fetch this data as well. By the end of this class, we will display different fruits on the onboarding screen and make it more interesting.

Learn how to use App Storage and understand the new SwiftUI App Life Cycle. This year Apple in the WWDC extended the SwiftUI framework with some new APIs such as Scenes and Apps. This was a big expansion to SwiftUI, and that’s why many developers call it SwiftUI.

One of the most important features is that we can now build an entire app with just SwiftUI. In this class, we're going to cover the basics of these new APIs and explain how views, scenes, and apps work together.

By the end of this SwiftUI lecture, users will be able to exit the onboarding process by tapping on the start button and enter the next screen in the Fructus application using Xcode editor.

In this iOS lecture, we’re going to cover how to create a ListView and retrieve data using a loop with SwiftUI. To accomplish this we will need to create a separate row component for this list. By the end of this class, we will have a well-designed second screen with the necessary content inside it.

Up to this point, we have finished creating an Onboarding screen and a Second screen. The list of fruits looks amazing but there is no additional functionality attached to it.

Now it’s time to add a working navigation link to each list row so when users tap on them they will be navigated to a detailed view. There are many topics to cover in this two-part class and that will take some time.

By the end of this SwiftUI class, we will finish developing the majority of this new screen, so without further ado let’s start coding in Xcode.

In this SwiftUI tutorial, we’re going to finish up the detail view by creating an infobox for the nutrients of the fruit.

To do that, we will use two UI components that are new in SwiftUI and iOS. You will see how easy to develop this interactive user interface and test it using Xcode’s built-in Live Preview feature.

By the end of this lecture, users can unfold a well-designed information box with all of the nutritional value that fruit can contain. Alright, without further ado let’s get started!

Every iOS application needs a well-designed Settings view, no matter what! While we're creating this outstanding Settings View we will focus on the following topics:

1. First, we’re going to create a Settings view and learn how to present it as a Sheet on top of our existing view with the SwiftUI.

2. Secondly, we will learn that the difference between a good and great SwiftUI app often comes from the little details.

By the end of this lecture, we will finish up the first part of this series. Without further ado, let’s open Xcode and start coding.

In the second part of creating a Settings View SwiftUI tutorial series, we’re going to develop a new section with some information. As you can see, this information box contains several rows.

While on one hand, there is a text on the left side of the box, on the other hand, there is another text on the right side. At first, it seems to be pretty easy to create such a layout with SwiftUI, however as you may notice some rows contains executable links.

For example, if we tap on the website link on one of the rows in this example, then it will open iPhone’s Safari browser and go to the website address. To give this reusable component more functionality we’re going to develop a useful logic for it with a conditional statement in Xcode.

By the end of this lecture, we will create not only a new section for the Settings screen with some additional information but we will add new functionality to it as well.

In the last SwiftUI tutorial in this section, we’re going to develop another great feature that will add additional value to the Fructus app. This new feature in the Settings will allow users to reset the entire application and start the onboarding process with the welcome cards and fruits.

As you can see this reset feature is attached to a toggle interface. However, you can also notice that we’re going to add some love for its design and make it better with conditional logic.

You will see what I mean by that shortly after you are holding this app in your hand. By the end of this class, you will get a fully functional iOS app developed with the latest SwiftUI in Xcode. It sounds great, doesn’t it? All right, without further ado, let’s open Xcode and start coding.