35 Advanced Topics

Looking Beyond the Basics

By the time you reach this part of the course, you already know how to build complete Android apps with layouts, networking, storage, and modern architecture. This chapter is here to open the door to topics that go beyond standard usage and give you a preview of what is possible when you start customizing the Android platform more deeply.

This chapter will not fully teach you everything about those subjects. Instead, it will help you understand why they matter, what they enable, and how they fit into the bigger picture of Android development. The detailed, hands on material will appear in the child chapters that follow.

What “Advanced” Means in Android Development

In Android, “advanced” rarely means you must write more code. More often, it means that you take more control over how Android behaves and how your app is structured. You already know how to use system provided components like Button, RecyclerView, ViewModel, Retrofit, and Room. At an advanced level, you start asking different questions.

You begin to ask how you can create brand new UI components that behave exactly as you want. You consider how you can simplify state handling, side effects, and configuration changes. You think about how to reduce boilerplate and make your app easier to test and maintain for years, not just days.

In this course, the “Advanced Topics” section focuses on two specific directions where modern Android is evolving: custom views and Jetpack Compose.

Why Customization Matters

Android provides a rich set of built in views and components. For many apps, these are enough. At some point, however, you will encounter a design or interaction that cannot be achieved by simply combining existing components or applying styles.

Imagine you must create a progress indicator with a very specific animation, a circular slider that works like a volume knob, or a fully branded chart that follows your product’s identity exactly. It might be possible to fake these with several views and a lot of styling, but the result is often complex, hard to maintain, and limited.

Advanced Android development encourages you to see the UI toolkit as something you can extend, not just use as is. This is where custom views become important. They let you design reusable components that feel like native parts of the platform and can be tuned precisely for performance and interaction.

At the same time, Google has been building a new UI toolkit called Jetpack Compose. It rewrites how you think about UI, state, and layout, and it is quickly becoming the recommended way to build new Android user interfaces. Learning to think in terms of composable functions is a different type of “advanced,” where the complexity lies in managing state and understanding declarative patterns.

Where Custom Views Fit In

The chapter on Custom Views will focus on situations where the traditional View system is still very powerful. Even in a world that includes Jetpack Compose, custom views are relevant because many apps still rely on XML layouts and existing View based screens.

Custom views are valuable when you need complete control of drawing and interaction while staying in the classic view hierarchy. They are also important when you want to create reusable design system components that multiple apps can share.

You will see how custom views let you define your own rules for measuring, laying out, and drawing content, and how input events can be interpreted in richer ways than what basic controls allow. You will also see how to expose custom attributes so that designers or other developers can configure your view from XML with the same convenience they have with built in controls.

The crucial point is that custom views are not just about visual uniqueness. They are about encapsulation. A complex pattern such as a combined input field with validation, labeling, and icons can be wrapped in a single view so that the rest of your app does not need to know about all the internal details.

Where Jetpack Compose Fits In

While custom views extend the classic toolkit, Jetpack Compose introduces a different approach to building UI. Instead of writing XML and separate Kotlin classes that manipulate it, you describe your UI directly in Kotlin using composable functions. The UI becomes a pure function of state, which is an important conceptual shift.

In the Jetpack Compose chapter you will see how to define composable functions that express your UI in a more declarative way. This will include the idea that when state changes, Compose automatically recomposes the parts of the UI affected by that state. This is different from manually finding views and updating their properties one by one.

Compose also changes how you structure screens, how you think about navigation, and how you manage theming and behavior across your app. You will see that although it is a new toolkit, it still interops with the existing view system. This means you can gradually adopt Compose in an existing project instead of rewriting everything at once.

Compose is considered advanced at first because it asks you to think differently about reusability, state hoisting, and side effects. Over time, many developers find it simpler to reason about than complex nested layouts in XML. This transition from an imperative to a declarative mindset is a big part of modern Android development.

Choosing Between Classic Views and Compose

As an advanced Android developer you will often be asked which UI approach to use. Even at a beginner level it is helpful to know the main idea behind that decision, without going into all of the technical details.

Custom views and the classic View system are still common in many production apps. There are large codebases, established design systems, and libraries that rely on this stack. If you maintain such an app or build features on top of an existing structure, creating or extending custom views is often the natural choice.

Jetpack Compose is more suitable when you start a new screen or a new app where you can benefit from reduced boilerplate and a more testable, state driven UI. It is also attractive if your team is comfortable with functional patterns and you want a more modern architecture.

In practice, many real projects mix both. For example, you might embed custom views inside Compose screens, or place Compose content inside existing ViewGroups. This hybrid pattern lets teams incrementally migrate while keeping the best parts of their current systems. Knowing that interoperability is possible makes it less stressful to commit to learning Compose.

At this stage of the course, the goal is not that you master every technique. Instead, it is that you recognize the tradeoffs. The detailed chapters that follow will guide you through concrete examples that show how each tool works and when it shines.

How These Topics Extend What You Already Know

Everything in this “Advanced Topics” section builds on skills you have already learned. When you study custom views, you will reuse your knowledge of the Android view hierarchy, layout parameters, and resources. You will simply go to a deeper layer of control.

When you study Jetpack Compose, you will still rely on your understanding of activities, lifecycle, and architecture components like ViewModel. Compose does not replace these ideas. It changes how screens are built and how state flows into the UI, but the platform fundamentals you already learned remain valid.

You have already seen MVVM, LiveData, and ViewModel. Compose will integrate with these ideas and often make them easier to express. Custom views will benefit from the performance and profiling tools you previously encountered, especially when you design complex drawing logic.

Because of this continuity, you can see “advanced” not as a separate world, but as the next layer on top of everything you have been practicing.

What You Will Focus On Next

In the next chapters you will dive into each advanced topic with a beginner friendly yet practical approach. You will not build huge, production ready libraries, but you will learn enough to recognize patterns and feel confident exploring further.

In the Custom Views chapter, you will focus on how to create a simple but non trivial component, how to measure its size, how to draw on the screen, and how to respond to user interaction in a controlled way. You will also see how to integrate it back into regular XML layouts so that it behaves like any other view.

In the Introduction to Jetpack Compose chapter, you will focus on the basics of composable functions, state handling within Compose, and how to create and preview simple UI elements without needing complete activities or fragments. You will see how Compose changes your layout thinking, and how it can coexist with what you already know.

By the end of the Advanced Topics section you will not only be able to follow tutorials. You will also have the conceptual tools to understand documentation, library code, and more complex examples that you will see in professional Android projects.

With this mindset in place, you are ready to explore the specific advanced techniques that will give your Android apps more power, flexibility, and longevity.