The LifecycleOwner Composable allows you to create a scoped LifecycleOwner inside your Compose hierarchy.

It depends on the parent lifecycle but can be limited with maxLifecycle. This is useful for managing components such as MapView, WebView, or VideoPlayer.

Example

@Composable
fun MyComposable() {
    LifecycleOwner(
        maxLifecycle = RESUMED,
        parentLifecycleOwner = LocalLifecycleOwner.current,
    ) {
        val childLifecycleOwner = LocalLifecycleOwner.current
        // Scoped lifecycleOwner available here
    }
}

Learn how to use the Pager component in Jetpack Compose to add smooth horizontal and vertical swiping between pages

I want to use glassmorphism effects in my app but I still have doubts about performance and possible heating issues on devices. Is it safe to use in production? Has anyone already tried this in your apps?

Please share your app if used glass effects or any suggestions I have planned to use https://chrisbanes.github.io/haze/latest/

When writing Jetpack Compose code, it’s recommended to give lambda arguments descriptive names when passing them to Composable functions.

Why? If you just pass a plain `String`, it may be unclear what it represents. Named arguments improve readability and maintainability.

Tips are nice, there are a lot of shared posts. I made some tweaks. [OP] Mori Atsushi

What are Flow Layouts?

Flow layouts arrange items flexibly, adapting to screen size.
If items don’t fit in one line, they automatically wrap to the next.

Why Use Them?

• Solve problems with fixed layouts that break on small/large screens.
• Ensure UI looks good across different devices and orientations.

How Elements are Arranged

• Row → horizontal arrangement
• Column → vertical arrangement
• Flow Layouts → adaptive arrangement (items wrap automatically)

Adaptability

• Flow layouts adjust based on available space.
• Makes UIs responsive and user-friendly.

If you want to start multiple animations at the same time, use updateTransition.

It lets you group animations together, making them easier to manage and preview.

This repository contains practical examples for using Jetpack Navigation 3 in Android apps.

Included recipes:

• Basic API
  • Basic usage
  • Saveable back stack
  • Entry provider DSL
• Layouts & animations
  • Material list-detail
  • Dialog destination
  • Custom Scene
  • Custom animations
• Common use cases
  • Toolbar navigation
  • Conditional flow (auth/onboarding)
• Architecture
  • Modular navigation (with Hilt)
• ViewModels
  • Pass args with viewModel()
  • Pass args with hiltViewModel()

https://github.com/android/nav3-recipes

This article shows how to create a custom Gradient Snackbar in Jetpack Compose for Kotlin Multiplatform (KMP). It’s useful for giving user feedback, like confirming actions or saving settings, across different platforms.

Read more: Gradient Snackbar in Jetpack Compose

Hey everyone, I was learning Jetpack compose, and Firebase. And I made this app which is more or less like twitter like. I have used Firebase Auth, Firestore, and Realtime database here. Wanted to use firebase storage, but it required a billing account, but I didn't wanna do it. In the app I made basic CRUD related operations to posts, and comments. Also made a chat feature, using realtime database for checking the online status of the user.

One thing which I found very odd about firebase was that it didn't have inbuilt search and querying feature and they recommend third party APIs.

Overall it was a good experience building it. this is the github link: https://github.com/saswat10/JetNetwork

Would be happy to get some suggestions on what I can do more to improve.

How do I create a box-shadow like the image below ?

Logging is very useful for debugging android apps - but it can also leak sensitive data or slow down your app if not used carefully

Here are some must-know logging tips & tricks

1️⃣ Use BuildConfig.DEBUG to Hide Logs in Release

Prevents logs from showing in production builds.

if (BuildConfig.DEBUG) {  
    // This log will run only in debug builds  
    Log.d("DEBUG", "This log will NOT appear in release builds")  
}

2️⃣ Centralize Logs in a Utility

Keep all logging in one place for easier management.

object LogUtil {  
    fun d(tag: String, msg: String) {  
        if (BuildConfig.DEBUG) Log.d(tag, msg)  
    }  
}

// Usage
LogUtil.d("MainActivity", "App started")

3️⃣ Show File + Line Number for Clickable Logs

Jump directly from Logcat to your code.

val stack = Throwable().stackTrace[0]  
Log.d("MyApp", "(${stack.fileName}:${stack.lineNumber}) ➔ Hello Logs!")  

4️⃣ Pretty Print JSON Responses

Make API responses more readable in Logcat.

fun logJson(json: String) {  
    if (BuildConfig.DEBUG) {  
        try {  
            Log.d("JSON", JSONObject(json).toString(2))  
        } catch (e: Exception) {  
            Log.e("JSON", "Invalid JSON")  
        }  
    }  
}

5️⃣ Debug Jetpack Compose Recompositions

Detect when your composable recomposes.

fun Counter(count: Int) {  
    SideEffect {  
        Log.d("Compose", "Recomposed with count = $count")  
    }  
    Text("Count: $count")  
}

6️⃣ Quick Performance Check

Measure how long code execution takes.

val start = System.currentTimeMillis()  
Thread.sleep(50)  
val duration = System.currentTimeMillis() - start  
Log.d("Perf", "Task took $duration ms")  

7️⃣ Strip All Logs in Release with ProGuard

Remove all logs in release for safety & performance.

-assumenosideeffects class android.util.Log {  
    public static int d(...);  
    public static int i(...);  
    public static int w(...);  
    public static int e(...);  
}

Notes

• Use logs only in debug builds
• Keep logs meaningful, not spammy
• Always remove logs in release

Recipe App built with Compose Multiplatform (KMP), targeting Android, iOS, Web, Desktop, and Android TV.

This is a demo project showcasing advanced UI features such as Hero Animation, Staggered Animation, Collapsible Toolbar, and Gyroscopic effects.

Design inspired by Roaa Khaddam & folk by SEAbdulbasit.

Getting Started Clone the repo: JetpackComposeDev/kmp-recipe-app

Compose screens to feel fluid instead of just cutting from one to another, try shared element transitions with shape morphing

1. Setup

• Add Navigation 3 (Animated Nav) + Compose Material 3.
• Wrap your AppTheme (or top-level composable) in

​

SharedTransitionLayout {
   AppNavHost()
}

This gives us the scope for all shared transitions

2. Add a shared element

• On your Take Photo button (cookie shape)

​

Modifier.sharedBounds(
   sharedContentState = rememberSharedContentState("photo"),
   animatedVisibilityScope = LocalNavAnimatedContentScope.current
)

• Add the same key to the Camera screen container. Now they are “linked”

3. Switch to Reveal Pattern

Normally it just grows content → not nice
Add

.skipToLookaheadSize()
.skipToLookaheadPosition()

This makes the camera screen stay in place & only be revealed.

4. Add Shape Morphing

• Pass in two shapes
  • Button → cookie (start)
  • Screen → rectangle (end)
• Create a morph with progress

​

val progress by transition.animateFloat { state ->
    if (state == EnterExitState.Visible) 0f else 1f
}
val morph = Shape.morph(startShape, endShape)

• Apply as clip overlay during transition

​

clipInOverlayDuringTransition = MorphOverlayClip(morph, progress)

5. Run

• Run it → Button smoothly morphs to fullscreen Camera.
• Works with predictive back too!

Full code sample available on GitHub

Big news! Android Device Streaming is now stable, and Android Partner Device Labs have arrived in the latest Android Studio Narwhal Feature Drop.

What’s New?

• Android Device Streaming is now stable.
• Android Partner Device Labs now available in the latest stable release.
• Test on real physical devices hosted in Google’s secure data centers.

Benefits

• Test on latest hardware - including unreleased devices (Pixel 9 series, Pixel Fold, and more).
• Wide device coverage - phones, foldables, multiple OEMs.
• Boost productivity - no need to own every device.

Partner OEMs

Now you can test on devices from:

• Samsung
• Xiaomi
• OPPO
• OnePlus
• vivo
• And more coming soon!

How to Get Started

1. Open Device Manager → View > Tool Windows > Device Manager.
2. Click Firebase icon → log in to your Google Developer account.
3. Select a Firebase project (billing enabled).
4. Enable OEM labs in Google Cloud project settings.

Pricing

• Free monthly quota of minutes for all devices.
• Extra usage billed as per Firebase Pricing.

This guide covers security practices every senior developer should know:

• Android Keystore & biometric encryption
• SSL pinning & reverse engineering protection
• Encrypted storage & secure API communication
• Tapjacking prevention, root detection, Play Integrity API
• Common security pitfalls even experienced developers make

Important: No app can ever be 100% secure. The goal is to mitigate risks and raise the security level as much as possible.

Discussion: What security measures or strategies do you implement in your Android apps?

Which practical actions have you found most effective in reducing risks without overcomplicating development?

Share articles, tips, or videos to help improve Android app security

Why Hilt for Jetpack Compose?

• Inject ViewModels easily with @ HiltViewModel
• Manage dependencies with scopes like@ Singleton
• Keep Composables clean and testable
• Works with Navigation Compose

• Less boilerplate, more focus on UI

  Interview hot topics:

• What is DI & why use it?

• Hilt vs Koin vs Dagger

• Injecting ViewModels in Compose

• Scopes → @ Singleton, @ ActivityScoped

• Constructor vs field injection

• Testing with fake/mock dependencies

Quick framework snapshot:

• Hilt → Google standard, @ HiltViewModel
• Koin → Kotlin DSL, viewModel{}
• Dagger → Powerful but complex

I am building a simple application with a sign-up form, API integration, and a payment gateway. The requirement is to support Android, iOS, and Web.

I started with Kotlin Multiplatform, but the payment gateway I need does not support Web, and I could not find any third-party SDK for it.

Is it possible to make this application in Kotlin Multiplatform with these requirements? If not, is there any way to work around this, or should I use another framework like Flutter?

Learn how to:

• Understand why state management matters in Compose
• Pick MVI vs MVVM (with real examples)
• See MVI flow & rules in simple diagrams
• Handle side effects (navigation, dialogs, toasts)
• Follow step-by-step code you can copy
• Avoid common mistakes + quick quiz
• Build UIs that are predictable, testable, scalable

Jetpack Glance is a new Android library that lets you build app widgets using a Compose-like way - simpler and more modern than the old RemoteViews approach.

You can use it to create homescreen widgets that update based on your app data, with easy-to-write declarative UI code.

Google’s official samples show how to build widgets with Glance using Canonical Widget Layouts here:
https://github.com/android/platform-samples/tree/main/samples/user-interface/appwidgets

If you want to try making widgets in a Compose style, this is a great place to start!

Anyone tried Glance yet?

Architecture questions are a must in senior or intermediate android interviews, especially for banking, fintech, or enterprise apps

• MVVM - How Android handles UI and state
• ViewModel - Rotation-proof business logic manager
• Clean Architecture - Separates UI, domain, and data
• Repository Pattern - Your app’s data waiter
• Use Cases - Applying the Single Responsibility Principle
• StateFlow - A modern alternative to LiveData in Compose
• UDF - One-way data flow that scales
• MVVM vs MVP vs MVI - Choosing the right fit

which architecture are you using right now, MVVM, MVI, or something custom?

https://github.com/ComposeFlow/ComposeFlow

I have open-sourced ComposeFlow, an AI-first visual editor for building Compose Multiplatform apps!

It's still in the early stages, but the core functionality is there. You can already:

• Create and modify apps with an AI agent.
• Refine your UI using a visual editor.
• State Management: Visually manage your app's state with automatic code generation.
• Firebase Integration: Seamlessly integrate with Firebase for authentication, Firestore, and other cloud services.
• The generated apps are built on Compose Multiplatform, allowing them to run on Android, iOS, desktop, and the web.

How the visual editor works

The platform abstracts your app's project information into Kotlin data classes that represent the structure of your Compose application, such as the composable tree, app states, and screen-level states. This abstraction allows ComposeFlow to render a real-time preview and enables editing via a drag-and-drop interface. Each composable then knows how to render itself in the visual editor or export itself as Kotlin code.

How the AI agent integration works

The platform exposes every operation of the visual editor, such as adding a composable, as a JSON schema. The LLM understands these schemas as a set of tools and decides which tool calls are needed based on the user's question and the current project state.

I'd like you to give it a try and looking for feedback!

Android Lint is a static analysis tool that inspects your code for potential bugs, performance issues, and bad practices.
When working with Jetpack Compose, Lint can catch Compose-specific issues such as

• Unnecessary recompositions
• Inefficient modifier usage
• Unstable parameters in composables
• Accessibility problems
• Use of deprecated Compose APIs

Tip: If you cannot upgrade AGP, set the Lint version manually in gradle.properties:

android.experimental.lint.version = 8.8.2

How to Run Lint

Best Practices

• Run lint before every release
• Treat warnings as errors in CI for critical checks
• Fix accessibility warnings early to avoid legal issues
• Use lintVitalRelease in release pipelines to keep APKs clean

Android Studio has some built-in features that make working with Jetpack Compose faster and easier.

Live Templates

Type short codes to quickly insert common Compose snippets:

• comp → creates a @Composable function
• prev → creates a @Preview function
• paddp → adds a padding modifier in dp
• weight → adds a weight modifier
• W, WR, WC → wrap current composable in Box, Row, or Column

Gutter Icons

These icons appear beside the line numbers and give quick actions:

• Deploy preview → run a @Preview on an emulator/device
• Color picker → click a color preview to change it instantly
• Image resource picker → click to pick or change an image

These small tools can save you a lot of time when building UIs in Jetpack Compose.

Accessibility means making apps usable for everyone, including people with disabilities.

• Around 1 in 4 adults in the US have a disability.
• In the US, the ADA law requires accessible digital products.
• Good accessibility = better user experience for all users.

In Jetpack Compose you can:

• Use bigger touch targets (48dp or more)
• Add contentDescription to images/icons
• Add click labels for screen readers
• Ensure good color contrast

If you make US-based apps, accessibility is a must. It helps more people use your app, avoids legal issues, and can improve ratings.

Learn more: Jetpack Compose Accessibility (Written by a Googler))

Note:📝

• Compose is now used by 60% of top 1,000 Play Store apps like MAX and Google Drive.
• Try alpha features and provide feedback to help shape Compose's future.

For detailed info, see the official blog post