Logomark
Top-notch video tutorials for developers.

Thousands of developers use NSScreencast to stay on top of iOS development.

Video Training for iOS Developers

The iOS landscape is large and changes often. With short, bite-sized videos released on a steady schedule, NSScreencast helps keep you continually up to date.

  • Quality content We stress the details. Each screencast is carefully produced in HD quality.
  • Team Plans Get access for your whole team. NSScreencast makes for great lunch & learns.
  • Any Device Stream on the web, or use one of our apps for  tv, iPhone, and iPad.
Keep up with iOS Development

NSScreencast has been releasing a new screencasts regularly for more than 6 years. With short videos you can learn a lot over time without a huge time commitment.

NSScreencast offers the largest collection of iOS development screencasts on the internet. With the range of videos that NSScreencast offers, there is something for people of every skill level.

Bite-sized screencasts on iOS and Mac development.

Displaying Episode 25 - 48 of 464 in total
lock
#440
It can be cumbersome to pass values from parent to child view to configure something. For instance, setting a font for many Text views inside of a VStack. Luckily there is a .font() modifier that can do this for you. How does it work? It sets a value in the Environment using an EnvironmentKey. In this episode we will learn how to leverage the SwiftUI environment to pass values to descendent views, regardless of their depth from where it is set.
lock
#439
Using Preferences we can communicate data, such as the actual size of a view, to any ancestor view. By taking advantage of the reduce function required by the PreferenceKey protocol, we can combine multiple values in whatever way suits our needs. In this episode we will use this technique to size a bunch of sibling views equally by collecting the biggest width and then pushing this value down to subviews with some parent state.
lock
#438
In SwiftUI we use State to push values from a parent to a child. What if you want to go the other way, passing data about a child up to a parent? To do this we can leverage Preferences. In this episode we will see how to define a custom preference key, how to use an overlay with a GeometryReader to measure the size of a view, and then set a preference with the view's size. Then we'll learn how to respond to preference changes in an ancestor view.
lock
#437
Buttons in SwiftUI are much more flexible than UIButton in UIKit. For starters, there is no assumption that our buttons are just text or an image, they can use any view whatsoever for the content, which is called the "label". Using Button Styles we can create buttons in whatever shape or form we desire. In this episode we create three different button styles using SwiftUI to show how flexible they are and how easy they are to reuse.
lock
#436
With extensions we can encapsulate common layout and styling logic that can be reused across many views, however they do have limitations. In this episode we will see how we can create View Modifiers that allow you to leverage @State and other View-related behavior and apply this behavior to arbitrary views.
lock
#435
In UIKit we use imperative code to do things like display alerts, but in SwiftUI we have a declarative structure. In this episode we will see how this changes how we work with alerts. We'll look at two ways of showing alerts, one with a simple boolean state variable, and one with a bindable identifiable type that is passed to our alert, which we use to show a specific error message if an operation fails.
lock
#434
In UIKit we've often lamented the fact that there is no builtin facility to load an image with a URL, leaving developers to implement this on their own. In SwiftUI the situation is the same, however we have more flexibility to build what we need. Using a Swift package called FetchImage, we will create a reusable ImageView struct that can load our images efficiently given a URL.
lock
#433
With SwiftUI views we no longer have view controllers, and this can pose the question: Where does our data access and networking code live? In this episode we will load some data from a movies API in order to examine the ObservableObject protocol.
lock
#432
The Breathe app on watchOS has a really excellent animation. In this episode we attempt to recreate this animation in SwiftUI using offsets, rotation, and scaling, then making the animation repeat forever.
lock
#431
SwiftUI is really fun and easy to work with, but what if you need to work with a view that already exists? This episode covers the UIViewRepresentable protocol and we use it to provide a UIActivityIndicatorView to SwiftUI. The same approach can be used to wrap your own custom UIViews as well.
lock
#430
In this episode we add the ability to provide modal content from outside of the modal view. To do this we can leverage @ViewBuilder which is a type of Function Builder. This is a new Swift feature that gives SwiftUI's syntax a DSL rather than writing out vanilla Swift syntax.
lock
#429
In this episode we look at designing a modal card that takes advantage of ZStack, HStack, VStack and the Spacer helper.
lock
#428
The Keychain is the best place to store sensitive data such as API keys, auth tokens, and login credentials. On device the data is stored encrypted. Once unlocked, you can retrieve the values you saved, keeping the sensitive data secured by the user's passcode, Face ID, or Touch ID. Using the keychain is not very straightforward, however. It has a low-level C-adapted API and is a little cumbersome to work with. In this episode we will look at how to add, query, and remove items from the keychain, then look at a popular open-source library for making storing values in the keychain much easier to implement.
lock
#427
Property wrappers are turning out to be super useful! In this video we'll look at an open-source library called ValidatedPropertyKit, which gives you property wrappers for validating user input. With it you can check for ranges, non-empty strings, regular expressions, or extend it with your own.
lock
#426
Last time we saw the manual approach to parsing XML. While ultra flexible, parsing XML that is extremely tedious. In this episode we will examine a different approach using Codable and a 3rd party library that adds support for XML. We'll see how XML's flexibility adds some increased complexity with how to parse documents, how to control whether properties are encoded/decoded as elements or attributes and how to deal with nested arrays.
lock
#425
Sometimes legacy APIs that we have to deal with only support XML, and while Swift has first class support for JSON with Codable, XML parsing is still done with Foundation's XMLParser. This is a powerful yet difficult to use class that is modeled as a streaming XML parser. This means you have to write some code that keeps track of the values and state of where we are in the XML document in order to parse it. In this episode we will cover how to parse an XML document using multiple objects, parsers, and a delegate stack.
lock
#424
When working with Codable models, everything is great until you deviate even slightly from the normal behavior. Doing so requires you to drop down to a more manual approach where you have to define your own CodingKeys enum and encode/decode methods. In this episode we will look at a 3rd party set of property wrappers that give you some handy Codable functionality for free.
lock
#423
Swift 5.1 introduced a powerful new feature to the language: Property Wrappers. In this video we will take a look at how to write property wrappers and how to use them to simplify code in our apps.
lock
#422
In the last episode we had a bit of an issue... I was trying to store an enum value in UserDefaults, thinking it would automatically use the backing rawValue to store and load the value. Unfortunately this doesn't work. In this episode we fix this issue and extend our solution to also accommodate other data types by leveraging Codable and a custom protocol.
lock
#421
UserDefaults is quite a handy class for storing user user preferences and lightweight data. However the data is keyed by strings and there's no enforcement of any schema or validation of the data you put in it. In this episode we will look at a technique for making strongly typed access to data in UserDefaults so that we can avoid mistakes when typing the key name or the type of data intended to be written to that key.
lock
#420
Now that Swift Package Manager has started to see some adoption and we have some integration inside of Xcode, I think it's time to take a deeper look at how to use it both as a consumer and as a library author. In this episode we'll create a DiceKit library using SwiftPM, then use it in a command line utility.
lock
#419
To wrap up this series, we add a new model to track and persist the progress of playing episodes. We also restore the player and playback position when coming back from a cold launch.
lock
#418
In this episode we create the UI for our playlist screen, showing episodes from each of the subscribed podcasts. On this screen we combine NSFetchedResultsController with UITableViewDiffableDatasource so that our playlist screen can react to changes to the underlying data and reload as necessary. We do this using the automaticallyMergesChangesFromParent on our NSManagedObjectContext.
Shape
#417
Before Swift 5 we used to write our own Result type to contain a value or an error (but never both). A lot of 3rd party libraries brought along their own as well. Then Swift 5 came and brought us Result. Not only is it slightly different than the ones we might be familiar with, Swift's Result type also has some useful functionality up its sleeve.