Native Application Development A Cross-Reference for iOS and Android (Mike Dunn Shaun Lewis)（Z-Library）

【One-Line Pitch】 A practical cross-reference guide for native mobile developers, this book maps common iOS and Android tasks side-by-side, helping you quickly build fluency in both platforms with real, compilable code examples in Swift, Java, and Kotlin. 【Book Arc】 - **Opening (~0%–9%)**: Introduces the book’s purpose—a task-based cross-reference for iOS and Android—and sets expectations for code quality, language coverage (Java, Kotlin, Swift), and the assumption that readers have some programming background but not necessarily mobile expertise. - **Early (~9%–19%)**: Explains the book’s organization into two parts: platform-agnostic tasks (Part I) and a full app walk-through (Part II). It also justifies the deliberate choice of mature, vetted libraries (e.g., SQLite over Room, FragmentManager over Navigation) to maximize accessibility and real-world applicability. - **Early (~19%–28%)**: Begins the task chapters with UI controller fundamentals—how to create a starting UI controller on Android, the role of Activities and Fragments, and the importance of the main thread during app initialization. It also acknowledges the shift in Google’s recommended navigation patterns while staying neutral on legacy vs. modern approaches. - **Middle (~28%–47%)**: Covers changing the active UI controller via Intents, the constraints of the Binder transaction buffer (1 MB limit) for passing data, and alternatives like static variables or the Application instance. It then introduces Fragments as lightweight controllers, highlighting their flexibility for direct instantiation and nesting. - **Middle (~47%–53%)**: Continues with Fragment transactions—how to add, replace, remove, attach, hide, and show fragments using the FragmentManager—providing concrete code snippets in both Java and Kotlin to manage UI state transitions. 【Key Takeaways】 - **Task-based cross-reference structure** (Early): The book is organized around common, platform-agnostic tasks (e.g., file I/O, HTTP requests) with parallel iOS and Android implementations, making it easy to jump between platforms. This design supports both cross-platform developers and those learning a second native framework. - **Mature libraries over bleeding-edge APIs** (Early): The authors deliberately default to vetted, widely used libraries (e.g., SQLite over Room) to ensure the code is immediately useful and maintainable, even if newer alternatives exist. This pragmatic choice prioritizes readability and broad applicability over novelty. - **UI controllers are the heart of an app** (Early): Both platforms treat UI controllers (Activities/Fragments on Android, view controllers on iOS) as the bridge between user input, data, and rendering. Understanding their life cycle and creation is foundational to any mobile app. - **Android’s Activity launch is system-controlled** (Middle): You cannot instantiate Activities with `new`; instead, you send an Intent to the system, which handles instantiation and configuration. This asynchronous, system-driven process is critical for managing launch modes and task stacks. - **Binder transaction buffer limits data passing** (Middle): The 1 MB process-level limit on Binder transactions means you cannot pass complex objects directly between Activities. You must either persist data to disk or use globally reachable structures like static variables or the Application instance. - **Fragments offer more flexibility than Activities** (Middle): Unlike Activities, Fragments can be instantiated directly with custom constructors and can be nested, making them ideal for modular UI management. However, nesting has historical reliability issues, so caution is advised. - **Fragment transactions are the key to dynamic UI** (Middle): Using FragmentManager, you can add, replace, remove, attach, hide, or show fragments to change the UI at runtime. These operations are performed in a transaction and committed, allowing for flexible screen composition. 【Reading Tips】 - **Skim the opening chapters** (~0%–9%) if you’re already familiar with mobile development basics; they mainly set expectations and explain the book’s structure. Focus instead on the task chapters that follow. - **Deep-read the UI controller chapters** (~25%–53%) if you’re new to Android or iOS navigation; they explain core concepts like Activities, Fragments, and Intents with code examples in both Java and Kotlin. Pay special attention to the Binder transaction limit and Fragment transaction patterns. - **Use the cross-reference format actively**: When reading about a task on one platform, immediately compare it with the complementary platform’s example. This reinforces learning and highlights platform-specific differences. - **Treat code samples as starting points**: The authors note the samples cover ~80% of basic knowledge, so expect to consult official documentation for edge cases or newer APIs. The code is meant to compile and run, so test it in your own environment. - **Skip the philosophical debates**: The book stays neutral on Android’s Activity vs. Fragment vs. Navigation component controversies. If you’re not interested in legacy patterns, focus on the practical code and adapt it to your preferred architecture. 【Coverage Limits】 This guide covers the book’s opening, organization, and early UI controller chapters (roughly the first half of Part I). It does not cover later task chapters (e.g., views, networking, filesystem, databases) or the full app walk-through in Part II, as those sections were not included in the provided excerpts.