Hi, I am writing instrumented tests for Android app. The app allows users to sign in using SSO with Intune MAM SDK, and this leads to work accounts being created. You can look them up in settings on the emulator in Passwords & Accounts section.

I need to remove these accounts before each test - I was trying to do that with the code below:

private fun ensureClearSettingsAccounts() {     val accountManager = AccountManager.get(getApplicationContext())     val accounts = accountManager.accounts     accounts.forEach { account ->         accountManager.removeAccount(             account,             getApplicationContext(),             null,             null         )     } }

the problem with that is that it ONLY fetches Google accounts, it doesn't fetch any work accounts or accounts connected to Microsoft Company Portal. If I get and log accountManager.authenticatorTypes though, I can see that there are package names connected to existing work profiles created by CP like com.microsoft.workaccount, com.microsoft.workaccount.cp, com.microsoft.msa.cp.

How can I remove these accounts? The device is NOT rooted and cannot be rooted. Clearing packages through ADB doesn't work (add shell pm clear <pkg name>). Applying some user permissions such as GET_DATA and stuff also don't change anything. The API version is 34.

What are your predictions and thoughts and experiences for the mobile android dev job market, especially in Europe ?

Currently, I'm finishing my bachelors CS degree in Europe and thinking about to pursue my interest in mobile android development and focus on gathering in this field skills and probably getting a job here. But I don't have any idea how sustainable this is, considering the job market currently and in the future for android developers ?

Or is cross-platform the way to go for future mobile devs ? (like React Native etc...)

Would be curious what you guys are thinking about and how freshmen are valued currently in the job market for mobile android development.

For the past 5 years I have been teaching Android dev course at a university using materials and presentations from Google: https://developer.android.com/teach#teach-a-class

The issue is these official presentation materials are getting a bit long in a tooth.

The presentations were made circa 2020 and do not really cover Compose for one, it is all XML.

Where would one find decent up to date teaching materials?

I would have expected for Google to update the presentations but they seem stuck at version 1.0...

Anyone try R1?

It's an open source model thats supposed to be on par with OpenAI's O1 performance, a closed source model and current leader. But I want to know if it actually does well specifically for kotlin/jetpack compose from your experience because benchmarks are sort of hand wavey and not really focused on android engineering at all.

These models have knowledge cut-off dates, and android libs change year over year with improvements.

Have you tried it and what has your experience been compared to the other models (ie. Gemini, Claude, O1)

side note: mods please don't take this down. I think this could be a good neutral discussion, and it is extremely relevant to android engineering because we're seeing open source models get better at helping us write code (our literal jobs) that we can also now self-host and have full control over it. Thanks!

I prefer my android studio appearance to be a particular way, i.e. the project files to be on the right side instead of the left side but every time I switch to a new project, the new project usually has the default UI appearance.

How do I make my custom appearance settings persistence?

Please help.

Hello!

I do most testing on the Internal Testing (no Closed Testing, no Open Testing), and the Google account of my Android phone and on my Google Play app is included among the testers on Google Play Dev.

Is there a way to be able to have access to the Production version without needing a second device with a separate account that has never been a testing account for that app?

I ask because

1 - having a second account (not enrolled as a tester) in the Google Play app doesn't seem to make a difference

2 - removing an account from the testers on Google Play console doesn't seem to make a difference (kinda once a tester, forever a tester), but maybe it's because the overall main account for the phone is still the testing one

Why I can't seem to be able to access both Internal Testing and Production with one account?

Thanks

I’m building a notes + to-do + reminders app with advanced features, a modern design, and a better user experience. It’s almost ready and should be done in a month. The app will be ad-free but might have premium features.

I’m a solo developer with little marketing experience and a small budget (I can arrange some funds, but not much). I plan to launch in two months but not sure how to go about it.

1. Launch on Play Store, market it myself, and offer premium features.

2. Make it open-source, offer everything for free, and rely on donations.

3. Hire a marketing team (but not sure if it's worth it for a notes app).

4. Any better ideas?

Which option should I go with?

(Note: This article was first published on our blog, we hope you find it useful)

For a long time, we had a problem with user reviews in TimeTune. Although we were using the recommended In-App Review API, we received very few reviews compared to the amount of daily downloads.

Most reviews were positive, so we already knew that users like the app. But the small amount of reviews made that the pace of growth for our Google Play rating was excruciatingly slow.

What was happening? 🤔

It turns out that TimeTune doesn’t have a specific ‘winning’ moment in the app. Winning moments are those occasions where a user completes a specific action that triggers a clear sense of accomplishment and satisfaction (for example, completing a level in a game). Showing a review prompt in such occasions increases the chances of receiving a positive review.

But being a time-blocking planner, we didn’t have a perfect place to show the review prompt. Instead, we were showing it from time to time in the main screen when the user opened the app.

In other words, we were interrupting the user’s experience and workflow. And that probably lead to the review prompt being dismissed most of the time 😖

We needed a different approach.

PSYCHOLOGY TO THE RESCUE

That’s when we turned our attention to one of the most acclaimed books in the world of persuasion: ‘Influence: The Psychology Of Persuasion‘, by Robert Cialdini. If you’re a developer and haven’t read that book yet, we highly recommend it. Seriously, it’s full of ideas you can implement in your apps.

Using the principles from that book, we began to design a process where we could ask for reviews in a non-intrusive way (and if possible, increasing the ratio of positive reviews even more).

And it worked. Big time.

Here’s how we did it:

DRAWING ATTENTION

First, we needed a way to draw the user’s attention without interrupting. So on the main screen, we added a red badge to the top menu’s overflow icon:

Adding a badge to the overflow icon

Notice however how that badge is not a dot, it’s a heart. That detail, although small, is very important psychologically speaking. Besides being the start of the review path, that heart is already moving the user towards a positive frame of mind.

Also, curiosity has been aroused: “That’s not a normal badge”. All users without exception will click there to see what the heart is about. So that’s another win, because this approach will draw more clicks than the ordinary in-app review prompt.

The user is now thinking: “What could this heart be?”

FOLLOWING THE PATH

Clicking on the overflow icon opens the top submenu. Here we needed a way to direct the user towards the proper option, in this case our settings:

Leading the user towards the right option

Instead of highlighting the settings option with a different method, we used the read heart again to mark the way. At this moment, the user knows they need to ‘follow the heart’.

As they already took the first step by opening the overflow menu, the user is now invested in the process (another psychological principle). Again without exception, they will click on this second heart, which at the same time reinforces their move towards a positive frame of mind.

MAKING THE ASK

Now that the user is in the screen we want them to be (you’ll see why soon), it’s time to ask for the review. However, we’re not doing it directly 😮

If we showed an ordinary ‘Please give us a review’ message, the user would probably dismiss the dialog like they did when they saw the old in-app review prompt (also, a message like that could have been shown in the main screen).

Instead, we’re showing the following message:

Asking for support

Notice how we’re still showing the red heart, but bigger. This heart symbolizes now several things at the same time:

• Our love for the user.
• That we’re asking for their support in the kindest way.
• Most importantly, the love the user feels for the app.

We also made the dialog not cancelable, so the user needs to click on ‘Got it’ to dismiss it. This seemingly unimportant detail records in the user’s mind that they indeed got the message, reinforcing their commitment to this process (a good alternative would be to show something like ‘I will do my best’ in the button).

Remember, this dialog is not an interrupting dialog. It’s the user who initiated the process and ‘followed the heart’.

So, since they already clicked on ‘Got it’ and they are in a positive frame of mind, it’s easy to scroll a bit and see what this is all about.

GAMIFYING TASKS

This is the final and most important step. Here is where the persuasion principles shine.

Here’s what appears at the end of our settings screen:

Gamifying the process

The header in this section is crucial. Besides using the heart again to mark the final step, we switched to the first person to express the user’s thoughts. Why is this important?

The use of the first person in that sentence filters out all those users who don’t identify with it. This happens unconsciously. A user who doesn’t like the app won’t feel motivated to leave a review here (even a negative one). But a user who likes it will.

Besides, in psychology, it’s a well known fact that writing down a statement reinforces your commitment with it (for example, writing your personal goals on paper). So using the first person in that sentence makes it seem as if the user wrote it themselves, reaffirming their commitment ✍️

Finally, we also added gamification components, like a ‘Done’ button in each support task and a progress bar to indicate how many of the tasks are completed.

Notice how the first task is marked as completed by default. ‘Install the app’… duh. But persuasion principles tell us that showing a progression as already started motivates the user to keep going with it, so that’s what we’re doing here ✔️

Also, why ask for several support tasks and not just one? Because if a user cannot complete all tasks (especially the last one, upgrading to premium), they’ll probably think: “Well, the least I can do is leave a review”.

👉 Keep in mind that users will click more on the top tasks and less on the bottom ones, so put the most important task at the top (well, the most important task would be upgrading to premium, but we have dedicated buttons for that in several screens, so here we ask for a review).

In any case, the gamification instinct will lead users to complete as many tasks as possible. So use this approach to show all the support tasks that can help with your project (in our case, we’d like users to try our other apps).

If a user completes all tasks, it would be a good idea to give them some kind of prize or reward. That would reinforce their satisfaction and strengthen the bond with your app (that’s something we still need to implement).

RESULTS

After publishing the new approach (even in beta), we started to see results immediately. Not only did the amount of reviews increase a lot, but all the reviews were extremely positive! 🎉

And maybe not surprisingly, the amount of negative reviews decreased too. That probably happened because of two factors:

• With the old approach (the in-app review prompt), some users left negative reviews because we were interrupting their workflow; now that we’re not interrupting, those reviews are not happening anymore.
• The in-app review prompt also appeared to all users -happy and unhappy-, while now we’re targeting happy users only (we still want feedback from unhappy ones, but preferably through email).

We liked the new approach so much that we ended up removing the in-app review API completely! However, depending on the type of app you’re developing, it may be better to use one approach or the other (or even a combination of both). You need to test and measure.

BE HONEST

Using persuasion and psychology principles in your app is not a license to trick your users in deceiving ways. That never works, users are not dumb.

Be honest, treat your users with respect and they will love you for it ❤️

We hope this article can bring new ideas to your projects. Those ideas certainly worked for us.

Cheers! 🥰

I'm working on an SDK project for my team at work. From my clients' perspective, the SDK is a collection of public-facing interfaces that they can utilize. We plan on implementing each of those interfaces within the SDK. I would like each of these implementations to be hidden from the client. If I were doing this work within one standard Android gradle project, that would be simple; split up the interface and its implementation into separate modules, and have a wiring module on top of the two, which has an api dependency on the interface module, and an implementation dependency on the impl module. From what I've read and been told, that won't work to withhold access if I'm returning a single AAR to my clients.

One idea for solving this level-of-access problem would be to encapsulate all of my code into one behemoth module, and just use "internal" modifiers on class I want hidden from my client. This seems like a disorganized and non-scalable mess, quite frankly. I'm wondering if there are other solutions I can go for that will do what I need? Any help is appreciated.

Hi everyone,

I’m currently learning Android development and working with Kotlin and Gradle, and I’ve noticed that folder organization varies quite a bit across different projects. Some people put everything in the root directory, others separate resources and classes into different subdirectories, and some follow more complex approaches.

Are there any conventions or best practices recommended for organizing folders in a Kotlin project with Gradle, or is it just a matter of personal preference? Should I follow a specific structure to maintain consistency or facilitate project scalability?

Any advice or experiences you could share would be really helpful. Thanks!

Hi guys,

I'm trying to use the CalendarContract API to access calendar events synced on the user's device. It's working for the primary (Google) account but not working with the other account, for example secondary Outlook.

I asked for READ_CALENDAR and GET_ACCOUNTS permissions, I can list the calendars, I can list the events and instances of the calendars of the primary account only. The events and instances of other accounts are not listed. :/

Is there any limitation or I missed something important about it? I will add snippets as comments because of the Reddit's limitations.

Edit: I added another Google account and my app can read that account's calendar events without any issue, but it cannot access the Outlook account's calendar events.

Hey everyone, just sharing a library I’ve been working on that makes it simple to push real-time data (not FCM or traditional push notifications) to Android apps using gRPC streams. Perfect for syncing state across devices or updating UI in real time—think live order updates, location tracking, or instant coupon alerts. Unlike FCM, you have full control over structured JSON data, allowing you to send it in any format and handle it however you need in your app.

Some highlights:

• Persistent gRPC streams – No WebSockets, no polling, just a direct connection
• Handles reconnections – No need to manage it manually
• Workflows for automation – Trigger pushing data based on events, conditions, and user actions
• Infra managed for you – No servers to set up, no scaling headaches
• Only takes a few lines of code – Simple SDK integration
• Free tier – Try it out completely free, no setup cost

Would love feedback from other Android devs!

🔗 Pushlytic.com

🔗 Android SDK

Do not know why and when it happened, but I want to reset it or do something to that regard. Please help!

Hey guys, this discussion came up and like title, I was pretty surprised they weren't using Alias or scrcpy. So I showed them my aliases and workflow and they thought it was very helpful. It gave me idea to share with you guys too. So I created this repo with alias that I use (modified to be generic). I also made a youtube video to share these and some other tips. Hope it helps to improve your daily workflow a little bit.

@HiltViewModel
class MyViewModel @Inject constructor (
    private val savedStateHandle : SavedStateHandle
    private val someApi : SomeApi
) : ViewModel() {
  private val KEY = "someKey"

  val uiState = savedStateHandle.getStateFlow(KEY, "")
      .flatMapLatest { search ->
          if ( search.isBlank() ) {
              flowOf(UiState.Idle)
          } else {
            /*
             * Plenty logic goes here to fetch data from API.
             * An interim Loading state is also emitted.
             * Final Completion states are the usual, Success or Failure.
             */
             ...
          }
      }.stateIn (
        viewModelScope,
        SharingStarted.WhileSubscribed(),
        UiState.Idle // One of the declared UiStates
      )

  fun searchTerm(term: String) {
      savedStateHandle[KEY] = term
  }
}

In the Test class

class MyViewModelTest {
    private lateinit var savedStateHandle: SavedStateHandle

    @Mockk
    private lateinit var someApi: SomeApi

    private lateinit var viewModel: MyViewModel

    @Before
    fun setUp() {
        MockkAnnotations.init(this)
        // tried Dispatchers.Unconfined, UnconfinedTestDispatcher() ?
        Dispatchers.setMain(StandardTestDispatcher()) 
        savedStateHandle = SavedStateHandle()
        viewModel = MyViewModel(savedStateHandle, someApi)
    }

    @After
    fun tearDown() {
        Dispatchers.resetMain()
        clearAllMocks()
    }

    @Test
    fun `verify search`() = runTest {
        val searchTerm = // Some search-term
        val mockResp = // Some mocked response
        coEvery { someApi.feedSearch(searchTerm) } returns mockResp

        // This always executes successfully
        assertEquals(UiState.Idle, viewModel.uiState.value) 

        viewModel.searchTerm(searchTerm)
        runCurrent() // Tried advanceUntilIdle() also but -

        // This always fails, value is still UiState.Idle
        assertEquals(UiState.Success, viewModel.uiState.value) 
    }
}

I had been unable to execute / trigger the uiState fetching logic from the savedStateHandle instance during the unit-test class test-run.

After a lot of wasted-time, on Gemini, on Firebender, on Google-search, etc, finally managed to figure -

1) Dispatchers.setMain(UnconfinedTestDispatcher())
2) replace viewModel.uiState.value with viewModel.uiState.first()
3) No use of advanceUntilIdle() and runCurrent()

With the above three, managed to execute the uiState StateFlow of MyViewModel during Unit-test execution run-time, mainly because 'viewModel.uiState.first()'

Still fail to collect any interim Loading states.

Is there any API, a terminal-operator that can be used in the Unit-test class something like -

val states = mutableListOf<UiState>()
viewModel.uiState.collect {
    states.add(it)
}

// Proceed to invoke functions on viewModel, and use 'states' to perform assertions ?

Has there been any attempt on making a different UI preset library thats supposed to compete with Material3 or Material in general? This goes for both Compose and XML

Fellow Android dev here.

If you work on an Android app that requires entering a 2FA code that's been emailed to me, for the love of God(s), PLEASE maintain the app's state. Use Workflow, Circuit, Mavericks, some other library, or maintain it yourself. I don't care.

If I go to my email inbox on my phone to view the code and then come back to the app, the app shouldn't reset and begin at the start of the authentication flow again. I have to enter my phone number and so on ♻️ Especially if I don't have access to view my inbox on a laptop or something, it's so annoying. It's not hard, but the only trick I've found is to use Android split screen to view Gmail and the other app at the same time.

Or am I not thinking of a security reason to not doing this?

Hi! Sorry if it's a silly question. I'm working on an app with lot of legacy code. I'm seeing this error every time on app start but besides it being in the log, the app seems to be working fine. Maybe someone renamed something in the past that could be the reason. Do you know where I can find the problem?

GoogleApiManager: Failed to get service from broker. java.lang.SecurityException: Unknown calling package name com.google.android.gms. at android.os.Parcel.createExceptionOrNull

Long-time Android dev here, and after 10 years of developing Android apps I STILL haven't found a good solution for app marketing. Traffic from Google Ads, TikTok, Facebook, etc. is still so unreliable and flaky. Other places like Apptimizer look like a total scam (and this is backed up by the reviews on TrustPilot).

So I set out to create something better. Think of it like focus groups for your mobile app. We have a curated list of high-quality, US-based mobile app users - people who are curious to try and evaluate new mobile apps.

The installs aren't 5 cents each, but then again you get what you pay for.

https://tapscout.net

I'm looking for any initial feedback you folks might have, any feedback at all would be appreciated.

As part of their evaluation, TapScouts will capture screenshots of your app and answer up to 5 questions that you provide as part of their post-evaluation feedback.

People always say build something that solves your own problem, and this is exactly that. Hoping for some positive responses here and maybe we can take some market share from these BS scam install services.

Thanks for your interest.

I have an Android app in which I would like to implement "Backup app data to user's Google Drive" feature, so users can backup their data on their own Google Drive. This feature is pretty common and is available in many apps. Example, WhatsApp.

I checked the latest Google Drive API and tried to use it in a test app, but I am not able to find a trustable document to get an end-to-end idea of what is the right/recommended way to use it. I am not an expert Android developer though.

If anyone of you have implemented the feature or work with the Google Drive API. Can you please provide some guidance to implement it?

Many thanks.

In the code snippet below, I created a string resource which is annotated based on : https://developer.android.com/guide/topics/resources/string-resource#StylingWithAnnotations
In my Compose code, I get the annotated strings i.e (Terms of Service and Privacy Policy), color them differently and make the a clickable link.

However, this makes the whole text clickable for some reason. When I checked, the annotations get the right indices but the code doesn't work as expected.

I'm I doing something wrong or the framework has a bug?

https://reddit.com/link/1icy68n/video/1m63br4loyfe1/player

// String resource used bellow 

<string name="disclaimer_text">By continuing, you agree to our <annotation link="terms_of_service">Terms of Service</annotation> &amp; <annotation link="privacy_policy">Privacy Policy</annotation></string>




private fun Context.buildDisclaimerMessage(): AnnotatedString {
    val annotatedStringResource = getText(R.string.disclaimer_text) as SpannedString
    val annotations = annotatedStringResource.getSpans(
        0,
        annotatedStringResource.length,
        Annotation::class.java
    )

    return buildAnnotatedString {
        withStyle(style = SpanStyle(fontSize = 12.sp, color = ColorTokens.Grey.v100)) {
            append(annotatedStringResource.toString())

            annotations.forEach { annotation ->
                val start = annotatedStringResource.getSpanStart(annotation)
                val end = annotatedStringResource.getSpanEnd(annotation)

                addStyle(
                    style = SpanStyle(color = ColorTokens.Primary.v100),
                    start = start,
                    end = end
                )

                val url = when (annotation.value) {
                    "terms_of_service" -> LinkAnnotation.Url(...someurl)
                    "privacy_policy" -> LinkAnnotation.Url("...anotherUrl")
                    else -> LinkAnnotation.Url("")
                }

                addLink(url = url, start = start, end = end)
            }
        }
    }
}

So, here's the runtime screen-shot -

Problem-Image

If `val state` is "UiState.Idle" then how did it even get into the "UiState.Completed.Success" block ?

Just FYI, the UiState declaration -

Original-UiState

Tried some mix-and-match of the below,

Modified-UiState

Won't-work-1

Won't-work-2

Won't-work-3

Won't-work-4

Any solutions / work-around recommendations are welcome.

Thanks in advance.

I've been learning Compose for a couple weeks. It's still a little early for me to have an informed opinion of it but my experience so far has me wondering…

Is Compose the future of Android development, where Google and the Android community will invest 99% of its effort and Fragment-based development will become increasingly neglected? Or is Compose simply an alternative for those who prefer its style of development and both will be maintained well into the future? Presenters at events like I/O are always excited about Compose (of course) but has Google said anything "official" about it being the standard going forward, like they did with Kotlin over Java?

I've tried quite a few options, yet haven't found anything that works in all situations for me.

While seemingly simple, there are some common disruptions I run into -

• Running the app on an emulator vs a physical device (sometimes necessary when testing gesture related things)
• Using home wifi vs office wifi
• Having to wipe data on the emulator (clears some configurations)
• Running a dev server that requires authentication (sometimes you can turn this off, but often it might be part of what's being tested)

Using laptop local IP address on wifi as host name

This works for both physical and emulator devices. I've even setup my home wifi so that my laptop always gets assigned the same specific address. However, I've found some office wifi setups have firewall, or other configuration settings that stop my phone from connecting to the laptop this way.

Ngrock
I've used ngrock before as a proxy. I liked it because it works regardless of the network/device each emulator, server, phone, etc is on. I also liked that it happened to add some natural latency (which is nice when evaluation loading animations and such).

However, I always wanted to use ngrock with some kind of authentication since it's exposing my laptop to the open internet. Unfortunately, there was no way to rename the ngrock auth headers, so that they didn't overwrite the bearer auth used by my actual server. Once I renamed my app's auth-headers in debug builds instead, and used the ngrock feature to tack on a header to every request. That was annoying when testing multiple users interaction though.

Chrome Dev Tools

I've tried using chrome://inspect/#devices to setup port-forwarding on physical devices connected by usb. However, I've found it often fails/lags to actually detect connected devices.

Loopback

Using 10.0.2.2 works for the emulators running on my laptop, but not a physical device of course.

So - does anyone have a setup they're liking that works across physical devices & emulators in office wifi settings?

Hello everyone! 👋

I’m thrilled to share Why Not Compose!, one of my open-source showcase projects today. 🎉

https://i.redd.it/4kzi18p1isfe1.gif

What is “Why Not Compose!”?

It’s a collection of animations, compositions, and UIs built using Jetpack Compose—a sort of Compose cookbook, showcase, or playground. As an early adopter of Jetpack Compose, I’ve always enjoyed exploring its potential. While following official examples like the Now in Android open-source app, I found some implementations a bit complex. So, I was inspired to simplify and reimplement features in my way, storing finalized implementations in this repo.

The result? A repository that not only aids me in daily tasks but also allows me to quickly share implementations with my colleagues. I hope this resource can help you, too! 😊

Check it out

• 📂 GitHub: Why Not Compose!
• 📱 Google Play: Play Store Link (5k+ installs, 4.8 rating)

Notable Features

• MVVM Pattern
• Navigation Component
• Hilt
• Dark mode support
• Ready-to-use Compositions
• Material 3
• Gradle Kotlin DSL
• CI/CD
• ktlint, CodeQL
• Baseline profile generation
• Fastlane for Play Store publishing
• Animated Splash Screen (Introduced in Android 12)

App Sections

1. Animations: Explore animations built with Compose APIs.
2. Compositions: Ready-to-use Compose components—App bar, badge, list, dialogs, swipe-to-refresh, swipe-to-dismiss, etc.
3. UIs: Prebuilt UI screens—Map view, OTP verification, web view, pager, and more.
4. Tutorials: 15+ real-world examples of Compose solutions.

Screenshots

Some screenshots from the repository (Part 1)

Some screenshots from the repository (Part 2)

Tutorial Highlights

• Counter (Beginner): Simple counter implementation.
• Counter with ViewModel (Beginner): Counter with a ViewModel.
• AnimatedVisibility (Beginner): Animate UI using AnimatedVisibility.
• Lottie (Beginner): Explore Lottie animations.
• Select and Crop Image (Intermediate): Pick and crop images with uCrop.
• Capture and Crop Image (Intermediate): Capture images via the camera app and crop using uCrop.
• Permission Handling (Beginner): Handle runtime permissions in Compose.
• Data Fetch & Paging (Advanced): Use the Android Jetpack Paging library.
• Tic-Tac-Toe (Advanced): A simple game with basic AI.
• ExoPlayer (Advanced): Integrate ExoPlayer with Compose.
• CMS (Advanced): Example of a Content Management System using “Go REST” APIs.
• Memory and Storage Caching
• Deep Link (Intermediate): Handle deep links.
• Navigation Data Pass (Intermediate): Pass data with the Navigation component.
• Reactive Model (Beginner): Reactive MVVM example.
• Baseline Profiles (Intermediate): Check install status using ProfileVerifier.
• Barcode Scanner (Intermediate): Scan barcodes using Google Code Scanner and ML Kit.

How You Can Help

• Suggestions: I’d love your ideas for features or improvements.
• Contributions: Feel free to clone, fork, and contribute!

Please let me know what you think, and I hope you find this repository as useful as I do. 🚀

Happy coding! 🧑‍💻