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.

There are 46 episodes with tag 'uikit'   Clear search
lock
#484
Another common use of context menus is with table views and collection views. In this episode we will explore adding a menu to a table view cell that allows copying a font or toggling it from a favorites list.
lock
#483
In this episode we will see how to nest menus inside each other as well as dynamically choosing when to show a nested menus contents inline.
Shape
#482
Context menus are a great affordance for performing related actions to a UI element. Users can tap and hold to view the context menu, and the gesture is consistent across the OS so users will likely already be familiar with it. In this episode we'll show how to set up a basic context menu with a custom preview with normal and destructive actions.
lock
#479
Working with NSAttributedStrings can be a bit cumbersome, and can present some challenges when you want to localize your strings. We can make things much easier to work with by leveraging the BonMot library, which provides a cleaner interface for styling strings, allows us to separate styling from the views and strings, and customize tags we can use to mix styles in the same string.
lock
#478
Sometimes our text contains links that should be styled differently and react to taps so a URL can be opened in a web browser. While we can use a UILabel to detect and style links, they don't respond to touches. Let's see how we can leverage UITextView instead to handle links in NSAttribtedStrings.
lock
#477
To work with styled text we'll use NSAttributedStrings, which allow us to apply styles to ranges of text. Doing this in code is a bit more cumbersome than in storyboards, but allows us to control things like font size, color, style, kerning, line spacing and more.
lock
#476
The built-in way of adding constraints in code requires quite a bit of code and is a bit cumbersome to write. I believe that we should aim to reduce friction when writing code like this to make it easier to add new views and change your layout. SnapKit is a pretty useful dependency that gives you a DSL for making autolayout constraints. In this episode we'll integrate SnapKit into the project and simplify our existing layout code.
lock
#474
One really useful UIView subclass I generally have on all my projects is a simple GradientView. You give it two colors and optionally some location values and it draws a gradient from top to bottom. In this episode we build this so that we can integrate a fade to black effect to overlay on top of the background image.
lock
#473
In this episode we will see how we can leverage SwiftUI's live previews even if we aren't using SwiftUI and even if our deployment target is less than iOS 13! We'll cover previewing our view controllers and using that to give us rapid feedback on our layout as we work.
lock
#472
When working on a project that doesn't use Storyboards, we have to create our window and root view controller manually. iOS 13 introduced the concept of Scene Delegates, which change how this is typically set up. In this episode we will review how to set up a new project, remove the storyboard references, and set up the window and root view controller in code.
lock
#470
One of the quickest ways for an app to give some personality and branding is to customize the type of buttons in the app. Out of the box iOS gives us a rather uninspiring blue label that is known to be a button, but it is common for apps to have their own button design. In this episode we will take a stylized button design from Dribbble and implement it as a custom component. We'll build it in a playground so we can see our work quickly, and we'll create custom previews (similar to SwiftUI) for viewing multiple states of the button at the same time.
lock
#459
Using Item Anchors we can position decoration views anchored to our layout items. This is could be used to outline or underline items, or in our case to add a little unread indicator badge to our items.
lock
#458
Not every layout will be appropriate for every screen size. In this episode you'll see how you can use the layout environment when constructing your compositional layout to provide a more suitable layout for iPad.
lock
#457
One of the things you'd get for free with UITableView in the grouped style is a nice rounded rect background around your sections. With UICollectionView, you can implement these with background decoration views. We'll see how to set these up in our compositional layout to give the series section a different feel.
lock
#456
Our Diffable Datasource and snapshots are generic over the type of data that we pass to the cells. So how can we make sections with completely different data? In this episode we'll cover one approach which involves defining an enum with associated data for each of the sections. We'll use this to add a Series strip of data mixed in with our collection view.
lock
#455
In this episode we'll make a custom header view to give some of our sections a title. The approach we use here with compositional layout is more flexible than with UITableView. We'll start with a UICollectionReusableView implementation for our header, add the desired item to our layout, and then vend the desired view using the datasource's supplementaryViewProvider.
lock
#454
Diffable datasources provides a great API for driving your collection view updates in a transactional, state-driven way. We no longer have to manually call insert/delete/move rows when the data is changed. Instead, we apply a new snapshot and the changes are made for us, including animations.
Shape
#453
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.
Shape
#452
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.
Shape
#451
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.
Shape
#450
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.
lock
#415
One of the features of iOS 13 that has not gotten much attention is the new diffable datasources for UITableView and UICollectionView. Using UITableViewDiffableDataSource or UICollectionViewDiffableDataSource along with NSDiffableDataSourceSnapshot you can create safe, animatable changes between two states without having to keep track of which records were added, moved, or deleted. It's seriously great!
lock
#408
We take our player bar and install it into a custom tab bar. To do this we have to create a custom tab bar controller and tab bar subclass and mix it with just a little bit of questionable UIKit hackery to get it to layout how we want. We'll talk about the tradeoffs for different approaches as well as see some useful debugging tips when a button isn't responding to taps.
Shape
#406
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.