SwiftUI Masterclass: iOS 13 App Development with Swift 5
4.6 (182 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
764 students enrolled

SwiftUI Masterclass: iOS 13 App Development with Swift 5

From Totally Beginner to Advanced iOS App Developer with this Complete iOS 13 SwiftUI Development Course with Xcode
4.6 (182 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
764 students enrolled
Created by Robert Petras
Last updated 6/2020
English
English [Auto-generated]
Current price: $13.99 Original price: $19.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 11.5 hours on-demand video
  • 14 articles
  • 14 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • The Complete iOS App Development Course with SwiftUI
  • Master Apple's latest UI Framework - SwiftUI Development
  • Learn macOS desktop app development with Apple's Catalyst framework
  • Build eye-catchy iPhone and iPad apps with gorgeous layout and design
  • Learn Swift 5 programming language - Essential iOS Development Skill
  • Learn how to publish apps to the App Store
  • Basic mobile application design and prototyping skills
  • Learn how to store data on your iPhone and iPad with Core Data
  • Create custom user interfaces with SwiftUI
  • Gorgeous in-app interactions and animations
  • Visually build iOS apps and write SwiftUI codes
  • Create a top-notch portfolio of real apps and apply for iOS developer jobs
  • Test-driven iOS 13 iPhone and iPadOS app development
  • Xcode 11 tips and tricks for iOS Developers
  • Loading external JSON data with using Web APIs
  • Learn to use Apple's new Combine framework and handle asynchronous events
  • Learn how to implement Swift Package manager in your work
Course content
Expand all 91 lectures 11:35:26
+ Table of Contents: What Will You Build with SwiftUI in this Course?
6 lectures 13:10

This course is unlike any other SwiftUI online tutorial. We care about app UI design and want to make sure that you get better at it in the app development process of building outstanding iOS 13, iPadOS, macOS and even watchOS apps.

Preview 01:27

In this SwiftUI tutorial for beginners, we’re going to build an Avocado Recipes app with Swift programming language in Xcode. This iOS 13 application has a quite slick design and it supports both the tall iPhone and the wide iPad screens.

Moreover, we will learn how to support system-wide light or dark appearance with SwiftUI. We are going to create adaptive color sets and prepare some specific graphics for dark mode as well.

Preview 01:51

In this SWiftUI tutorial, we’re going to build a Slot Machine game, an outstanding iOS, iPadOS and even a macOS app with Swift programming language in Xcode.

  1. At the beginning part of the class, we will create a very impressive game interface with many gorgeous graphics that were made by myself for this course. If you are curious, then I can tell you that I designed those graphic assets using a professional vector drawing iPad application with my Apple Pencil.

  2. In the middle part of this class, we will develop the main game logic with Swift. Then we will learn how to save and read the High Score using the User Defaults. We can use User Defaults to store any basic data type for as long as the app is installed. You will see how easy is to use it with SwiftUI.

  3. In the last part of this class, we will learn how to bring an iPad app to Mac by using Apple’s Catalyst technology. With Mac Catalyst, our Slot Machine iPad app shares the same project and source code therefore we can efficiently convert this mobile app to desktop.

Preview 02:43

In this SwiftUI tutorial, you’ll write your very first Core Data application with SwiftUI in Xcode. You’ll see how easy it is to get started with all the resources provided in Xcode, from using the starter code templates to the Data Model editor. Without further ado, let's have some fun and build this outstanding Todo app with SwiftUI!

Preview 02:10

In this slightly advanced online SwiftUI tutorial, we’re going to develop a modern iOS and iPadOS mobile app with swipe motion powered by the SwiftUI framework. Having said that, we will dive into some advanced gesture techniques in this section.

The app presents users with a pile of Honeymoon destination cards and allows them to use the swipe gesture to like or dislike a card. This could be a great portfolio app that you can show up with confidence in your job interview.

Preview 02:07

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

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

  2. Xcode 11 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

Course Requirements
02:52
+ PROJECT 01: Build Your First iOS 13 App With SwiftUI in Xcode
14 lectures 01:15:48

This course is designed for you to master SwiftUI and iOS 13 app development.

So, what kind of app we’re going to build? In this section you will learn the following things:

1. How to set up a new iOS 13 project
2. How to create a launch screen
3. How to add icons for the app
4. How to create a card layout with SwiftUI
5. How to load different information from a data file
6. How to play sounds
7. How to animate user interface elements with SwiftUI
8. How to create a haptic feedback feature
9. How to show alerts with SwiftUI
10. Finally, how to create stickers without writing any code


Start your SwiftUI journey with this hands-on project and learn by doing.

Without further ado, see you at the class!

Preview 01:49

Take a short sneak peek to the first SwiftUI project. In this section, you will create interactive cards iOS 13 app in Xcode.

Preview 00:31

The downloadable project file contains the following main folders:
1. Completed iOS 13 app project files (Students can build it in Xcode)
2. Resources materials including images, app icons, vector files, sound files, data files.
3. SwiftUI project workbook (PDF and eBook file formats)
4. The student’s folder is created mainly for your project.

Let’s set up the iOS 13 project
11:25

Since the Launch Screen is the first screen users see when they open a mobile app, therefore, it’s important to know how to create it in the iOS 13 development process.

How to create a launch screen in iOS 13
06:21

In this lecture, we're going to work on this project further. We'll create a card view with SwiftUI and design a complex layout for it. When you finish the hardest part of this project then you will learn a ton of useful iOS design methods. Don't stop and keep learning!

Create a card view in SwiftUI
14:37

In this short lecture, we're going to repeat the cards using the 'ForEach' structure with SwiftUI. Besides that, you're going to learn how to use the debug preview in this tutorial as well.

Repeating content effortlessly with ForEach
04:30

In this iOS 13 development tutorial, we're going to create a data model for the cards. This card model's purpose is to represent the actual data of all cards.

Create a data model for the cards
02:21

We will work on the data for the cards. This static data contains all of the content of the cards in one file for our SwiftUI app.

Let’s create an array of static data
04:26

It’s getting more and more exciting because our next goal is to fetch the static data and display the different cards in this SwiftUI application.

How to load static data in SwiftUI
06:09

I think you will enjoy this lecture because sounds can make apps to life and increase the overall user engagement at the same time.  It’s always fun playing sounds and music in iOS development and the same is true for SwiftUI.

Preview 05:14

Besides playing a sound file there is another thing which quite cool, as I think: It's the animation in SwiftUI. Users unintentionally pay attention to the moving parts of the user interface because animations are eye-catchy for them. Let’s play with SwiftUI animation, shall we?

Introducing SwiftUI Animation
09:00

In this lecture, I’m going to introduce haptic feedback in iOS 13 to you. What haptics is on the iPhone? Simply put: haptic feedback (also called Haptics or Haptic Touch) is the use of touch feedback when you interact with your iPhone.

Let’s add a Haptic Feedback for the iOS 13 app
02:07

In this lecture, you will learn how to present an Alert window with SwiftUI. Each card has a different alert title and message, so you can play with them in the simulator or on your real device.

Preview 02:29

A Sticker pack is a messaging extension that lets people share content with friends. These iOS 13 app extensions offer a fun, engaging way for us to express ourselves in a Messages app conversation without typing or using emojis.  Without further ado, let’s create our first Stiker pack without writing a single line of code.

Let’s create Stickers for the mobile app
04:49
+ PROJECT 02: Build an Avocado Recipes App With SwiftUI in Xcode
19 lectures 02:37:09

In this section, you will learn how to create a complex iOS 13 app layout with SwiftUI in Xcode. No Adobe XD, Sketch, Figma, Framer or other subscription-based prototyping software needed. Join to this SwiftUI course and learn iOS app prototyping with me!

Preview 01:51

Take a short sneak peek to the second SwiftUI project. In this section, you will create a complex iOS 13 app in Xcode: We are going to build an Avocado Recipe iOS 13 app for iPhone and iPad. The Avocados app has a fairly complex UI in SwiftUI so you will learn lots of new and exciting features in Xcode.

Preview 00:46

Let’s set up our iOS 13 project in Xcode 11. In this section, we’re going to build an Avocado Recipes app with SwiftUI. This iOS 13 app has a quite slick design and it supports both the tall iPhone and the wide iPad screens.

Let’s set up our SwiftUI project as usual. Download the resources from this section. Place it to the Desktop and unzip it by clicking on the package.

The provided package contains 3 folders marked with the Swift logo and a supplementary workbook files in PDF and ePub formats. This workbook shows you the main objectives of this project.

As in the first section, you can find the completed project in the green folder. The finished project with the source codes may help you when you are stuck and need some quick help.

The next folder is the red one. This contains all of the resources you will need to build the Avacodo Recipes app.

The final blue folder is the student’s folder. We are going to create and save your app in this place. That is why it’s empty for now.

Without further ado, let’s set up the Xcode 11 project.

Let’s set up the SwiftUI project in Xcode 11
07:03

Supporting Dark Mode in iOS 13 App Interface with SwiftUI. In this lecture, we will learn how to support system-wide light or dark appearance with SwiftUI. We are going to create adaptive color sets and prepare some specific graphics for dark mode as well. We configure custom color assets using Xcode’s asset editor.

Supporting Dark Mode in iOS App Interface with SwiftUI
11:11

This SwiftUI lecture is a short one because we already know how to create a simple ‘Launch Screen’ in Xcode 11. Since the ‘Launch Screen’ is built by using older and different technologies than SwiftUI, therefore it’s quite important to practice how to create it.

By following my instruction you have just created not only an eye-catchy iOS 13 Launch Screen which will work both on iPhones and iPads, but it will change its appearance in Light and Dark mode too.

Preview 07:12

All right, it’s time to talk about the TabView navigation with SwiftUI a little bit. So a TabView is a special view that switches between multiple child views using interactive user interface elements. These UI elements are the tab items.


To create a user interface with tabs in Xcode, we need to place views in a TabView and apply the .tabItem modifier to the contents of each tab. Tab views only support tab items of type Text, Image, or an image followed by text. Passing any other type of view results in a visible but empty tab item.


Let’s create our first Tab navigation with SwiftUI, shall we?

Create a user interface with tabs (TabView) in SwiftUI
06:48

In this lecture, we’re going to create a home view of the ‘Avocados’ app with SwiftUI. What’s better than test it on your real device or in the simulator? We can do it even better because Xcode 11 has a new built-in environment testing feature.

Click on the ‘Environment Overrides’ button and turn on the interface style option. There we can switch on the Light and the Dark mode.

Let's build the Avocado home view with SwiftUI animation
10:03

In this lecture, we’re going to design the layout of the header section with SwiftUI. The header contains a horizontal scrolling view with many images like avocado foods on the kitchen sink. The new Preview window in Xcode 11, we can see instantly how our layout design is getting improved following this process. The headlines of the header section also have a sliding in animation that will draw the app users’ attention into the top area where they can scroll horizontally the header images.

Let's design the layout of the header in Xcode 11
11:15

In this lecture, we’re going to fetch the static data for the headers. What's new in Xcode 11 is that we can override the interface style environment parameter and switch from Light Mode to Dark Mode. You can use it this handy feature not only in the iPhone Simulator but on your physical devices as well. Awesome! Our app gets better and better with completing each lecture.

Let's fetch the data for the Header with Swift 5
06:13

In this lecture, we will practice our design skills and create an awesome layout design with SwiftUI. It might be challenging this complex layout in the first look, but basically, we are going to use horizontal and vertical stacks to achieve this design in Xcode 11. Besides coding this awesome layout we will learn another important concept in connection to SwiftUI.

We’re going to create our first Custom View Modifier. Basically, it is a reusable code snippet. With them, we can reuse these codes over and over without repeating ourselves. And the best part is that once we change something inside the modifier than all views which are using this modifier will be updated immediately. You will see two examples using them in this lecture.

As usual, we will test our app in the simulator or on our physical devices. This time choose the 11-inch iPad Pro device.

How to create a interesting layout with SwiftUI: Best Dishes with Avocado
13:28

All right, in this lecture, we will create a unique design and asymmetric layout with SwiftUI. The avocados facts reveal some interesting information for us about this popular fruit.

As you will see, in the SwiftUI framework, we can use multiple similar modifiers and attach them to a view at the time like backgrounds in this case. Just don’t forget that the orders of these modifiers matter a lot.  I’m sure that you will love this design exercise in Xcode 11 at the end. So let’s start coding in Swift language.

Avocado Facts and Why Modifier Order Matters in SwiftUI
09:14

In this lecture, we’re going to fetch the static data for the avocado facts with SwiftUI in Xcode. I’m sure that you are excited to run the app on your device or in the simulator. Let’s build and run the app. Click on the Recipes tab and test the facts section. It’s well functioning and quite impressive.

Go back to the Xcode and override the environment style parameter from light to dark mode. Great! Our app has been improved a lot with this new design. Let’s continue the app development by adding some avocado recipes to it in the following lectures.


Fetching the Avocado Facts’ Data with SwiftUI
06:20

In this SwiftUI lecture, we’re going to create the layout of the recipes cards and presenting the recipes’ content in the content view. We maximize the with of the recipe card by 640 points because of the wide the iPads’ screen. Definitely, centering them look much better rather than make the cards stretch out edge-to-edge. Just try it out.

As usual, we can run the live preview in the canvas for a quick test but at the end of this lecture, we’re going to build and run our avocado recipes app in the simulator as well.

After launching the app scroll down to the recipe cards. You should find all of the recipes inside the content view which means our code works without any problems. In the next lecture, we will create a detailed view of the recipes and learn how to present them in a sheet with SwiftUI.

Preview 14:38

In this SwiftUI lecture, we’re going to create a detail view layout for the Avocado Recipes. But before we start coding let’s participate in a short exercise. I will show you both the card layout and the detail layout design beside each other and I ask you to find those parts in both layouts which contains multiple elements yet there are identical to each other. Pause the lecture and start again when you find at least two identical sections in the app’s screenshots.

Are you done? Nice work! You may figure out that the recipe rating with the yellow stars and the cooking information have got identical content. Having said that we should perhaps separate each one of them as individual layout components in a brand new view and reuse them in the card view and the detail view.

With this best-practice, we can avoid code duplication and we can maintain our code with ease. So let’s separate the star ratings and the cooking information from the card view in Xcode 11.

Let's Create the Avocado Recipe Detail View in Xcode
16:05

Presenting new views using Sheets. There are only two objectives in this lecture:

  1. The first one is to create new haptic feedback when a user taps on the Avocado Recipe Cards

  2. The second one is to present the Recipe Detail views using modal sheets by tapping on the cards.

We only need to build and run the application on a real device or in the simulator. You can launch the app and play with the cards in Xcode Simulator.

By tapping on one of the cards we trigger haptic feedback and present the detail view using a modal sheet. Finally, by pulling down the actual sheet or tapping on the close button we can dismiss the modal window.

It’s quite fascinating, isn’t it? We’ have just learned another new method of how to present content with SwiftUI.

How to Present a New View with using SwiftUI Sheets
04:49

In this iOS development lecture, we’re going to create a layout for the individual stage of the avocado ripenings. During the process of designing, we will use vertical stacks intensively.

Without further ado select the View folder in the Project Navigator and create a new SwiftUI file in Xcode 11.

In the next lecture, we will insert the avocado ripening view into the app and repeat it according to its stages.

Let's Design the Avocado Ripening View with SwiftUI in Xcode
12:55

In this SwiftUI layout exercise, we’re going to fetch data for the stages of the Avocado Ripening. Since you’re already know how to load static data with SwiftUI, therefore, this will be a short lecture, I promise you.

When it’s done, let’s play with the horizontal scrolling in the live preview. We should definitely build and run our app in a real device or in the simulator. Do you see? Don’t forget to test the app in dark mode (using the new Xcode's environment override feature) as well since we made it compatible with both presentation mode.

How cool is it? We have just successfully managed to present all of the stages of the avocado ripening using a horizontal scrolling view using SwiftUI.

As we are approaching the end of this section of the course I’m pretty sure that you know what’s going on and how to use the ‘For Each’ loop in a horizontal or a vertical stack. See you at the class!

Let's present all of the stages of the Avocado ripening with SwiftUI
06:52

SwiftUI gives us a fantastic tool for building forms – collections of user input controls designed to gather information, such as an order form or a settings screen. Even better, SwiftUI forms automatically adapt the appearance and behavior change so they work better alongside other app logic.


In this lecture, we’re going to create a basic form design with a user interaction just to get a quick look at how to start building forms with SwiftUI.


We have just finished the development of this avocado recipe app in Xcode 11. How cool is that? It’s time to see the settings form in action in the live preview. Turn on and off the toggle button to see how SwiftUI show and hide animate automatically the second section of the form with a built-in animation.


All right, let’s test the app on a real device or in the simulator. I hope that you enjoyed this gentle introduction to the SwiftUI forms. Later on, in this course, we will create much more complex forms like order forms and other setting forms with real-life functionalities.


Until then let’s play with the tab navigation bar or the horizontal scrolling views. You can tap on the recipes card and see how the detail view of the avocado recipe shows up in a new model view. I would strongly recommend you to build and launch the app onto an iPad as well. You will notice that this iOS app works like a charm on the bigger screens as well.


At the end of this section, I would like to thank you for your hard work! Hopefully, you still love coding with SwiftUI and you’re eager to start to build the next app with me in the next section.


Until then, happy coding!

How to Build a Basic Form UI for iOS with SwiftUI
09:26
+ PROJECT 03: Build a Slot Machine Game macOS App with SwiftUI and Mac Catalyst
15 lectures 02:37:57

What will you learn and what are the main objectives of this iOS, iPadOS and even macOS project?

  • How to build a fun Slot Machine minigame with SwiftUI.

  • How to build an iPhone and iPad app with outstanding graphics.

  • How to store and retrieve data using User Defaults.

  • How to create a macOS application with Mac Catalyst.

Preview 02:43


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

In this SwiftUI tutorial you will learn how to create not only an iPhone and iPad mobile app but a Mac app with SwiftUI in Xcode as well. We’re going to develop an outstanding iOS and iPadOS application with custom-tailored design by using Apple’s latest SwiftUI framework. In these video tutorials, we will use the User’s Defaults to save and retrieve data permanently.

  • How to build a fun Slot Machine minigame

  • How to build an iPhone and iPad app with outstanding graphics.

  • How to store data with User Defaults.

  • How to create a macOS application with Mac Catalyst.

Preview 01:31

In this SwiftUI class, we’re going to build a Slot Machine game, an outstanding iOS, iPadOS and even a macOS app with SwiftUI.

At the beginning part of the class, we will create a very impressive game interface with many gorgeous graphics that were made by myself for this course. If you are curious, then I can tell you that I designed those graphic assets using a professional vector drawing iPad application with my Apple Pencil.

In the middle part of this SwiftUI class, we will develop the main game logic with Swift. Then we will learn how to save and read the High Score using the User Defaults. We can use User Defaults to store any basic data type for as long as the app is installed. You will see how easy is to use it with SwiftUI.

In the last part of this SwiftUI class, we will learn how to bring an iPad app to Mac by using Apple’s Catalyst technology. With Mac Catalyst, our Slot Machine iPad app shares the same project and source code therefore we can efficiently convert this mobile app to desktop.


Without further ado let’s set up our project as usual in Xcode. Download the resource files from this section. Then place it to the Desktop and unzip it by clicking on the package.


The provided main folder contains 3 folders marked with the Swift logo and a supplementary workbook files with the objectives in PDF and ePub formats.


  1. As you know by now, you can find the completed project in the green folder. This finished project with the source codes may help you when you are stuck and need some quick help.

  2. The red folder contains all of the resources you will need to build the Slot Machine game.

  3. Finally, we are going to save this app into the blue folder.

Let’s set up the Slot Machine iOS and macOS app project in Xcode
12:49

In this SwiftUI class, we’re going to develop the header part of the Slot Machine game. As you can see this is a complex layout, so it will take quite some time to build it. The header interface contains the Slot Machine logotype, the game reset, and info buttons, then the high score and the players’ coins. Having said that let’s jump into Xcode and start the iOS app development.

Let's build up the Slot Machine minigame’s header view
18:02

In this short SwiftUI lecture, we are going to build the middle part of the iOS Slot Machine app with three reels and one Spin button. Without further ado, let’s start coding. First, create a new SwiftUI file and name it to ‘Reel View’ in Xcode editor.

Preview 07:00

In this iOS development lecture, we’re going to finish the layout of the game interface. Our main objective is to create two buttons for the betting system in the footer of the app using SwiftUI. Without further ado, let's get continue the project in Xcode.

Let's build up the Slot Machine minigame’s footer view
10:04

In this SwiftUI tutorial, we’re going to create a new view with some information about the Slot Machine app and give credits to the creators. Excellent work! It’s time to start the live preview and test our application with the new sheet and the info view in Xcode.

Let’s do it. As you can see presenting a view in a sheet with SwiftUI is not so hard after getting more experienced. Creating a custom closing button is not mandatory each time, but you will see later on that a desktop Mac app doesn’t have the slide-down functionality as iOS apps have.

That’s why this closing button will be so handy when we bring the Slot Machine app to Mac. I’m sure that you are already so eager to code the main game logic in the next class. Until then, happy coding!

Let's create the Info View with SwiftUI form
09:42

In this SwiftUI tutorial, we’re going to develop the main logic of the Slot Machine game. The rules and the game flow is quite simple. The player taps on the Spin button to rotate three reels that have six symbols on them. Winning or losing is determined by these randomly generated symbols whether they are identical or aren't.


If each reel shows the same symbol along with the game interface, then the player wins. If there are no fully identical symbols then the player loses coins. The amount the player could win depends on the bet. It could be increased either by 100 coins or 200 coins. This payout is calculated by multiplying the bet amount by 10 times.


In this lecture, we will mainly focus on the main game logic. However, later on, we will add many new exciting features to this game in each following lectures for example:


  • We will save permanently the high score in the disk of the device

  • We will develop the betting system so the Player will be able to choose the amount of the bet in each round.

  • Then we will show a custom pop up window when the game is over.

  • Another awesome feature will be playing different casino theme sound effects. This will generate a fantastic vibe for the Slot Machine.

  • Not to mention the last lecture when we will bring this game to Mac in Xcode.

How to develop the main logic of the game with Swift 5
17:28

In this SwiftUI tutorial, we’re going to develop the logic of the betting system with Swift 5 programming language. This feature will allow the player to take different bets in each round in the Slot Machine game. The amount of the bet could be either 10 or 20 coins. This will require us to create two new functions to work properly. Let’s develop this iOS and macOS feature in Xcode!

Preview 06:28

How to create a custom popup window for the Game Over GUI in Xcode. In this SwiftUI tutorial, we’re going to create a custom popup window. We will show this modal when the player loses all the coins and the game is over. Without further ado, let’s jump into the project and start coding with Swift.

How to create a custom popup window for the Game Over
15:35

In this SwiftUI tutorial, we’re going to store the High Score using User Defaults. The user default is a .plist file in the app’s package and we can use it to set and get simple pieces of data.

Introducing the User Defaults

The User Defaults class is exceptionally useful for storing small pieces of data in any application. User Defaults also provides convenience methods for accessing common data types such as Integer, Boolean, String, Date, URL and so on. We can store even collection types with Array and Dictionary as well. You will see in this class that how easy to use it with SwiftUI.

Since there are endless possibilities of how we can use this handy tool in app development, therefore, we are going to use it many times in the upcoming iOS development projects.


How to store and retrieve data permanently: Introduction to User Defaults
08:22

I’m quite confident to say that you will enjoy this SwiftUI tutorial after finishing with the user interface design and game logic development. In this class, we’re going to add animation to the Slot Machine.

The game interface has three areas where adding animation could be especially beneficial in my opinion.

  1. The first area is randomly changing symbols.

  2. The second area is the betting system.

  3. Then finally, the third area is the popup modal window.

Adding animation to these parts could improve the overall user experience and grab the player's attention. Having said that, are you ready for having some fun? Then let’s start coding in Xcode!

Add animation to the Slot Machine game using SwiftUI
15:05

The SwiftUI game logic of the Slot Machine is done, but when it comes to user experience design as a whole it falls short of expectation. Of course, the animations grab the player’s attention but you will see at the end of this lecture that there are other tools in our toolbox to enhance the user experience. We have other options besides moving objects on the screen such as playing sound effects or creating haptic feedback.

This is especially true in game development in general. A great game design contains both visual and sound components as well. Just keep in mind that when we are involving these components at the same time, then we basically providing audio-visual aids or hints for the player.

In the first part of this lecture, we’re going to add some sounds effects and even catchy background music to the game. Then in the last part of this tutorial, we’re going to deal with the haptics in Xcode.

Preview 13:02

Let’s create your first macOS app using the Mac Catalyst framework in Xcode editor. Did you enjoy the lectures so far? I hope so because this will be the cherry on the cake. In this class, we will bring the Slot Machine game to Macintosh with using Apple’s Mac Catalyst framework.

By now, the Slot Machine app should look like a native macOS app, while also running on iOS devices.  As you can see now it’s incredibly simple to start building a native Mac app from your current iPad app. With Mac Catalyst, our Slot Machine game shares the same project and source code so that’s why we could efficiently convert this iPad to Mac.

Regardless that Slot Machine main project is finished, I still have something special for you in the next lesson. I hope that you are eager to figure out what’s next in the following lecture. See you at the next class!

Let’s create your first macOS app using the Mac Catalyst framework
13:32

In this final SwiftUI lecture, we’re going to create some gorgeous stickers for this Slot Machine game. A Sticker pack is a messaging extension that lets people share content with friends without typing or using emojis. Sending stickers is an engaging way for us to express ourselves in the Messages app. Without further ado, let’s create a new sticker pack without writing a single line of code in Xcode.


Preview 06:34
+ PROJECT 04: Todo App with Core Data and App Themes
10 lectures 02:33:25

In this SwiftUI tutorial, you’ll write your very first Core Data application with SwiftUI in Xcode. You’ll see how easy it is to get started with all the resources provided in Xcode, from using the starter code templates to the Data Model editor. Without further ado, let's have some fun and build this outstanding Todo app with SwiftUI!

Preview 02:10

Download the Student's Workbook and learn everything about the objectives of this SwiftUI lecture.

Preview 01:20

In this SwifUI tutorial, you’ll write a Core Data application with SwiftUI in Xcode. The new project will be a TODO app. You’ll see how easy it is to get started using the Core Data starter code template provided by Xcode.

In this section, we’re going to build this app differently as we used to do before. The Todo app tutorial consists of two parts. In the first part of the tutorial, we’re going to develop the whole app focusing on Core Data and nothing else.

In the second part of the tutorial, we’re going to enhance the user interface and the user experience. During designing UI and UX, we’re going to learn some exciting concepts and develop some totally new features as well.

Preview 14:02

The first step in working with SwiftUI and Core Data is to create a data model file. Because we decided to use Core Data when we created this new project, therefore, Xcode created this data model file for us. In the project navigator, you can see a new xcdatamodeld file.

When you select this Core Data model file then you will see totally different settings in the editor window than ever before. Here we define the structure of our Todo application’s object, including its types, properties, and relationships if any.

Both of the smaller left part and the larger right part of the editor are empty. Here we need to create and configure a new Core Data entity. If you’re not familiar with entities: you can think of an entity as a class in Swift programming language.

This core data entity could have many attributes as well. These attributes are like the properties of that class. Our main goal is to create, read, update, and delete todo items in the local storage.

In computer programming, Create, Read, Update, and Delete are the four basic functions of persistent storage.  Many times we mention this development approach: just saying CRUD.

Learn how Core Data and SwiftUI frameworks work together
15:44

In this SwiftUI lecture, we will learn how to fetch data from the database and display it in a "List View". In the previous lecture, we’ve already created a new Environment property. This property wrapper looks inside the internal storage by using the Managed Object Context.

Now, in order to retrieve todo items from the internal storage of the device we need to call a new fetch request. Doing this with SwiftUI is surprisingly simple using the Fetch Request property wrapper.

Without further ado, let's open the Content View file and start coding in Xcode. Let’s enter the following code at the top of the file.

How to fetch data from Core Data and display it in a List view with SwiftUI
11:47

In this SwiftUI video we will learn how to improve the overall user experience of this iOS mobile application. Instead of showing a boring blank list when there is no todo item encaptured, we’re going to display a random image with a random productivity tip on the screen.

Besides that, we’re going to create a gorgeous add too button with a subtle animation that grabs the user’s attention to it. Without further ado let’s start with modifying the project’s settings in Xcode, shall we?

How to show an image and a quote when there is no todo item in the List
21:29

Let’s improve the Todo form appearance with SwiftUI in this tutorial. In the first part of this lecture we’re going to improve the Todo form’s appearance with SwiftUI. As you can see with some handy modifiers we can create a professional-looking user interface.

In the second part of this tutorial we’re going to create a new add button with a pulsating animation on the first screen. Alright!

As you know Apple’s iOS operating system provides us many UI components with the default design system. This default design system changes from time to time when Apple decides to refine or totally refresh the whole look and feel or only just some parts of it in some cases of the next big iOS release.

However one thing is sure about this design system. Its official name is Human Interface Guidelines and Apple designed it not only for iOS but all of its platforms such as macOS, watchOS, and tvOS. If you want to be a well-rounded iOS or macOS app developer then you should be familiar with these design guidelines.

Preview 16:36

In this SwiftUI tutorial, we’re going to create a complex layout for the new Settings view with SwiftUI in Xcode. Besides learning how to create a slick grouped list we will learn how to open external website links as well. Before we start coding, I think that it would help us to understand the layout design if we take a look at the final design and go through the building blocks one by one.


First, since we want to navigate from the main screen to the settings view by using a new button on the navigation bar therefore it’s obvious that we need to create a navigation bar as well. Inside this navigation view, there is a primary vertical stack that consists of two other parts.


The first element in this VStack is a form. You will see that Form View in iOS and iPadOS is very-very powerful UI component. When the size of its content is bigger than the size of the screen then it automatically provides us a scrolling functionality.


The second part of the container is a simple footer with only one text view. We decided not to put this text view inside the form because we want it to stick at the bottom of the screen on purpose. With this combination of the from and a text view inside a vertical stack container, we will get a very impressive custom layout design.

Let’s create an advanced Settings and learn how to open external website link
31:05

In this SwiftUI tutorial, we’re going to develop a new feature. The ability to change the app’s icon programmatically has been around for quite a few years. This cool feature allows users to switch between a predefined set of alternate icons developed in Xcode.

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.


Our goals in this iOS Development tutorial:

  1. How to create a predefined set of alternate icons using the Property List Editor.

  2. Then we’ll learn how to change the app icons programmatically

  3. Finally, we’ll leverage SwiftUI Pickers to allow users to choose their favorite icon from a list.


You know, every app needs a beautiful and memorable icon that attracts attention in the App Store and stands out on the Home screen. This new User-selectable apps icon feature provides more value for the Todo app.

By developing this functionality we let people select an alternate app icon from a set of predefined icons that are embedded within the app.

Let's develop a feature: How to create iOS Alternate App Icons with SwiftUI
37:02
Let's develop a feature: How to create App Themes with SwiftUI
02:10
+ PROJECT 05: Build Honeymoon a Tinder-Like iOS App with SwiftUI in Xcode
19 lectures 02:17:41

What we ‘re going to do in this SwiftUI tutorial is to build a gorgeous iOS 13 and iPadOS app with a Tinder-like user interface design. Since swiping motion is quite a popular mobile UI pattern nowadays, that’s why we’re going to dive into gestures with SwiftUI in this section. The app presents users with a pile of Honeymoon destination cards and allows them to use the swipe gesture to like or dislike a card.

Preview 02:07

In this class, we’re going to develop a modern iOS and iPadOS mobile app with swipe motion powered by the SwiftUI framework. Having said that, we will dive into some advanced gesture techniques in this section. The app presents users with a pile of Honeymoon destination cards and allows them to use the swipe gesture to like or dislike a card. This could be a great portfolio app that you can show up with confidence in your job interview.


Without further ado let’s set up our SwiftUI project as usual. Download the resource files from this section. Place it to the Desktop and unzip it by clicking on the package. The provided main folder contains 3 folders marked with the Swift logo and a supplementary workbook files with the objectives in PDF and ePub formats.


As you know by now, the completed project is in the green folder. This finished project with the source codes may help you when you are stuck and need some quick help.


The next folder is the red one. This contains all of the resources you will need to build the Honeymoon app.


Finally, you can save your project in the blue folder. We are going to create and save your app in this place. That is why it’s empty for now. All right, our first step is to launch the Xcode, then we need to create a new Xcode project.

Let’s set up the Honeymoon Destination iOS 13 project in Xcode
09:38

In this lecture, we will create a very simple ‘Launch Screen’ with a stretching color gradient background and a logo in the center of the screen in Xcode.

Just a reminder: Usually, when we try to add a new image and we want it to fill out the whole screen we fell into difficulties because Xcode is in favor of using the safe area by default. Today I will show you a really easy way to prevent this default behavior using a Storyboard file.

Preview 04:58

In this lecture, we are going to create a card layout for the individual Honeymoon destination with SwiftUI in Xcode. Shortly after the Launch Screen, we should see the Honeymoon card with a photo of the Eiffel Tower in Paris. It’s a great place to continue our journey, isn’t it? See you at the class!

How to build up the layout of the individual Honeymoon Card view
09:33

In this class, we’re going to create the Header view for the Honeymoon app with SwiftUI in Xcode. This header will contain two buttons on the edges and a logo in the center part of the screen. Let’s ‘Build and Run’ the app in the simulator or on a real device before we start the next class, shall we?

Slowly but surely we’re building up the Honeymoon app as you can see in this iOS Development tutorial. The footer view will be our next target.

Let’s develop the Header layout of the Honeymoon App with SwiftUI
04:30

In this SwiftUI lecture, we’re going to create the Footer View for the Honeymoon app. This footer will contain two images on the edges and a button in the center part of the screen. Until this point, we were practicing which we have learned in the previous lectures using Xcode. In the following classes, we will learn about new iOS Development features and techniques. See you at the class.

Let’s develop the Footer layout of the Honeymoon App with SwiftUI
04:16

In this SwiftUI class, we will create reusable components with SwiftUI. With the use of these components, we will write less code later on. Without further ado, let’s jump into Xcode. The first component contains a handlebar and the Honeymoon logo.

Pay attention to the last modifier, which is the ‘fixed size’. Basically, it helps to render the text view’s dimensions. In this case, we want to make sure that the height of the text will be expanded even if the parent view is smaller than the dimension of this text view. The ‘vertical: true’ value will force the rendering engine under the hood to preserve its ideal height and do not allow to truncate the text.

How to create reusable components and write less code with SwiftUI
08:15

It’s time to use the components which we created in the previous lectures. In this SwiftUI class, we’re going to create a new view for the guides of the Honeymoon application. I think that it was worth typing so many strings in this lecture because, in the end, we built up a modern and eye-catchy layout for the guides in Xcode.

What do you think? Are you ready for some advanced topics on SwiftUI like data bindings and environmental objects? Let’s figure it out at the next class!

Let’s create a new view for the guides of Honeymoon App
07:00

In this lecture, we will learn how the @Binding property works with SwiftUI in Xcode. Our main goal is to show an 'Alert' window when a user taps on the ‘Book Destination’ button on the footer. Basically, we will make the Footer view to communicate with the main ‘Content View’ and share a piece of information with each other.

So, what is the @Binding property wrapper in the iOS development anyway? The @Binding is one of SwiftUI’s less used property wrappers, but knowing how it works is still hugely important. The @Binding property lets us declare a value in a view and share this value with another view. Having said that when this value changes in one view then it will also change in the other view.

Preview 06:49

In this iOS development class, we’re going to present the guide's view using bindings with SwiftUI. After that, we will learn how to dismiss this view by using the app environment presentation mode in Xcode.

Show views with Binding and dismiss views with Environmental objects
05:20

In this iOS development lecture, we will practice what we have learned before. We’re going to create a new view with some information about the Honeymoon application and give credits for the photographers. Just a gentle warning: I’m going to dictate a slightly faster tempo in this SwiftUI class.

Some folks might think that creating this kind of layout for static content is not so important, but in my opinion, the real difference between a good and a great SwiftUI app often comes from the little details.

Let’s create a new view for the credits and app info
12:40

In this short SwiftUI lesson, we’re going to present the Info view by using the SwiftUI sheet and dismiss it by the presentation mode environment property. Without further ado let’s jump into Xcode.

Everything is working like a charm. So far you learned a ton of useful features with SwiftUI but the main topic is just coming: using gestures and creating swipe motions with SwiftUI.

Show views with Binding and dismiss view with Environmental objects (exercise)
04:27

With all of the previous preparation in Xcode, finally, we’re going to start the implementation fo the Tinder-like user interface with the swipe gestures.


Just a quick disclaimer before we start coding:

This is a slightly advanced SwiftUI topic and you may find it a little bit difficult to understand the logic and the code implementation how the app works at first sight. If you are a total beginner, please, don’t be disappointed or discouraged if you don’t understand something. Later on, in this masterclass, we will learn the very basics of how gestures work with SwiftUI. In this section, just concentrate to understand the big picture and follow me step-by-step.

All right, after this gentle warning let’s talk about the main mechanics of this app. You can imagine this app as a deck of piled cards. Each card shows a photo of a Honeymoon destination.


THE MAIN PROBLEMS:

While we successfully implemented the card deck, we actually have got two serious issues.

  1. The first issue is the following: The first destination is supposed to be the highest card, however, it’s now the lowest card in the deck.

  2. The second issue is the following: We rendered all of the 21 card views at the same time. What if we have a thousand cards or even more in the future? Is there a better and resource-efficient way to display the card deck?

The answer is YES! Without further ado, let’s start coding.

Let’s implement the card deck with a computed property
12:35

How to implement the Swiping Motion with SwiftUI: We’re going to implement the swipe feature first before we dynamically remove and create new cards. Yet again this a fairly advanced topic, so if you haven’t worked with gestures intensively using SwiftUI then I highly recommend you to watch the section about the basics of gestures in the course.

First, we define the possible states of the drag gesture. To represent the drag states we’re going to use a new enum.

This Drag State defines and represents all of the stages for our custom swipe gesture.

As you can see, basically we have 3 stages of this drag gesture:

  1. The first state is for when no gesture happens. This is the inactive state.

  2. The second one when a user taps on the screen. This is the pressing state.

  3. The last one when the actual drag gesture is happening.

After the states enum creation let’s define a new @GestureState variable to store the drag state we discussed before.

How to develop the Swiping Motion with SwiftUI
13:18

Let’s display the Heart and X-mark symbols during the swiping motion. The SwiftUI drag gesture of the Honeymoon app is now working. How cool is that! In this iOS development tutorial, we’re going to display the heart and x-mark symbols depending on the swiping direction when a user drags the topmost card to right or left.

Preview 07:10

The Honeymoon app is almost done, but I'm afraid that one more main functionality is still missing. Now, when we release the card it returns to its original position. Let's create a new function in Xcode.  In this SwiftUI lesson, we’re going to remove the topmost card and add a new one at the same time. Don’t skip the next class because I have more exciting features to show you!


How to remove and insert the cards
05:41

The Honeymoon SwifTUI app’s functionality is done, but when it comes to the user interface and user experience design it falls short of expectation. For example, one area that we could improve is the card’s movement when the user releases the card.

Instead of having the card disappearing suddenly, the card should fall out of the screen smoothly when it’s thrown away. To fine-tune the animation, we will attach a new `transition` modifier and apply an asymmetric transition to the card views. Without further ado, let’s jump into coding with Xcode.


Enhancing the animation with custom transitions with SwiftUI
06:10

With SwiftUI, we can easily build some cool animations and other modern UI patterns. However, we can enhance the user experience even more by using sounds and haptic feedback in Xcode. That is exactly what we are going to do in this lecture.

We start by creating an audio player. Then we will add different sounds in multiple places. You might ask what’s next?  And the answer is predictable: Haptic feedback. iOS has some nice predefined haptic feedback such as error, warning, and success.

We’re going to implement the success haptics in the Honeymoon app.

The process is quite simple and easy to follow. We need to write only 2 lines of codes for each haptic feedback.

Congratulations!

This application is quite impressive for sure. You have just finished Honeymoon a Tinder-like app with some advanced gesture features. You can use this app in your portfolio and even show up with it in your next job interview if you wish. The more app you build the more confidence you gain in your developer journey.

I hope that you enjoyed this course so far and I can tell you that more is coming! Just one thing. I would appreciate it so much if you could take the time to give me a star rating or even better if you could share your learning experience with other students by writing a review for this course.

If you wish you can always send me a question or even recommendation about the masterclass. I would be glad to read your success stories too.

Until then, happy coding!

Implementing new haptic feedbacks (success) and playing sound effects
12:00
+ Swift Programing Language Fundamentals
1 lecture 00:01
Get started with Swift programing language and learn all of the fundamentals
00:01
+ New SwiftUI Application (June 2020)
1 lecture 00:01
New SwiftUI Application (Release Date: June 2020)
00:01
+ New SwiftUI Application (July 2020)
1 lecture 00:01
New SwiftUI Application (Release Date: July 2020)
00:01
+ New SwiftUI Application (August 2020)
1 lecture 00:01
New SwiftUI Application (Release Date: August 2020)
00:01
Requirements
  • macOS Catalina from Apple (free)
  • Xcode 11 from Apple (free)
  • Willing to create awesome apps by following the instructor step by step
  • You do not need any other prior programming experience or knowledge
Description

IMPORTANT INFORMATION BEFORE YOU ENROLL IN THE MASTERCLASS

Please keep in mind, that this masterclass is under active development. The course is already more than 11 hours long and it will be more than 20 hours long by the end of this year.  Each month I release another exciting and practical project about how to build a new application from scratch or other useful learning material about app development.


UPCOMING UPDATES + WWDC 2020

You may be glad to hear from me that, this summer there will be two new complete sections published about Swift programming language fundamentals and SwiftUI fundamentals. Besides that, more exciting iOS 14 projects are coming shortly after WWDC 2020 as well.


WHY YOU SHOULD GET THIS COURSE

Visually learn SwiftUI and build top-notch iOS 13 apps, iPadOS apps, Apple Watch apps, and even macOS apps! Introducing the complete SwiftUI Masterclass Course that will become your quickstart reference guide in the iOS 13 App Development.


HANDS-ON PROJECTS


  1. SWIFT Language Fundamentals (coming soon)

  2. PROJECT: Developers Card App

  3. PROJECT: Avocado Recipes App

  4. PROJECT: Slot Machine Game iPhone, iPad, Mac App

  5. PROJECT: Todo App with Core Data, App Themes, and Alternate App Icons

  6. PROJECT: Honeymoon Destination App

  7. SWIFTUI Fundamentals (coming soon)

  8. ...and much more SwiftUI project to come in 2020 and 2021.


Let's face the truth that most SwiftUI and even iOS development courses teach you how to build ugly and hideous applications but not this one. ⭐️


Do you want to create eye-catchy apps with SwiftUI? Then this course is for you!


Would you like to show your apps to your friends, co-workers, even family members and make them look up to you? ⭐️


If yes, then enroll in the best SwiftUI course and create 1st class apps!


Moreover, are you eager to build up your professional portfolio and show up in your next job interview with confidence?  By the way, your new employer will be impressed by your work so much for sure. ⭐️


You know, you should definitely take this SwiftUI and iOS 13 Masterclass course!


Learn faster with the up-to-date Swift code examples! You are in good hands ⭐️


  • Do not waste time getting lost and bored looking at endless and outdated tutorials and code examples on the Internet!

  • You will grasp the Apple's latest SwiftUI framework quickly and easily by following the instructor line by line. 


Welcome to the world’s best iOS 13 Development with SwiftUI Course ⭐️


This up-to-date SwiftUI course contains step by step instructions to teach you how to build several fully-fledged iOS, iPadOS, macOS, and even watchOS applications.


What’s in it for you? ⭐️


As a student on this masterclass, you're going to create dozens of eye-catchy apps with the latest and greatest technologies that Apple has recently released such as:


  1. SwiftUI is a declarative user interface design framework,

  2. Combine framework helps developers work with events,

  3. Catalyst is designed to allow developers to Bring their iPad apps to Mac.


In case, if you're someone who wants to get a job as an iOS or macOS developer then this masterclass is perfect for building up your professional portfolio to show off at your next interview. They will be interested in your work after all.


On the other hand, if you're somebody who wants to build your very own apps for your startup business then in addition to all of the coding tutorials I've also included full exercises on user interface design and app animation too.


You should know that this course assumes absolutely no programming experience. So if you're a complete beginner then I'll be there for you and guide you in this program.


Finally, if you're an experienced developer, on the other hand, I'm sure that you are going to find plenty of advanced Swift 5 programming best practices as well.


That being said, by the end of the course you'll know how to develop, design, and publish your next app into the Apple App Store.


So what are you waiting for? ⭐️ Join in this SwiftUI Masterclass course now!

Who this course is for:
  • If you are a beginner iPhone developers curious about iOS development, then jump straight into this course
  • For Advanced iOS and macOS developers eager to learn SwiftUI framework
  • If you want to get a job as an App developer, then take this course
  • If you are going to build and publish your App to Apple's App Store, then start this SwiftUI course and get up speed quickly with the latest iOS development