Android Development

From a first Android Studio project and the Kotlin language through Views and Jetpack Compose, Retrofit and RxJava, testing, security and the Kotlin Multiplatform and Flutter alternatives, Android development as told through the free samples of the Leanpub books about it.

Created from the free samples of 25 Leanpub books and the descriptions and tables of contents of 26 more, with every source cited.

Android development is the building of applications for Google's Android operating system, which runs on phones, tablets, foldables, watches, televisions and cars from many manufacturers. The work is done in Android Studio, Google's IDE built on JetBrains' IntelliJ, in Kotlin or the older Java, against the Android SDK and the Jetpack libraries, with Gradle as the build system, and the result is distributed through Google Play and other stores. One of the sources, written for web developers in 2015, lists what the native route needs: the SDKs, and a Google developer licence at twenty-five dollars.[22]

The Leanpub books on the subject fall into three generations. The earliest, from 2015 to 2017, are Java books: an eight-hundred-page Android Studio textbook for Android 7, a reference on Retrofit, RxJava explained for Android, Firebase in Java, and a test-driven development guide whose authors now call it out of date.[11][5][3][44][4] The second, from 2018 to 2021, follows Kotlin: the book that taught Android developers the language by building a weather app, the guides to Anko and the Kotlin Android Extensions that preceded Jetpack Compose, and a two-platform textbook whose Android half was rewritten in Kotlin for its second edition.[1][2][10] The most recent, from 2024 to 2026, assume Jetpack Compose: three books on its internals, a book of Compose sensor projects, screenshot testing of Compose previews, security for Kotlin developers, and interview guides rewritten after the Compose-first announcement.[27][30][9][42][32]

This article covers the Kotlin language and its use on Android, the two interface toolkits, architecture and reactive programming, the libraries for networking, images and backend services, builds and testing, security, the cross-platform frameworks that target Android without the Android SDK, and the interview books. Its sources are the free samples of twenty-five Leanpub books and the public descriptions and tables of contents of twenty-six more, listed at the end; nothing from any book's paid chapters was used. The Android and Kotlin categories on Leanpub hold more pure Kotlin-language books than Android books, and many Flutter, React Native and Kotlin Multiplatform titles; the language books appear here as the language section, and the cross-platform books in a section of their own.

Where to start

A reader who has never programmed can begin with Kotlin alone. Atomic Kotlin, by Bruce Eckel and a member of the JetBrains Kotlin team, teaches the language in very small chapters it calls atoms, one concept each, with no forward references and exercises checked inside IntelliJ IDEA through the EduTools plugin; its summaries let an experienced programmer skip ahead, and its 2021 printing was adjusted for Kotlin 1.5.[17] Kotlin: An Illustrated Guide takes the same ground in twenty illustrated chapters, defining each term before it is used, and was still being revised in 2026.[37] Kotlin Essentials, the first volume of Marcin Moskała's Kotlin for Developers series, argues that Kotlin is a better first language than Java, since a junior Kotlin developer never needs to write a getter or a builder, and shows from the first chapter how to decompile Kotlin to Java in the IDE to see what the compiler did.[12]

A developer who knows Java or another language and wants to build an app has two paths. Kotlin for Android Developers, written from 2015 and recommended at the time by Google and JetBrains, learns Kotlin while writing a weather forecast app, stopping to compare each feature with Java 6; it assumes some Android Studio, Gradle and SDK knowledge and is dated to Kotlin 1.3 and the Anko era.[1] Mastering Mobile Application Development - 2nd Edition teaches Android in Kotlin beside iOS in Swift, one concept and one app at a time, and suits a student or a developer who knows one platform and wants the other.[10] For the current toolkit, the 2026 book on Android development with Jetpack Compose and Kotlin covers project structure, responsive interfaces, state and architecture with Material 3, though only its description was available to this article.[31]

A working Android developer has a clearer set. Effective Kotlin is sixty numbered items of best practice, from limiting mutability onwards.[13] Kotlin Coroutines is written for Android and backend developers, the two main audiences of Kotlin, and starts at the compiler mechanics of suspension before the library.[16] Jetpack Compose Mechanisms and Jetpack Compose internals are for the day a Compose developer wants to know why a screen recomposes.[27][26] For interviews, Manifest Android Interview reviews the framework, Jetpack and Compose as about a hundred and fourteen questions with worked answers.[32]

History

Android 1.0 shipped in 2008 with Java as its application language and a view system, the View framework, that has been part of the platform since that first release.[9] For its first decade the books were Java books. The Android Studio textbook of 2016 shows the shape of the platform then: the IDE and its emulator, the activity lifecycle, the Layout Editor and the new ConstraintLayout, fragments, menus, RecyclerView, intents, services, SQLite, content providers, notifications and Android 7's multi-window support, in seventy-five chapters.[11] The libraries of the period came from outside Google: Square's Retrofit and Picasso, Bumptech's Glide, Netflix's RxJava, which the Netflix team ported from Microsoft's Rx.NET and announced in February 2013, and which the event-driven, UI-thread-bound nature of Android made a natural home for.[5][7][6][3]

Kotlin arrived from the side. JetBrains, the company behind IntelliJ and so behind Android Studio, designed it for Java developers, and Android developers adopted it early because the IDE understood it and because it was more expressive, null-safe and interoperable with Java.[1] At Google I/O in 2017 the Android team announced that Kotlin was an official language, with the framework, the IDE and the libraries made to work with it, after years of the community asking.[1] The language books record what followed: Google later suggested that all Android applications be written in Kotlin and that its APIs would be designed primarily for it, and Kotlin became in practice the standard language of the platform.[12] Between the announcement and Jetpack, the Kotlin team's own Anko library offered a layout DSL in place of XML, and one Android author who converted a whole project to it recorded the pros, faster view creation without inflation, and the cons, blind layout writing with no designer, and concluded it was a matter of taste.[2]

The second turning point was Jetpack Compose, Google's declarative toolkit, which was built from scratch without the View framework. A 2026 testing book describes the result: some apps are traditional, built entirely with Views, some modern, built entirely in Compose, and many combined, and Compose is becoming the standard.[9] The toolkit also left the platform: Compose was written for Android but uses Kotlin's multiplatform capabilities to render on desktop, web and iOS,[12] and a Compose Multiplatform author dates its maturity to the two years before 2026, when the lifecycle, navigation and ViewModel APIs were unified.[20] The 2026 interview guide's second edition follows Kotlin 2.4.0 and what it calls the Compose-first announcement, expanding its Compose coverage and trimming Views and XML.[32]

The Kotlin language

Kotlin is an open-source, statically typed, multi-paradigm language made primarily by JetBrains, with a public design process called KEEP, that compiles to JVM bytecode, JavaScript or native machine code.[12] On Android it compiles to the JVM target, and the interoperability is complete in both directions: any Java library can be used from Kotlin, and Kotlin code from Java, so a Java project can be migrated one file at a time, which is how the Kotlin compiler itself was moved from Java.[12] The language is not a layer of sugar over Java, one source insists, but a different language with multiplatform capabilities and coroutines that Java lacks.[12]

Learning the language

The features that drew Android developers are the ones every introduction leads with. A data class replaces a Java class with its fields, accessors, equals, hashCode and toString; null safety makes the type say whether a value can be null, so that the compiler refuses to call a method on a possibly null reference; extension functions add methods to classes whose source is not available, replacing the utility classes of Java projects; and lambdas replace the anonymous class a click listener used to need.[1] Mutability is the first item in Effective Kotlin: a mutable state is harder to understand, debug and reason about, needs synchronisation under threads, causes unintended side effects at a distance and multiplies the states a test must cover, so Kotlin separates read-only val from var, read-only collection interfaces from their mutable subtypes, and offers copy on data classes; a val, the item notes, is not immutable, since it may have a custom getter, and only a final property without one can be smart-cast.[13]

Moskała's series divides the language by level. Functional Kotlin covers function types, lambdas, function references, inline functions, collection processing, sequences, DSL builders, scope functions and context parameters, with an Arrow chapter by that library's maintainers; its introduction lists which functional concepts Kotlin supports and which, such as currying and partial application, it omits.[14] Advanced Kotlin takes variance modifiers, delegation, contracts, Java and JavaScript interoperability, multiplatform modules shared between Android and iOS apps, reflection, annotation processing, Kotlin Symbol Processing and compiler plugins, and has the reader build an annotation processor, a KSP processor, a compiler plugin and a detekt rule; its sample explains why a mutable list is invariant while a read-only list is covariant.[15] Practical Kotlin Deep Dive asks seventy questions about internals, from null safety and value classes to the K2 compiler and Kotlin Multiplatform, and answers them from generated bytecode, KEEP proposals and compiler source; a course of the same content adds assessments and a code playground.[35][36] Functional Programming Ideas for the Curious Kotliner frames functional programming as four design principles, applies them to immutable data, optics, Either and Result, effects and property-based testing, and ends in a chapter on flows, composable functions and view models.[18]

Kotlin on Android

Coroutines are the language feature that changed Android code most, replacing callbacks, AsyncTask and much of RxJava. Kotlin Coroutines opens by dismissing the usual reasons given for learning them, lighter threads, easier than RxJava, and calls them a general concept known since the 1960s that Go brought back and Kotlin made practical; it is written from the backend and Android perspectives because coroutines were designed for those two uses, and its four parts go from how suspension works through the kotlinx.coroutines library, Channel and Flow, to practice, with sections on constructing a coroutine scope on Android and testing Android functions.[16] The version read here is based on Kotlin 2.0.20 and kotlinx.coroutines 1.8.0.[16]

Before Compose, Android developers used Kotlin to tame the View framework. 5 top guides to mastering Kotlin is five short guides from 2018 on Anko layouts, the Gradle Kotlin DSL, coroutines, the Kotlin Android Extensions and Java interoperability, each weighing whether the tool is worth adopting; its Anko guide builds a CoordinatorLayout with an AppBarLayout, toolbar and RecyclerView in Kotlin code, keeping the layout in a component class rather than the activity, and notes that layout parameters and styles are harder than in XML.[2] The same author's larger book interleaves language chapters with the steps of its forecast app, a RecyclerView adapter, a network request, a detail activity, a settings screen backed by shared preferences and a SQLiteOpenHelper.[1] Google's own recommendations have since moved on: Anko is archived, and the Kotlin Android Extensions were replaced by view binding and then by Compose.

The pure language books in the Android category are useful background rather than Android instruction. Building Domain Specific Languages in Kotlin works through the lambda-with-receiver, invoke, infix and operator features that builder DSLs use, in a restaurant menu example, and Compose, Gradle and Anko are all DSLs of that kind.[38] The interview-oriented Kotlin Design Patterns for Android Interviews is the exception that stays on Android: fifteen classic patterns, each with a Kotlin implementation, an Android and Compose mapping to ViewModels, repositories and use cases, and a closing part on where they appear in MVVM, MVI and Clean Architecture.[34]

Building the interface

Android has two interface toolkits. The View framework, with its XML layouts, activities, fragments and the ViewGroup subclasses, dates from the first release and is in most shipping apps; Jetpack Compose, declarative and written in Kotlin, is the one Google now recommends for new work, and apps that mix the two are common.[9]

Views, layouts and Android Studio

The 2016 Android Studio textbook is the fullest account of the View era among the sources. Its sequence runs from installing the JDK and Android Studio 2.2, creating a virtual device and running on a physical one, through the architecture of the platform and the anatomy of an app, the activity lifecycle and saving state, the Layout Editor and ConstraintLayout, XML and code-built layouts, event, touch and gesture handling, fragments, menus, the transitions framework, the floating action button and Snackbar, TabLayout, RecyclerView and CardView, the navigation drawer, intents, threads, services and notifications, to SQLite, content providers, the storage access framework, media, maps, printing, fingerprint authentication, signing for release, in-app billing and Gradle.[11] Only its contents were available here, and its Java and Android 7 are dated, but the chapter list is still a map of the classic SDK.

Mastering Mobile Application Development - 2nd Edition teaches the same material comparatively. Its first chapter sets Xcode against Android Studio, with the Layout Editor, Gradle, SDK management, emulators and the support libraries, and upgrades to Android Studio 4.0; its first app lays out a login screen in the Layout Editor, validates the form, animates a view, uses the string resource editor and internationalises the app; its architecture chapter covers process and application state transitions, the resource constraints of a mobile device, and the choice between Model-View-Presenter and Model-View-ViewModel; later chapters add navigation graphs, ViewModel, LinearLayout against ConstraintLayout, RecyclerView, Firebase, networking and maps.[10] The TDD book's spike builds a RelativeLayout form by hand to learn how to receive text on every keypress, and its acceptance test fails first with the error that only the thread that created a view hierarchy may touch its views, which the @UiThreadTest annotation resolves.[4]

Jetpack Compose

Compose describes an interface as functions that produce UI, where state is the engine and recomposition the mechanism.[20] Three of the sources go beneath that description, and all three are internals books rather than tutorials. Jetpack Compose internals, from 2022, covers the properties of composable functions, the Kotlin compiler plugin that rewrites them, the runtime's slot table, Composer and Recomposer, how Compose UI materialises and measures nodes, the snapshot state system and the effect handlers, with one chapter on the runtime's uses beyond Android, in vector graphics and the browser DOM.[26] Jetpack Compose Mechanisms, from 2026 and updated for Kotlin 2.4.0 and Compose Compiler 2.4.0, follows the same path through the AOSP source and adds a performance playbook from the author's own tooling, a stability analyser and hot swap, closing with a case study that takes a chat screen from forty-seven recompositions a second to none.[27] Its course version has fifty-nine lessons in eight chapters with questions and assessments.[28]

For custom drawing, the 2025 book on Compose Canvas and animation starts with the mathematics graphics needs, then DrawScope, primitives, paths, images and bitmaps, Canvas state and touch handling, and in its second part value-based, transition and physics-based animation.[29] Master Android Sensors with Jetpack Compose Projects uses Compose and Material 3 for fifteen complete apps, one per sensor family: a sensor inspector, motion detection, a compass, environmental monitoring, a pedometer, GPS and geofencing, a CameraX document scanner, audio classification, a biometric lock, Health Connect vitals, sensor-fusion fall detection, chart dashboards drawn with Canvas, a foldable-aware app and a testing and benchmarking tool, each with architecture, persistence, background services and tests.[30] Screenshot testing of Compose previews is in the testing section below.

Architecture, patterns and reactive programming

The architecture question on Android has always been how to keep logic out of the activity. TDD for Android's answer from 2016 is structural: keep the Android-free core of an application in its own module, which the app module depends on and which depends on nothing, so that unit tests run on the JVM without a device; the view is an interface in the core module, mocked with JMock in presenter-first tests, and implemented in the app module by a class with an Android prefix.[4] Mastering Mobile Application Development - 2nd Edition sets out Model-View-Presenter and Model-View-ViewModel as the architectural choice,[10] and Kotlin Design Patterns for Android Interviews shows where the classic patterns sit inside MVVM, MVI and Clean Architecture.[34]

Reactive programming was the other answer of the 2010s. Reactive Programming on Android with RxJava defines it as asynchronous programming with observable streams and shows that an Android developer already handles streams everywhere: click and swipe events, network and database I/O, push notifications and sensor updates.[3] Its history runs from Erik Meijer's team at Microsoft, who dualised the Iterator pattern into a push-based model and built Rx.NET, to Netflix, whose client teams needed to write concurrent server endpoints and whose port, RxJava, was open-sourced in 2013, and on to the ReactiveX ports and RxAndroid.[3] Its worked example is a pipeline that runs a request on a background scheduler, filters, maps, deduplicates and takes five items, then switches to the main thread with observeOn before subscribing, and the book draws out the characteristics: the Observer pattern with completion and error signals, pure operators that are declarative, thread-safe and testable, lazy evaluation until subscription, and errors passed down the stream instead of thrown.[3] It is Java-only, with a Kotlin companion, and dated to RxJava 2 and Android Studio 3.[3]

Two 2026 books look at architecture from the interview and planning side. Cracking the Mobile System Design Interview works eight case studies, a social feed, chat, an offline-first app, media streaming, an image loading library, ride sharing, fitness tracking and secure authentication, from the mobile client's point of view, with offline behaviour, caching, sync, state and background processing as the recurring concerns; it is deliberately platform-neutral.[48] The first part of a planned series on super apps, single applications offering many services, gives a mental model for planning one through two use cases, a multi-service consumer app and a multi-region finance app, and is about design philosophy rather than code.[50]

Networking, images, data and services

The Future Studio books, which grew out of a tutorial blog, are the sources for the library layer of a Java-era Android app, and they share a habit of ending each chapter with a checklist of what was learned. Retrofit: Love Working with APIs on Android describes Retrofit as a type-safe REST client that turns an API into a Java interface annotated with the HTTP method and path, with parameter substitution, form and multipart requests built in, and explains the division of labour with OkHttp, the low-level HTTP client Retrofit 2 is built on and sometimes borrows classes from.[5] Its quick start adds the Internet permission to the manifest, the Retrofit and Gson converter dependencies, since Retrofit 2 ships with no converter, and a GitHub interface with a path parameter; its ServiceGenerator keeps the Retrofit builder, the OkHttp client and its interceptors in one static class so that the app shares one socket-pooling client, and the book warns against rebuilding the Retrofit object on every call or adding the logging interceptor twice.[5] Later chapters cover converters, authentication by basic, token, OAuth and Hawk schemes, file upload and download, pagination, error handling, logging, caching, mocking and the ProGuard rules a release needs.[5]

The same authors' Gson book maps JSON to Java objects and back, from a plain user object through annotations, GsonBuilder configuration, custom serialisers and deserialisers, generics and streaming, and it is tailored to Android in its ProGuard, SharedPreferences and Retrofit sections while applying to any Java project.[8] Their two image books explain why a library is needed at all: Android loads images pixel by pixel, so a single five-megapixel photo takes about nineteen megabytes of memory, and network conditions, caching and transformations add complexity nobody should write twice.[7][6] Picasso: Easy Image Loading on Android covers Square's library through its three-call fluent interface, loading from URLs, resources, files and Uris, the automatic pausing of requests when an activity pauses, placeholders, resizing, transformations, caches and ProGuard, with an appendix on version 3.[7] Glide: Customizable Image Loading on Android does the same for Glide 4, adding the generated API that an AppGlideModule produces, GIFs and local video thumbnails, request priorities, targets, Glide modules and an upgrade guide from Glide 3.[6]

For a backend, the 2017 Firebase guide integrates Firebase Android SDK 11.2.0 service by service, with an example app for each: analytics, notifications and Cloud Messaging with a PHP server sending the pushes, the Realtime Database, authentication, storage, Remote Config, crash reporting, AdMob, invites, dynamic links and app indexing, several of which Firebase has since renamed or retired.[44] The sensor book above is the current source for the device side, from the Sensor Framework through CameraX, location, Health Connect and the WindowManager posture APIs for foldables.[30]

Builds, testing and continuous integration

Android builds run on Gradle through the Android Gradle Plugin, and most developers meet it only in configuration. Extending Android Builds goes further, into writing Gradle plugins and tasks that cooperate with the plugin through its Variant and Artifact APIs, and into intercepting the resource, source and bytecode stages with AAPT2, Kotlin Symbol Processing and bytecode modifiers, closing with build performance, across eight chapters of demos and case studies.[39] The 2016 CI book strings Docker, Jenkins, Nexus and SonarQube into a pipeline for an Android app and closes the loop with Appium acceptance tests written in Ruby, run across parallel devices.[40]

TDD for Android is the oldest testing source and the most honest about its age: its authors warn that it predates the easier unit testing that later tooling brought. Its method still reads well. Write the examples with the customer first, as given-when-then scenarios; spike the unfamiliar API in a throwaway project with a time limit; write an end-to-end acceptance test in the language of those scenarios and let it fail for the right reason, a failure rather than an error; then drop to unit tests in the Android-free module, with a test list, presenter-first design and mocks.[4] Instrumentation tests in its app module use AndroidTestCase for a context and JUnit 3, while the core module uses JUnit 4.[4]

The 2026 testing source is about appearance rather than behaviour. Mastering Android Screenshot Testing defines screenshot testing as recording a reference image of a component or screen and comparing each run against it, so that an unintended visual change is caught; it exists because end-to-end tests, UI tests with fake data and accessibility tests can all pass while the text on a button is unreadable in dark mode, and because Compose previews catch nothing automatically.[9] The book sets framework-neutral principles first, when to use screenshot tests, what to verify, team standards, emulators against devices and scope, then implementation on a mood tracker app, asynchronous images with coil-test, and generating tests from Compose preview functions with ComposablePreviewScanner and Roborazzi; its parts on parameterised tests, CI integration and Compose Multiplatform were still to come when the sample was read.[9] Hands-On Mobile App Testing is the tester's companion to these, a platform-neutral book on what makes mobile testing different, device fragmentation, sensors, mobile-specific checklists and mnemonics, crowd and cloud testing, and the skills a mobile tester needs.[41]

Security

Two 2025 and 2026 books treat Android security at different altitudes. Modern Android Security for Developers is written for Kotlin developers who ship apps and organises the subject by attack surface: secure storage with EncryptedSharedPreferences, Jetpack Security, Room with SQLCipher and DataStore; the Android Keystore and cryptography; TLS and certificate pinning; authentication with biometrics, OAuth 2.0 and OpenID Connect, JWT handling, sessions and passkeys; code protection with R8; runtime integrity checks and the Play Integrity API; secure inter-process communication and WebView; security testing; privacy compliance; and architecture patterns, with a complete Kotlin manager class, a hands-on exercise and a checklist in most chapters.[42]

Secure Android Design and Development treats security as design decisions across the whole stack, from application code and inter-process communication down to framework services and the hardware abstraction layer, aligned with Android 15. It covers security principles, threat modelling with STRIDE and TARA, common programming mistakes in C, C++, Java and Kotlin, the Android security model of sandbox, signing, permissions, SELinux and Play Integrity, data protection, authentication and network security, and practical scenarios including financial apps and Android Automotive, for engineers and security engineers on production systems rather than beginners; a course of the same title carries the same material with exercises.[43] The older library books contribute the release-time concern that both share: the ProGuard and R8 rules without which a shrunk, obfuscated build breaks Retrofit, Gson or Glide.[5][8][6]

Cross-platform alternatives

A large share of the books in the Android category never touch the Android SDK: they build Android apps through a framework that also builds iOS apps. KMP for Mobile Native Developers lays out the four approaches: native, with Android Studio and Kotlin on one side and Xcode and Swift on the other, sharing no production code; progressive web apps, sharing everything because the browser is the platform; cross-platform frameworks that share modules, sometimes the UI; and hybrid apps running web code in a WebView with native plugins as a bridge. It argues that the choice is a spectrum rather than a binary, that many companies settle on shared logic with native UI, and it places Flutter, which renders its own UI with Skia, React Native, which translates React into native views over a bridge that the JSI architecture has since reworked, and Kotlin Multiplatform, which is native-first and joins existing projects as a dependency, on that spectrum.[19] The 2015 Ionic book made the same comparison a decade earlier for web developers, between native, mobile website and hybrid, and concluded that a hybrid app's WebView had speed limits that ruled out three-dimensional games.[22]

Flutter

Flutter is Google's Dart framework, and six of the sources teach it, all for Android and iOS together. Beginning Flutter 3.0 with Dart is a thousand-page accumulation across Flutter 2.5 to 3.0 that covers Dart, widgets, layouts, Provider, Riverpod and Scoped Model, navigation, Material Design, slivers, SQLite, REST and Firebase; its sampled chapter explains constraints, the rule that a widget receives its size from its parent and passes a constraint to its child, through Container, Center and alignment examples, and warns web developers that Flutter layout is not HTML layout.[23] Flutter 3 From Scratch: A Practical Guide with Real Projects, from 2026, builds seventeen chapters of projects, a unit meter, a places app with camera and SQLite, a Firebase to-do web app, an e-commerce app with Redux and a Strapi backend, and a BLoC app, and covers three state managers in the process; it also targets desktop and web.[24] Flutter: Zero to App, from 2020, presents each basic widget as an annotated constructor, Center, Text and TextStyle, Icon, Container, Column and Row, with small examples, in pre-null-safety Dart.[25]

Two shorter books by one author take the intermediate Flutter developer through state and performance. State in Flutter argues that stateful widgets and setState do not scale, since they rebuild widgets unnecessarily, and moves through InheritedWidget to Provider and Riverpod, showing the two mixed.[45] Better Flutter starts from why Flutter widgets are immutable and builds its advice on state, theming, lists and navigation on reducing rebuilds.[46] Their chapter headings are phrased as search queries, a sign of their origin as articles.[45][46]

React Native and web-based hybrids

Programming React Native, from 2016, builds a contacts app with Flux and Immutable.js and spends two chapters going native, with custom view managers and native modules on both platforms, alongside the native Android project, the Android toolbar and back button; its APIs, Navigator and ListView among them, are early React Native.[47] The 2015 Ionic framework walks a web developer from a mockup through an Ionic Creator prototype to a calculator app with icons, splash screens and AdMob, tested on devices and published to Google Play and the App Store, with Ionic 1, AngularJS and Cordova 4; its sample praises Ionic's one-command icon generation, live reload on device and side-by-side iOS and Android preview.[22] Android appears in these books where it must: setup, the keystore, APK signing and the Play Store listing.[22]

Kotlin Multiplatform and Compose Multiplatform

Kotlin Multiplatform is the code-sharing route that stays closest to Android, since the shared code is Kotlin and compiles to JVM bytecode for Android and, through Kotlin/Native, to a binary for iOS, with the expect and actual mechanism for platform differences.[19] KMP for Mobile Native Developers, a 2026 second edition, treats adoption as an architecture decision: whether to share, project structure with source sets and the Android Gradle Plugin 9, a first project, dependency injection including compile-time injection with Metro, modularisation, testing with coverage through Kover, native dependencies, designing libraries whose APIs feel natural in Swift, Swift Export and distribution through SwiftPM and CocoaPods, with a checklist per chapter and advice on presenting the approach to a team; it does not cover shared UI, and it quotes the Netflix studio team on writing business logic once.[19]

CMP for Mobile Native Developers is the UI half, for developers who already build Android apps with Kotlin and Compose or iOS apps with Swift and SwiftUI. Its 2026 second edition records how the stack settled, JetBrains ViewModels derived from AndroidX, Compose Multiplatform Navigation with type-safe routes through Kotlin Serialization, and Koin for dependency injection, and takes explicit stances on them while presenting Voyager, PreCompose, Decompose and Kodein as alternatives; its twelve chapters add adaptive layouts with WindowSizeClass, resources and localisation with right-to-left support, lifecycle and state holders, accessibility with VoiceOver on iOS, shared UI testing, integration with native components in both directions and an integrator project with a production checklist.[20] Migrating Production Apps to Kotlin Multiplatform and Compose Multiplatform is for teams with both apps already in production: whether to migrate, sizing, an eight-stage journey with three terminal stages, UI framework choices for the later stages, a seam principle for cutting an app, navigation and deep links across stages, dependency patterns, AI-assisted migration and anti-patterns, followed on two sample apps, one Compose and SwiftUI, one mixing XML, Compose, UIKit and SwiftUI.[21]

Careers and interviews

The interview books are the richest recent Android sources, because they review the whole platform. Manifest Android Interview asks about seventy questions on the framework, Views, Jetpack, business logic and tooling and about forty-four on Jetpack Compose fundamentals, runtime, UI and performance, each answered as a step-by-step walkthrough with follow-up challenges and Pro Tips for Mastery sections on internals; its June 2026 second edition follows Kotlin 2.4.0 and the Compose-first announcement.[32] The course built from it has over three hundred and seventy questions with assessments and a certificate.[33] Kotlin Design Patterns for Android Interviews serves the architecture round, pattern by pattern.[34] The oldest of the set, from 2015, collects a hundred Android questions in three difficulty levels, gathered by an author who had sat on both sides of the table, and is written for hiring managers as much as candidates; it predates Kotlin on Android.[51]

Two 2026 books by one author cover the parts of a mobile interview that are not Android. Cracking the Mobile System Design Interview is the system design round, mobile-first and platform-neutral, with eight case studies from a social feed to secure authentication and a cheat sheet.[48] Mobile Coding Interviews Using Kotlin/Swift is the algorithms round, giving each pattern, two pointers, sliding window, binary search, trees, graphs, dynamic programming and the rest, as a template in both Kotlin and Swift with worked problems and a checklist of eighty-eight.[49]

Sources

Every source is a Leanpub book or course. The note after each says which part of it was read; where no sample was available, only the public description and table of contents were used.

1.
Kotlin for Android Developers, Antonio Leiva: Learn Kotlin the easy way while developing an Android App Free sample: about the book, who it is for, and chapter 1 on what Kotlin is and what it gives an Android developer. 2019. Free sample: PDF · EPUB
2.
5 top guides to mastering Kotlin, Antonio Leiva: Learn the tricks that will let you take the most out of the language Free sample: the introduction and the first guide, on Anko layouts against XML. 2018. Free sample: PDF · EPUB
3.
Reactive Programming on Android with RxJava, Christopher Arriola, Angus Huang Free sample: chapter 1 on what reactive programming is, its history and a worked RxJava pipeline, and the start of chapter 2. 2017. Free sample: PDF · EPUB
4.
TDD for Android, Matteo Vaccari, Carlo Bellettini: Time-tested tricks to do Test-Driven Development well Free sample: chapter 1, the Unit Doctor app from spike and acceptance test to presenter-first unit tests. 2016. Free sample: PDF · EPUB
5.
Retrofit: Love Working with APIs on Android, Marcus Pöhls: Take delight in building API clients on Android. Free sample: the introduction and chapter 1, the quick start and the ServiceGenerator. 2019. Free sample: PDF · EPUB
6.
Glide: Customizable Image Loading on Android, Norman Peitek Free sample: about the book and chapter 1 on loading images, GIFs and video thumbnails. 2019. Free sample: PDF · EPUB
7.
Picasso: Easy Image Loading on Android, Norman Peitek: The Fast Approach to Build Image-Rich Apps Free sample: about the book and chapter 1 on image loading. 2019. Free sample: PDF · EPUB
8.
Gson: Enjoy JSON (De-)Serialization in Java, Norman Peitek Free sample: about the book and chapter 1 on Java-to-JSON mapping. 2019. Free sample: PDF · EPUB
9.
Mastering Android Screenshot Testing, Alex Zhukovich Free sample: the introduction and the start of chapter 2; chapter 1 is withheld and parts 4 and 5 were still to come. 2026. Free sample: PDF
10.
Mastering Mobile Application Development - 2nd Edition, Jonathan Engelsma, Hans Dulimarta: Learning iOS and Android Side-By-Side Free sample: front matter and the full table of contents; no chapter prose. 2021. Free sample: PDF
11.
Android Studio Development Essentials - Android 7 Edition, Neil Smyth: Learn to develop Android 7 apps with Android Studio 2.2 Free sample: the copyright page and table of contents of 75 chapters; no chapter prose. 2016. Free sample: PDF
12.
Kotlin Essentials, Marcin Moskała Free sample: what Kotlin is, the first program, and decompiling Kotlin to Java; the front matter and later chapters are withheld. 2026. Free sample: PDF · EPUB
13.
Effective Kotlin, Marcin Moskała: Best practices Free sample: Item 1, limit mutability; the front matter is withheld. 2026. Free sample: PDF · EPUB
14.
Functional Kotlin, Marcin Moskała Free sample: the introduction, conventions, reviewers and the start of the introduction to functional programming. 2026. Free sample: PDF · EPUB
15.
Advanced Kotlin, Marcin Moskała Free sample: the introduction and the start of the chapter on generic variance modifiers. 2026. Free sample: PDF · EPUB
16.
Kotlin Coroutines, Marcin Moskała: Deep Dive Free sample: the introduction, book structure, version note and part openers; the chapter bodies are withheld. 2026. Free sample: PDF · EPUB
17.
Atomic Kotlin, Bruce Eckel, Svetlana Isakova Free sample: front matter, table of contents, copyright page and the Section I introduction on how the book teaches. 2021. Free sample: PDF · EPUB
18.
Functional Programming Ideas for the Curious Kotliner, Alejandro Serrano Mena Free sample: front matter, the full table of contents and the start of the introduction. 2025. Free sample: PDF
19.
KMP for Mobile Native Developers, Santiago Mattiauda: A Hands-on Guide to Kotlin Multiplatform for Android and iOS Free sample: the table of contents, preface and chapter 1 on the four approaches to Android and iOS. 2026. Free sample: PDF
20.
CMP for Mobile Native Developers, Santiago Mattiauda: A Hands-on Guide to Compose Multiplatform for Android and iOS Free sample: the table of contents, preface and the start of chapter 1. 2026. Free sample: PDF
21.
Migrating Production Apps to Kotlin Multiplatform and Compose Multiplatform, Anubhav Savant: An Operational Guide for Migrating Existing Production Android and iOS Apps to Kotlin Multiplatform and Compose Multiplatform Free sample: the table of contents only. 2026. Free sample: PDF
22.
Ionic framework, Nikola Brežnjak: step by step from idea through prototyping to the app stores Free sample: chapter 1, the native, mobile web and hybrid comparison and installing Ionic. 2015. Free sample: PDF · EPUB
23.
Beginning Flutter 3.0 with Dart, Sanjib Sinha: A Beginner to Pro. Learn how to build Advanced Flutter 3.0 Apps Free sample: chapter 15 on constraints and widget sizing. 2022. Free sample: PDF · EPUB
24.
Flutter 3 From Scratch: A Practical Guide with Real Projects, Andrés Cruz Yoris: Build mobile, web, and desktop apps from scratch with Flutter 3, Dart, Firebase, Provider, Redux, and BLoC Free sample: the preface, intended readers and chapter map; no chapter prose. 2026. Free sample: PDF
25.
Flutter: Zero to App, Pouya Hosseini Free sample: part of chapter 3 on the basic widgets. 2020. Free sample: PDF
26.
Jetpack Compose internals, Jorge Castillo No sample: from the description and table of contents. 2022.
27.
Jetpack Compose Mechanisms, Jaewoong: A dissection of what runs beneath every @Composable No sample: from the description and table of contents. 2026.
28.
Jetpack Compose Mechanisms CourseCourse, Jaewoong: A dissection of what runs beneath every @Composable No sample: from the description; the course version of Jetpack Compose Mechanisms. 2026.
29.
Mastering Jetpack Compose: Canvas & Animation in Action, Mahmoud Ramadan: Design, Draw, and Animate Like a Pro No sample: from the description; the table of contents was empty. 2025.
30.
Master Android Sensors with Jetpack Compose Projects, Mahmoud Ramadan: Learn Android sensors through practical projects using modern Android development, Jetpack Compose, CameraX, Health APIs, and Sensor Fusion. No sample: from the description and table of contents. 2026.
31.
Android Development with Jetpack Compose & Kotlin (2026 Edition), A.P. Pyre: Build Modern Apps Using Android Studio, Material 3 & Google’s Latest Tools No sample: from the description; the table of contents was empty. 2026.
32.
Manifest Android Interview, Jaewoong: The ultimate guide to cracking Android technical interviews No sample: from the description and table of contents. 2026.
33.
Manifest Android Interview CourseCourse, Jaewoong: The ultimate guide to cracking Android & Compose technical interviews. No sample: from the description; the course version of Manifest Android Interview. 2026.
34.
Kotlin Design Patterns for Android Interviews, Mahmoud Ramadan: Master the 15 Patterns That Get You Hired No sample: from the description and table of contents. 2026.
35.
Practical Kotlin Deep Dive, Jaewoong: Unlocking the 'How' and 'Why' behind Kotlin fundamentals and internal mechanisms. No sample: from the description and table of contents. 2026.
36.
Practical Kotlin Deep Dive CourseCourse, Jaewoong: Unlocking the 'How' and 'Why' behind Kotlin fundamentals and internal mechanisms. No sample: from the description; the course version of Practical Kotlin Deep Dive. 2026.
37.
Kotlin: An Illustrated Guide, Dave Leeds: The fun way to learn Kotlin programming, one concept at a time! No sample: from the description and table of contents. 2026.
38.
Building Domain Specific Languages in Kotlin, Greg Milette: Kotlin language features and software design patterns for creating DSLs and improving code No sample: from the description and table of contents. 2019.
39.
Extending Android Builds, El Zhang: Pragmatic Gradle and AGP Skills with Kotlin No sample: from the description; the table of contents was empty. 2024.
40.
Continuous Integration for Mobile Apps, Pradeep Macharla: A Feedback loop pattern for build, deploy and test automation No sample: from the description and table of contents. 2016.
41.
Hands-On Mobile App Testing, Daniel Knott: A GUIDE FOR SOFTWARE TESTERS AND ANYONE INVOLVED IN THE MOBILE APP BUSINESS No sample: from the description and table of contents. 2022.
42.
Modern Android Security for Developers, Mahmoud Ramadan: Kotlin Patterns for a Dangerous World No sample: from the description and table of contents. 2026.
43.
Secure Android Design and Development, Mohammad Hossein Heydarchi: From App Layer to HAL No sample: from the description and table of contents. A course of the same title and slug carries the same material. 2025.
44.
Busy programmer’s guide to Firebase with Android., Isuru Madusanka, Rukman Bernard Fernando No sample: from the description and table of contents. 2017.
45.
State in Flutter, Sanjib Sinha: A Guide to State Management in Flutter No sample: from the description and table of contents. 2021.
46.
Better Flutter, Sanjib Sinha: Learn essential concepts to be a better Flutter developer No sample: from the description and table of contents. 2021.
47.
Programming React Native, Dotan Nahum No sample: from the description and table of contents. 2016.
48.
Cracking the Mobile System Design Interview, Mahmoud Ramadan: A Practical Guide to Android & iOS Architecture with Production-Ready Code No sample: from the description and table of contents. 2026.
49.
Mobile Coding Interviews Using Kotlin/Swift, Mahmoud Ramadan: Pattern-Based Problem Solving in Swift & Kotlin No sample: from the description and table of contents. 2026.
50.
Super App Part 1 - The Fundamentals, Sreejith K R: Creating A Mental Model by Analysing the Complexities & Approaches No sample: from the description; the table of contents was empty. 2023.
51.
100 Questions and Answers to help you land your Dream Android Job (or to hire the right candidate!), Enrique López Mañas No sample: from the description; the table of contents was empty. 2015.