Programming iOS 13 Dive Deep into Views, View Controllers, and Frameworks (Matt Neuburg) (Z-Library)

【One-Line Pitch】 A comprehensive, code-rich guide for iOS developers who already know Swift and Xcode basics, this book systematically explains how to build real-world iOS 13 apps by mastering views, view controllers, and Apple's frameworks—from drawing and animation to gestures, layout, and beyond. 【Book Arc】 - **Opening (~0%–10%)**: Establishes the foundational concept of the view hierarchy, explaining how views are arranged, drawn, and layered, including the critical role of size classes and layout margins in adapting to different devices and orientations. - **Early (~10%–23%)**: Dives into practical view configuration, covering Auto Layout constraints, custom layout guides, and image handling—including resizable images with cap insets, tiling, and stretching—plus visual effects like blur and vibrancy for modern interface design. - **Early (~23%–32%)**: Explores drawing and layers in depth, showing how to subclass UIView for custom drawing, build complex visual compositions with CALayer (like a 3D compass), and master layer features such as shadows, masks, and transforms for polished visuals. - **Middle (~32%–42%)**: Focuses on animation, explaining both block-based UIView animations and property animators, covering duration, delay, timing curves, and the underlying Core Animation mechanics—including implicit layer animations and how to customize them via action objects. - **Middle (~42%–48%)**: Transitions to touch handling and gesture recognition, detailing how UIGestureRecognizer subclasses work, their target–action dispatch model, and how to manage discrete versus continuous gestures for interactive interfaces. 【Key Takeaways】 - **View hierarchy dictates drawing order and interaction** (Opening): Sibling subviews draw in order, so earlier siblings appear behind later ones; understanding this is essential for predicting visual layering and touch behavior. (Early) - **Size classes are the key to adaptive layout** (Opening): The combination of horizontal and vertical size classes (regular/compact) tells you whether you're on iPad, iPhone portrait, or iPhone landscape, enabling responsive design without device-specific checks. (Early) - **Custom layout guides beat spacer views** (Early): UILayoutGuide objects participate in Auto Layout like subviews but avoid the overhead of actual views—ideal for evenly distributing views that stay spaced when the superview resizes. (Early) - **Resizable images with cap insets are powerful** (Early): Using `resizableImage(withCapInsets:resizingMode:)` lets you tile or stretch only the interior of an image, preserving corners and edges—critical for buttons, backgrounds, and scalable graphics. (Early) - **Shadows require careful layer configuration** (Early): A layer's shadow won't appear if `masksToBounds` is true; to get both clipping and a shadow, you need a trick—a separate invisible view behind the clipped one with its own shadow layer. (Early) - **Animation duration is really speed** (Middle): A duration of 0 means "use default" (0.2 seconds), and changing distance in the same time changes speed; understanding this helps you design animations that feel natural and intentional. (Middle) - **Implicit animations can be customized via actions** (Middle): By overriding `action(forKey:)` or storing animations in a layer's `actions` dictionary, you can control implicit animations—like forcing a 5-second duration that overrides CATransaction settings. (Middle) - **Gesture recognizers simplify touch handling** (Middle): Each recognizer reports one gesture type via target–action, making any view's touch handling as simple as a control's; discrete gestures (tap) emit one message, continuous ones (pan) emit a series. (Middle) 【Reading Tips】 - **Skim the opening view hierarchy section** if you're comfortable with basic UIView; focus instead on the size class and layout margin details, which are iOS 13-specific and easy to miss. - **Deep-read the drawing and layer chapters** (Early ~23%–32%): These are dense but payoff hugely for custom UI; pay special attention to the shadow/clipping trick and the 3D layer composition example. - **Treat the animation chapter as a reference** (Middle ~32%–42%): You don't need to memorize every API, but understand the difference between block-based animations and property animators, and how implicit animations work under the hood. - **Practice gesture recognizers with code** (Middle ~48%): The target–action pattern is straightforward but subtle; build a small app with multiple recognizers to see how they interact and share touches. - **Skip the table of contents and index** unless you're looking for a specific topic; the book is best read sequentially, as later chapters build on earlier concepts. 【Coverage Limits】 This guide covers the first half of the book (views, drawing, layers, animation, and gestures). Excerpts do not cover view controllers, scroll/table views, text handling, or the framework chapters (sound, video, maps, sensors, files, networking, threads), which appear later in the book.