Unit 5: iPhone Project Templates - Subjective Questions

Navigation controller: A UINavigationController is a container view controller that manages a stack of view controllers.

• The first view controller in the stack is called the root view controller.
• New view controllers are added using the pushViewController method.
• The current view controller can be removed using the popViewController method.
• It automatically provides a navigation bar containing a title and navigation buttons.
• It maintains the user's navigation history and supports back navigation.

Navigation controllers are useful for applications that require hierarchical navigation, such as moving from a list screen to a detail screen.

A navigation controller can be created in Interface Builder or programmatically.

Programmatic steps:

• Create the initial view controller.
• Initialize a UINavigationController with the initial view controller as its root.
• Set the navigation controller as the application's root view controller.
• Use pushViewController to display another screen.
• Use popViewController to return to the previous screen.

Example:

let detailController = DetailViewController()
navigationController?.pushViewController(detailController, animated: true)

The navigation controller manages the view controller stack and automatically updates the navigation bar when screens are pushed or popped.

Auto Layout is a rule-based layout system used to position and size interface elements on different screen sizes and orientations.

Constraints define relationships between views. They may specify:

• Horizontal and vertical positions.
• Width and height.
• Margins and alignment.
• Relationships between neighboring views.

For example, a label may be constrained to remain centered horizontally and positioned a fixed distance below an image view. Auto Layout uses these relationships to calculate the final frames of views at runtime. It supports different iPhone sizes, multitasking layouts, Dynamic Type, and device rotation without requiring separate fixed layouts.

A responsive interface can be designed with Auto Layout by following these steps:

• Add the required views to the view hierarchy.
• Define horizontal and vertical constraints for every view.
• Specify sufficient constraints for position and size.
• Use safe-area guides for content that should avoid the status bar, notch, or home indicator.
• Set content hugging and compression resistance priorities when views compete for space.
• Use stack views to simplify the layout of vertically or horizontally arranged controls.
• Test the layout on different screen sizes and orientations.

A view should have an unambiguous position and size. Missing or conflicting constraints can cause warnings and unexpected layouts.

Frame-based layout:

• Positions views using explicit coordinates and dimensions.
• Is simple for fixed layouts.
• Requires manual adjustment for different screen sizes and orientations.
• May produce overlapping or incorrectly sized views on other devices.

Auto Layout:

• Positions views using constraints and relationships.
• Adapts automatically to different screen sizes.
• Supports rotation, localization, Dynamic Type, and accessibility requirements.
• Can involve more initial configuration and may produce conflicts if constraints are incorrect.

Auto Layout is generally preferred for modern iPhone applications because it provides better adaptability and maintainability.

AVAudioPlayer is used to play local audio files such as MP3, AAC, or WAV files.

General procedure:

• Import the AVFoundation framework.
• Obtain the URL of the audio file from the application bundle.
• Initialize an AVAudioPlayer object with the URL.
• Prepare the player for playback.
• Call play() to start playback.
• Use pause() or stop() to control playback.

Example:

import AVFoundation

var audioPlayer: AVAudioPlayer?

if let url = Bundle.main.url(forResource: "music", withExtension: "mp3") {
    audioPlayer = try? AVAudioPlayer(contentsOf: url)
    audioPlayer?.prepareToPlay()
    audioPlayer?.play()
}

The player should normally be retained as a property so that it remains available during playback.

Important considerations for audio playback include:

• Configure the audio session with an appropriate category, such as playback or ambient.
• Handle interruptions caused by phone calls, alarms, or other applications.
• Check whether the audio file exists and handle loading errors.
• Retain the audio player for the duration of playback.
• Provide controls for play, pause, stop, and volume where required.
• Use the delegate to detect completion or playback errors.
• Consider background audio only when it is required and configure the application capabilities correctly.
• Release or replace the player when it is no longer needed.

Proper audio-session management improves reliability and prevents unexpected conflicts with other audio sources.

AVPlayerViewController provides a ready-made interface for playing video content.

Procedure:

• Import AVKit and AVFoundation.
• Obtain the URL of a local or remote video file.
• Create an AVPlayer using the URL.
• Create an AVPlayerViewController.
• Assign the player to the controller.
• Present the controller and start playback.

Example:

import AVKit
import AVFoundation

if let url = URL(string: "https://example.com/video.mp4") {
    let player = AVPlayer(url: url)
    let playerController = AVPlayerViewController()
    playerController.player = player
    present(playerController, animated: true) {
        player.play()
    }
}

The controller supplies standard playback controls and adapts the video display to the available screen space.

AVAudioPlayer and AVPlayer are both media playback classes, but they are intended for different requirements.

AVAudioPlayer is suitable for simple local audio, while AVPlayer is more appropriate for video and streaming media.

UICollectionView is a flexible view used to display a collection of items in customizable layouts such as grids, lists, and horizontally scrolling galleries.

Its main components are:

• Collection view: Displays the content.
• Cell: Represents an individual item.
• Data source: Supplies the number of sections, items, and cell content.
• Delegate: Handles selection, highlighting, scrolling, and interaction events.
• Layout object: Determines item size, spacing, insets, and arrangement.
• Supplementary views: Display section headers or footers.

The collection view reuses cells to reduce memory usage and improve scrolling performance.

The basic implementation involves the following steps:

• Add a UICollectionView to the view hierarchy.
• Create or register a collection-view cell class.
• Set the view controller as the collection view's data source and delegate.
• Implement numberOfItemsInSection.
• Implement cellForItemAt.
• Configure each cell using the corresponding data item.
• Implement selection behavior if required.

Example:

func collectionView(_ collectionView: UICollectionView,
                    numberOfItemsInSection section: Int) -> Int {
    return items.count
}

func collectionView(_ collectionView: UICollectionView,
                    cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
    let cell = collectionView.dequeueReusableCell(
        withReuseIdentifier: "Cell", for: indexPath)
    cell.backgroundColor = .systemBlue
    return cell
}

Cell reuse is important because only the cells currently needed on screen are maintained efficiently.

UICollectionViewFlowLayout arranges collection-view items in a line-based flow. It can be configured using properties such as:

• itemSize: Defines the width and height of each item.
• minimumLineSpacing: Sets spacing between rows or columns.
• minimumInteritemSpacing: Sets spacing between items in the same line.
• sectionInset: Adds padding around a section.
• scrollDirection: Specifies vertical or horizontal scrolling.
• Header and footer reference sizes: Define supplementary-view dimensions.

The layout can be assigned during initialization or through the collection view's collectionViewLayout property. A custom layout can be created when the standard flow arrangement is insufficient.

UIToolbar is a horizontal bar that contains toolbar items representing actions available in the current context.

Implementation steps:

• Create a toolbar in Interface Builder or programmatically.
• Create UIBarButtonItem objects for the required actions.
• Assign target-action methods to actionable items.
• Arrange the items using the toolbar's items property.
• Use flexible-space items to distribute controls.
• Position the toolbar using Auto Layout or place it within a navigation interface.

Example:

let saveItem = UIBarButtonItem(
    barButtonSystemItem: .save,
    target: self,
    action: #selector(saveData)
)
let flexibleSpace = UIBarButtonItem(
    barButtonSystemItem: .flexibleSpace,
    target: nil,
    action: nil
)
toolbar.setItems([saveItem, flexibleSpace], animated: false)

Toolbars are useful for frequent actions such as saving, editing, sharing, or filtering.

Toolbar items control both the actions and spacing of a toolbar.

• Flexible space: Expands to occupy available space and can push items toward opposite sides.
• Fixed space: Provides a specified amount of spacing between items.
• System item: Supplies a standard action and appearance, such as add, edit, save, or cancel.
• Custom item: Allows a custom view, such as a segmented control, search field, or progress indicator.
• Title item: Displays text when a textual command or status is required.

Using these item types makes toolbar layouts predictable and allows controls to adapt to different screen widths.

UITabBar is a control that displays a row of tab-bar items, while UITabBarController manages multiple view controllers organized as separate tabs.

• Each tab represents a major section of the application.
• A tab-bar item usually contains an icon and a title.
• Selecting a tab displays its associated view controller.
• The tab bar remains available while switching between sections.
• Each tab can maintain its own navigation controller and navigation history.

Tab-based navigation is appropriate when the application has several top-level destinations, such as Home, Search, Favorites, and Settings.

A tab-based application can be implemented as follows:

• Create a view controller for each major application section.
• Assign a title and UITabBarItem to each view controller.
• Create a UITabBarController.
• Assign the view controllers to its viewControllers property.
• Set the tab-bar controller as the root or present it from another controller.
• Use delegate methods when selection behavior must be customized.

A tab may contain a navigation controller instead of a plain view controller. This allows users to navigate within a tab while preserving the selected tab and its navigation stack.

Navigation-controller-based application:

• Represents a hierarchical flow of screens.
• Uses push and pop operations.
• Provides a back button and navigation history.
• Is suitable for list-detail workflows.

Tab-bar-controller-based application:

• Represents independent top-level sections.
• Allows direct switching between sections.
• Usually keeps each section readily accessible.
• Is suitable for applications with several major features.

The two controllers can be combined. For example, each tab of a tab-bar controller may contain its own navigation controller. The choice depends on whether the application structure is primarily hierarchical, section-based, or a combination of both.

SQLite is a lightweight, file-based relational database engine. It stores structured data in tables made up of rows and columns.

It is useful in iPhone applications because:

• It is embedded and does not require a separate database server.
• It stores data persistently between application launches.
• It supports SQL operations such as SELECT, INSERT, UPDATE, and DELETE.
• It is efficient for structured local data.
• It supports transactions and indexes.
• Its database is stored as a portable file in the application sandbox.

SQLite is suitable for offline data, cached server data, preferences requiring relational structure, and applications with moderate local data requirements.

The general procedure for using SQLite is:

• Determine a writable path in the application's documents or application-support directory.
• Open the database using the SQLite API.
• Create required tables with CREATE TABLE statements.
• Check and handle the return status of every database operation.
• Prepare SQL statements before execution.
• Bind values to parameters where required.
• Execute the statement and read returned rows.
• Finalize statements and close the database when appropriate.

A database should be created or opened during application initialization. Errors must be handled because database creation, file access, SQL syntax, and schema changes can all fail.

CRUD represents the four basic database operations.

• Create: Adds a new record.
  sql
  INSERT INTO Students (name, grade) VALUES (?, ?);

• Read: Retrieves records.
  sql
  SELECT id, name, grade FROM Students;

• Update: Changes an existing record.
  sql
  UPDATE Students SET grade = ? WHERE id = ?;

• Delete: Removes a record.
  sql
  DELETE FROM Students WHERE id = ?;

In iPhone applications, values should be bound to placeholders rather than concatenated into SQL strings. Parameter binding improves security, handles special characters correctly, and reduces the risk of SQL injection.