Building Responsive and Adaptive iOS App with UICollectionView
UICollectionView is an
UIKit view that manages collection of ordered items and presents the items using customizable layout. It was introduced by Apple in WWDC 2012 with the release of iOS 6 SDK.
UICollectionView interface is quite similar with the old
UITableView as it provides DataSource as a source to display the data and Delegate to handle interaction for each item.
UITableView that display each row using a fixed list layout inside
UICollectionView provides flexibility and customizability for developers to provide their own layout by subclassing
UICollectionViewLayout, it also supports custom decoration view, customizable size for each individual section view and cells. Apple itself provides us one layout out of the box to use called
UICollectionViewFlowLayout is the layout that displays items using grid system, with supports of headers and footers. It also provides 2 scroll directions, vertical and horizontal.
In vertical direction, the width of the item is constrained with the width of the collection view, so in each row it will try to fill as many item as possible inside the bounds of collection view width before it falls down to the next row so user can scroll the content vertically.
While on the horizontal direction, the height of the content is constrained with the height of the collection view, so in each column it will as many item as possible before it moves right to next column so user can scroll horizontally. Horizontal scroll direction is very suitable if you want to build a carousel using collection view.
What We Will Build
In this article we are going to build a responsive movie list app that is adaptive to various form factors from the small iPhone 5 up to largest iPad Pro using
UICollectionViewFlowLayout. Users will have the options to display the movies using list, small grid, and large grid layout. Here are the tasks that we will be doing:
- Starting the project.
- Building the Model.
- Building the
- Building the List Layout.
- Building the Grid Layout.
Starting the project
To begin the project, you can download the starter project in the GitHub repository below.
Starter project for Responsive and Adaptive iOS App with Collection View …github.com
The starter project contains several assets, collection view cells for list and grid item layout that we will use for the Collection View.
Building the Model
Let’s create our model to represent the Movie. Create a new File and name it
Movie.swift. Copy the declaration below to create the
Movie struct with all the properties.
We will also create another model to represent to Layout using enum. The
LayoutOption enum will have 3 unique cases that represent the list, small grid, and large grid.
Building the MainListViewController
Let’s create our only View Controller for the app. Open the
main.storyboard file, drag the Collection View Controller from the Object Library to the scene editor. Then embed it into a Navigation Controller. Select the Collection View, then set the background color to
#292A2F in the attributes inspector.
Next, create a new File and name it
MainListViewController.swift. It is a subclass of
UICollection ViewController. Here are the things that we will setup initially:
- Instance properties to store the model and the layout option. Here we will use stub movies array to drive the Collection View Data Source and list layout as the initial layout option.
setupCollectionView(). Register the list and grid cells from the Nibs.
setupNavigationBarItem(). Setup bar button item with target action selector that trigger the alert controller action sheet presentation for the user to select the layout option.
setupLayout(with:). Adjust the Collection View FlowLayout item size, spacing, section insets in relationship with the container size passed, layout option selected, and current trait classes.
- Implement the
collectionView(collectionView: numberOfItemsInSection:). This will return the number of items in movies array.
- Implement the
collectionView(collectionView:,cellForItemAt:). This method will use switch statement for the layoutOption property then based on the case will dequeue the list and grid cell respectively. The movie property will also be passed into the cell to be displayed based on the attributes.
Building the List Layout
Let’s build the list layout, in this layout, the cell items will render like
UITableViewCell with subtitle style plus an
UIImageView. Take a peek in
MovieLayoutListCollectionViewCell provided by the starter project to see the layout.
setupLayout(with:), we will get the collection view flow layout instance and perform switch statement on the layout option. In list layout, when the horizontal trait class is compact, each cell will take the full width of the collection view, other than that it will use 300 minimum item width, then calculate the maximum number of item inside the row, and readjust the size if there is any fraction remainder when calculating the items in the row. The height for the item will be fixed at 91.
In situation where the horizontal trait class is not compact, such as using iPhone Plus, XS Max in landscape, any iPad the item will be divided into at least 2 columns, the columns will increase when the width of the device increases. We also set the section insets for top and bottom with the value of 8 to add some spacing.
Because our app supports multiple orientation, we need to make also trigger the layout update with the new size when the device is rotated or the device trait classes has been updated. There are 2 methods that we should override:
viewWillTransition(to:coordinator:). This will be invoked whenever the orientation changes.
traitCollectionDidChange(previousTraitCollection:). This will be invoked whenever the trait classes gets updated.
We also need to make sure to update the
MovieLayoutListCollectionViewCell, in here we create a method
setup(movie:) so we can setup the label and image view when the movie is passed.
Build and run the project to see our list layout in action, try to run using devices like iPhone XS Max and iPad Pro in various orientation to see the list columns.
Building the Grid Layout
Let’s build the grid layout, in this layout each cell will display only the poster image of the movie inside each cell. Take a peek in
MovieLayoutGridCollectionViewCell provided by the starter project to see the layout.
We will add additional case for small grid and large grid cases inside the
setupLayout(with:). In here, we will declare the minimum item size width for small grid to be 106 and for the large grid to be 160. Then, using the same technique as the list layout, we will calculate the maximum number of item in row by dividing the collection view width with the minimum width, then use the remainder fraction to find the adjusted width to fit the row. The movie poster will have the aspect ratio of 3:4, so based on this we will calculate the height of the cell using the adjusted width we calculate before.
Make sure to update the
MovieLayoutGridCollectionViewCell, in here we create a method
setup(movie:) so we can setup the image view when the movie is passed.
Build and run the project, then tap on the bar button item to change the layout to small or large grid to see our grid layout option in action.
Finally, we have successfully build responsive and adaptive iOS app using Collection View, congratulations!!. Building an adaptive and responsive iOS app is not that hard with the help of Cocoa Touch Trait Classes combined with
UIKIt classes like
UIStackView. It also provides us advantage so we can utilize just one single codebase for iPhone & iPad for better maintainability. Keep up on lifelong learning and Happy Swifting 😋.
You can clone the completed project source code GitHub Repository below: