Stanford CS193p: iOS Development with SwiftUI | 2025 | L16: Shapes, Gestures, Persistence

Key Concepts

• Custom Shapes: Extending SwiftUI’s Shape protocol with custom Path implementations allows for diverse UI elements.
• Multi-Touch Gestures: SwiftUI simplifies gesture handling with discrete (onEnded) and continuous (onChange) closures.
• File Persistence: Options include Swift Data, the file system (sandboxed), iCloud (CloudKit), and User Defaults, each suited for different data sizes and complexities.
• Sandboxing: iOS apps operate within a secure sandbox, limiting access to their own files and data for security and privacy.
• Codable: The Codable protocol enables easy serialization and deserialization of Swift objects for data storage and transmission.

Custom Shapes & Geometry

The lecture began with extending SwiftUI’s capabilities through custom shapes. Any view can conform to the Shape protocol (inheriting from View) to create shapes beyond the built-in options. Implementing the path(in rect: CGRect) function is crucial, returning a Path struct that defines the shape’s outline. The Path struct provides functions for drawing lines, curves (including Bezier curves), and hit testing. A diamond shape was created as a demonstration, utilizing moveTo, addLineTo, and closeSubpath() within a Path initializer. GeometryReader was introduced as a tool for accessing a view’s size and position, but cautioned as potentially causing layout issues if not carefully managed, with aspectRatio suggested as a constraint. All shapes and views are fundamentally part of the UI.

Multi-Touch Gestures in SwiftUI

SwiftUI supports a variety of multi-touch gestures, including drags, pinches, and rotations. Gesture handling is achieved using the gesture view modifier. Gestures are categorized as discrete (e.g., tap, long press) and continuous (e.g., drag, pinch, rotation). Discrete gestures are handled with the onEnded closure (simplified with modifiers like .onTapGesture), while continuous gestures use the onChange closure, receiving a gesture-specific value. A rotation gesture was implemented to cycle through peg choices in the Codebreaker game, utilizing the rotation value from the onChange closure and managing state with both static and dynamic variables. SwiftUI is capable of differentiating between multiple simultaneous gestures. Potential conflicts with accessibility gestures were acknowledged.

Data Persistence Options

Several options exist for data persistence: Swift Data, the file system, iCloud, and User Defaults. The lecture focused on the file system, emphasizing the importance of security and privacy.

File System & Sandboxing Explained

iOS utilizes a Unix-based file system, but apps operate within a secure “sandbox” enforced by Unix permissions. This sandbox restricts app access to its own designated directory, preventing access to other apps’ data. Sandboxing simplifies data deletion and ensures reliable backups, including iCloud backups. The sandbox contains several directories: the read-only Application Directory (containing the app’s executable and resources), the Documents Directory (for user-perceived documents), the Application Support Directory (for user data not perceived as documents, and a potential location for Swift Data), and the Caches Directory (for temporary, non-backed-up data). Accessing these directories requires using URL structures with predefined static properties.

File I/O & Data Handling

Reading files can be done synchronously with Data(contentsOf: URL), but this is a blocking operation unsuitable for the main thread or HTTP URLs. Asynchronous reading is achieved with URLSession.shared.data(from: URL), returning a tuple containing the Data and a URLResponse and requiring await. Writing files uses Data.write(to: URL), with options like .withoutOverwriting and error handling via try or try?. FileManager provides utilities for file manipulation.

Codable for Data Serialization

The Codable protocol (combining Encodable and Decodable) allows converting Swift objects into data formats like JSON for storage and transmission. Swift can automatically synthesize Codable conformance for simple structs and enums. Classes and structs with non-codable properties require manual implementation of init(from decoder:) and encode(to encoder:), potentially utilizing CodingKeys for property mapping. JSONEncoder and JSONDecoder facilitate JSON encoding and decoding. AI tools can assist in generating Codable conformance code.

User Defaults for Simple Persistence

UserDefaults provides a simple dictionary-like storage for small amounts of data that persists between app launches. It supports only property list types and uses key-value storage with convenience methods for specific types. Namespacing keys is recommended to avoid conflicts.

Conclusion

This lecture covered a diverse set of topics crucial for completing the final project. From creating custom UI elements with shapes and handling complex user interactions with multi-touch gestures, to understanding the intricacies of data persistence and the importance of sandboxing for security, the material provided a solid foundation for building robust and secure iOS applications. The emphasis on utilizing SwiftUI’s built-in features and understanding the underlying system constraints will be invaluable for future development efforts.