First introduced in iOS 13, UICollectionViewCompositionalLayout is an amazing and powerful addition that gives you lots of flexibility when describing layouts. There are a few new types to get used to (namely sections, groups, and items) but they all work together allowing you to keep layout separate from your views and your data.

NSScreencast (free videos)

#453 - Compositional Layout

With UITableView no longer being encouraged for use, we need to replace this behavior with UICollectionView. This is where UICollectionViewListLayout comes into play. Using this layout we can get the familiar table view appearance in plain and grouped styles (as well as additional styles to support sidebars on iPad and macOS). This includes support for sticky headers and footers, swipe actions, and other UITableView behaviors that we've come to rely on.

#452 - Collection View List Layout

In this episode we migrate our collection view to use the new cell registration API. Using this API we no longer need to cast dequeued cell types to our custom types. Instead, we set up the registration object with the cell type and the data we'll be passing to each cell. This further reduces the code we have to write in our datasource implementation and gives us more flexibility on how and where cells are configured.

#451 - Cell Registration

In this episode we review the basic example app and start setting up our collection view in code. We start with the basic flow layout which is most common. Later we'll refactor this to use the newer style, but this episode introduces the series and sets up the foundation we'll build upon.

#450 - Setting Up

With the introduction of LazyVGrid and LazyHGrid In iOS 14 we now have access to much more powerful grid-based layouts in SwiftUI. In this episode We will examine the different types of layouts we can accomplish with flexible, fixed, and adaptive sizing for our rows and columns. We'll look at how animations work between different layouts, and how to consider larger screen sizes.

#445 - SwiftUI Grids

A few episodes back we covered how to wrap a UIActivityIndicatorView to show loading progress in SwiftUI. Now in iOS 14 this is built in. In this episode we'll cover the various styles, how to hook it up to a Progress instance, and how to create your own custom progress visualizations.

#444 - SwiftUI Native Progress Views

iOS 14 Beta is now available and one of the new features is Lazy stacks. With a normal stack, all the layout happened at once, which meant poor performance for large lists of content, grids, etc. With Lazy stacks the views are only created when they first come on screen, greatly increasing the usefulness of stacks for large or infinite collections of content.

#443 - SwiftUI Lazy Stacks in iOS 14

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.

#417 - Swift 5's Result Type

Sometimes we need to create variants of our icons. This can be done by using template images and using a UIImageView with a tintColor change, however sometimes this isn't feasible. We can use our icons along with a mask to create new images of whatever color we want. In this episode we'll use UIGraphicsImageRenderer to quickly draw a new dimmed image for a highlighted button state.

#406 - Tinting an Image Using Masks

Attaching gestures works quite a bit differently in SwiftUI than in UIKit. In this episode we will look at the @DragGesture property wrapper and how we can use gestures to update custom state that we can then use to transform our UI.

#400 - SwiftUI Gestures

SwiftUI's declarative nature makes building UIs incredibly easy. In this episode we will build a wallet UI with cards. We will create a CardView so we can reuse it in multiple places. Then we will use transforms to alter it's size and position. Finally we will see how declarative animations work as we expand the cards apart.

#399 - SwiftUI Transforms and Animations

Now that we've seen a taste of SwiftUI, let's dive into a real example and build an app. We'll have a first look at @State variables we can use to creating a binding between our state and our UI, and we'll run into a few puzzling errors and see how we can coax Xcode into giving us the right error message.

#397 - Tip Calculator in SwiftUI

Back from WWDC 19 and blown away by the announcements. There's a lot to cover, but we'll start by digging into the most exciting announcement: SwiftUI. This is going to change everything...

#396 - Hello, SwiftUI!

Working with dates is a task that is universally applicable to Swift developers. Particularly when dealing with an API, dates can arrive in all shapes and sizes. We‘ll examine some of the common ones such as ISO 8601, show how to parse these formats into Date instances, and how to use DateFormatter to display them back again as a string. We‘ll also cover the importance of using en_US_POSIX and honoring the user‘s Locale when displaying dates.

#367 - Parsing and Formatting Dates in Swift

In this episode we configure our iOS app to receive push notifications, adding the OneSignal SDK to our project, configuring the Notification Service extension, and testing it out on a real device.

#356 - Integrating Push Notifications - Part 2

NSScreencast features weekly bite-sized videso on iOS development. This free feed is just a sample of what is available for members. Subscribe today at https://nsscreencast.com.

hubhopper

NSScreencast (free videos)

hubhopper