DEV Community: Abdul Rehman

Login Screen: Get started with Avalonia UI in JetBrains Rider IDE C# dotnet MVVM

Abdul Rehman — Sat, 12 Jul 2025 16:05:29 +0000

Avalonia UI is Open Source alternative to Microsoft's WPF for building cross platform application in C#.Net. We are going to use dotnet sdk 9 in this tutorial and will help you get started with it and to build a basic Login Page Example in dotnet sdk 9 and JetBrain's Rider IDE which comes with free non comerial Licence. JetBrain's IDEs are no doubt one of the best IDEs and their ecosystem is very strong. But the real problem is pricing and most of the times when someone don't want to purchase the non comercial free linces is a great option from JetBrain.

Install DotNet SDK

The first step after installing the JetBrains IDE is to install the dotnet SDK. I would prefer to download and install the SDK by myself rather relaying on the IDE installation. After installation is done you should add the SDK path to the system veriable so that you be able to access the sdk via command line. If everything is setup you should be able to run the following command

dotnet --version

and it should return the SDK 9 version information. If you have multiple SDK versions installed, you can use following command to check list all the available SDKs in your system.

dotnet --list-sdks

Install Avalonia UI template

Now that we have dotnet sdk installed and it is available in our cmd terminal, we are good to install the Avalonia UI Template. For this you can simply run the following command.

dotnet new install Avalonia.Templates

This will install and create a project with this template if you are in a right directory but we will skip the project creation process and we will jump into the JetBrains's Rider IDE for this purpose.

Create New Avalonia UI Project

Open the JetBrain's Rider IDE and in new project creation window click on New Solution Button.

Now that you have Here on the left panel you will see the Avalonia UI Project Creation option. I will select the Avalonia MVVM App. You can also choose other options but for this tutorial we are going with the following settings

Don't forget to choose C# as your language instead of F#, and select the SDK 9 for the dotnet SDK. Now you are good to start coding. One more thing I forgot to mention, You should go with ReactiveUI when asked instead of Community UI.

Understanding the Folder Structure

Now that you are inside of your project you should see the folder structure. You can simply see your main.axaml file under the views directory. You should keep in mind that Avalonia UI uses it's own file structure which is axaml as mentioned in their official documentation.

Here you can see the App.axaml.cs file where the mainwindow is being initialized and started as a first window.

ViewModel for MainWindow

Now all you have to do is to move to your viewmodel directory and navigate to the file named MainWindowViewModel.cs. This file is your main View Model for your Main Window. You can change it to include the necessary variables and some initializations. Here is what my MainWindowViewModel.cs file looks like.

using ReactiveUI;
using System;
using System.Reactive;
using System.Diagnostics;
using Avalonia.Media;

namespace AvaloniaApplication2.ViewModels;

public class MainWindowViewModel : ViewModelBase
{
    private string _username;
    public string Username
    {
        get => _username;
        set => this.RaiseAndSetIfChanged(ref _username, value);
    }

    private string _password;
    public string Password
    {
        get => _password;
        set => this.RaiseAndSetIfChanged(ref _password, value);
    }

    private string _statusMessage;
    public string StatusMessage
    {
        get => _statusMessage;
        set => this.RaiseAndSetIfChanged(ref _statusMessage, value);
    }

    public ReactiveCommand<Unit, Unit> LoginCommand { get; }

    public MainWindowViewModel()
    {
        // Define the dummy login credentials
        const string DUMMY_USERNAME = "admin";
        const string DUMMY_PASSWORD = "password123";

        // Create the ReactiveCommand for the login action
        LoginCommand = ReactiveCommand.Create(() =>
        {
            // Clear previous status message
            StatusMessage = string.Empty;

            // Simple validation check
            if (string.IsNullOrWhiteSpace(Username) || string.IsNullOrWhiteSpace(Password))
            {
                StatusMessage = "Please enter both username and password.";
                Debug.WriteLine("Login failed: Empty credentials.");
                return;
            }

            // Dummy login logic
            if (Username.Equals(DUMMY_USERNAME, StringComparison.OrdinalIgnoreCase) && Password == DUMMY_PASSWORD)
            {
                StatusMessage = "Login successful!";
                Debug.WriteLine($"Login successful for user: {Username}");
                // You can add navigation or other logic here upon successful login
            }
            else
            {
                StatusMessage = "Invalid username or password.";
                Debug.WriteLine("Login failed: Invalid credentials.");
            }
        });
    }
}

Implements MVVM with ReactiveUI using ViewModelBase that inherits from ReactiveObject

Defines 3 bindable properties with RaiseAndSetIfChanged:

Username (string) – stores user input

Password (string) – stores password input

StatusMessage (string) – shows login status feedback

Exposes a ReactiveCommand named LoginCommand:

Created using ReactiveCommand.Create(...)

Executes login logic when invoked (bound to Login button)

Checks for empty Username or Password

Compares input against hardcoded values:

Username: admin

Password: password123

Updates StatusMessage based on result

Writes debug info using Debug.WriteLine(...)

Usage in XAML

Now it's time to use our ViewModel into our Main.axaml file for building our frontend UI. Here is main variables which we are going to use in our frontend.

Binds TextBox.Text to Username and Password
Binds Button.Command to LoginCommand
Displays StatusMessage to inform user of success or failure

No navigation yet, but placeholder comment added for future logic

Here is my complete Login Page UI code in XML


<reactiveUi:ReactiveWindow x:TypeArguments="viewModels:MainWindowViewModel"
                           xmlns="https://github.com/avaloniaui"
                           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                           xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                           xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                           xmlns:reactiveUi="clr-namespace:Avalonia.ReactiveUI;assembly=Avalonia.ReactiveUI"
                           xmlns:viewModels="clr-namespace:AvaloniaApplication2.ViewModels"
                           mc:Ignorable="d"
                           x:Class="AvaloniaApplication2.Views.MainWindow"
                           x:DataType="viewModels:MainWindowViewModel"
                           Title="Login"
                           Width="420"
                           Height="500"
                           CanResize="False"
                           WindowStartupLocation="CenterScreen"
                           Background="#121826"
                           RequestedThemeVariant="Dark"
                           >

    <Border CornerRadius="20"
            Padding="30"
            Width="360"
            Background="#1F2937CC"
            HorizontalAlignment="Center"
            VerticalAlignment="Center"
            BoxShadow="0 0 40 0 #00000080">

        <StackPanel Spacing="20">
            <TextBlock Text="Welcome Back"
                       FontSize="26"
                       Foreground="White"
                       FontWeight="SemiBold"
                       HorizontalAlignment="Center" />

            <TextBlock Text="Login to your account"
                       FontSize="14"
                       Foreground="#9CA3AF"
                       HorizontalAlignment="Center"
                       Margin="0,0,0,10"/>

            <StackPanel>
                <TextBlock Text="Username" Foreground="#9CA3AF" FontSize="12" Margin="0,0,0,5"/>
                <TextBox Text="{Binding Username, Mode=TwoWay}"
                         Background="#2C3444"
                         Foreground="White"
                         CornerRadius="8"
                         BorderBrush="Transparent"
                         Padding="8"/>
            </StackPanel>

            <StackPanel>
                <TextBlock Text="Password" Foreground="#9CA3AF" FontSize="12" Margin="0,10,0,5"/>
                <TextBox Text="{Binding Password, Mode=TwoWay}"
                         PasswordChar="●"
                         Background="#2C3444"
                         Foreground="White"
                         CornerRadius="8"
                         BorderBrush="Transparent"
                         Padding="8"/>
            </StackPanel>

            <TextBlock Text="{Binding StatusMessage}" 
                       Foreground="White" 
                       HorizontalAlignment="Center" 
                       Margin="0, -10, 0, 10" />

            <Button Content="Login"
                    Command="{Binding LoginCommand}"
                    Background="#4F46E5"
                    Foreground="White"
                    FontWeight="SemiBold"
                    CornerRadius="8"
                    Padding="12"
                    Width="100"
                    HorizontalAlignment="Center">
                <Button.Styles>
                    <Style Selector="Button:pointerover">
                        <Setter Property="Background" Value="#6366F1"/>
                    </Style>
                </Button.Styles>
            </Button>
            <TextBlock HorizontalAlignment="Center" Margin="0,10,0,0">
                <Run Text="Don't have an account? " Foreground="#9CA3AF"/>
                <Run Text="Register" Foreground="#4F46E5" TextDecorations="Underline" />
            </TextBlock>


        </StackPanel>
    </Border>
</reactiveUi:ReactiveWindow>

Login Backend

Here is simple Main.axaml.cs file for handling the frontend UI control for simulating a dummy login process based on our MainViewModel


using System;
using Avalonia.Input;
using Avalonia.ReactiveUI;
using AvaloniaApplication2.ViewModels;
using ReactiveUI;

namespace AvaloniaApplication2.Views;

public partial class MainWindow : ReactiveWindow<MainWindowViewModel>
{
    public MainWindow()
    {
        InitializeComponent();
        this.WhenActivated(disposables => { });
    }
    private void OnRegisterClicked(object? sender, PointerPressedEventArgs e)
    {
        Console.WriteLine("Register clicked"); // replace with navigation
    }

}

Mostly everything is handled in the viewmodel and nothing much required here. Only the Navigation to Registration page is left which we would do in some upcoming tutorials. This is how our final UI looks like

How to Properly Setup Hilt in Android Jetpack Compose Project in 2025

Abdul Rehman — Thu, 12 Jun 2025 14:16:55 +0000

Direct Answer

Key Points:

Research suggests Hilt 2.56 is the latest version, using KSP instead of KAPT for faster annotation processing.
It seems likely that you need to update Gradle files to use ksp for Hilt and AndroidX Hilt dependencies.
The evidence leans toward including both core Hilt (2.56) and AndroidX Hilt (1.2.0) compilers with KSP for full compatibility.

Project-Level build.gradle.kts Update:

Add plugins for Hilt and KSP with versions:

  plugins {
      id("com.android.application") version "8.5.2" apply false
      id("org.jetbrains.kotlin.android") version "2.0.20" apply false
      id("com.google.dagger.hilt.android") version "2.56" apply false
      id("com.google.devtools.ksp") version "1.9.24-1.0.20" apply false
  }

App-Level build.gradle.kts Update:

Apply plugins and update dependencies:

  plugins {
      id("com.android.application")
      id("org.jetbrains.kotlin.android")
      id("com.google.dagger.hilt.android")
      id("com.google.devtools.ksp")
  }

  dependencies {
      val hiltVersion = "2.56"
      implementation("com.google.dagger:hilt-android:$hiltVersion")
      ksp("com.google.dagger:hilt-compiler:$hiltVersion")

      val androidxHiltVersion = "1.2.0"
      implementation("androidx.hilt:hilt-work:$androidxHiltVersion")
      ksp("androidx.hilt:hilt-compiler:$androidxHiltVersion")
  }

Replace kapt with ksp for all Hilt-related annotation processing.

Notes:

Ensure your Kotlin and Android Gradle Plugin versions are compatible with KSP 1.9.24-1.0.20.
If using AndroidX Hilt extensions, include both compilers to avoid issues.

Survey Note: Detailed Analysis of Hilt with KSP in 2025

This section provides a comprehensive overview of transitioning Hilt to use KSP instead of KAPT, based on the latest available information as of June 12, 2025. It covers the evolution of Hilt, the shift to KSP, and practical implementation details for Android projects.

Background on Hilt and Dependency Injection

Hilt, built on Dagger, is a dependency injection library recommended for Android apps, simplifying the setup and management of dependencies. It reduces boilerplate code by generating Dagger components automatically. Traditionally, Hilt used KAPT for annotation processing, but with Kotlin's advancements, KSP has emerged as a faster, more efficient alternative.

Transition to KSP: Why and How

KSP (Kotlin Symbol Processing) is designed to leverage Kotlin's compiler infrastructure, offering up to twice the speed of KAPT. This transition is part of Kotlin's push for better performance, especially for annotation-heavy libraries like Hilt. Research suggests that Hilt, starting from version 2.48, supports KSP, with the latest version identified as 2.56 in recent Dagger releases (Releases · google/dagger). For AndroidX Hilt extensions, the latest stable version is 1.2.0, supporting KSP as introduced in version 1.1.0-alpha01 (Hilt | Jetpack | Android Developers).

The shift to KSP requires updating Gradle configurations, replacing kapt with ksp for annotation processing. This change is crucial for projects aiming to reduce build times and improve development efficiency.

Implementation Details

To integrate Hilt with KSP, updates are needed in both project-level and app-level build.gradle.kts files. Below is a detailed breakdown:

Project-Level build.gradle.kts: This file defines the plugins and their versions for the entire project. For Hilt 2.56 and KSP, the configuration is:

  plugins {
      id("com.android.application") version "8.5.2" apply false
      id("org.jetbrains.kotlin.android") version "2.0.20" apply false
      id("com.google.dagger.hilt.android") version "2.56" apply false
      id("com.google.devtools.ksp") version "1.9.24-1.0.20" apply false
  }

The versions (e.g., 8.5.2 for Android Gradle Plugin, 2.0.20 for Kotlin) should align with your project's setup, but these are based on recent documentation for compatibility with Hilt 2.56 and KSP 1.9.24-1.0.20, as noted in Dagger's release notes.

App-Level build.gradle.kts: Here, you apply the plugins and define dependencies. The updated configuration is:

  plugins {
      id("com.android.application")
      id("org.jetbrains.kotlin.android")
      id("com.google.dagger.hilt.android")
      id("com.google.devtools.ksp")
  }

  android {
      // Your existing Android configuration
  }

  dependencies {
      val hiltVersion = "2.56"
      implementation("com.google.dagger:hilt-android:$hiltVersion")
      ksp("com.google.dagger:hilt-compiler:$hiltVersion")

      val androidxHiltVersion = "1.2.0"
      implementation("androidx.hilt:hilt-work:$androidxHiltVersion")
      ksp("androidx.hilt:hilt-compiler:$androidxHiltVersion")
  }

This setup ensures that both core Hilt and AndroidX Hilt extensions are processed with KSP. The ksp configuration replaces kapt, aligning with Hilt's support for KSP as detailed in Dagger's documentation (Dagger KSP).

Compatibility and Considerations

Version Compatibility: Hilt 2.56 requires KSP 1.9.24-1.0.20 or higher, as specified in Dagger's release notes. Ensure your Kotlin version (e.g., 2.0.20) and Android Gradle Plugin version (e.g., 8.5.2) are compatible with these requirements.
AndroidX Hilt Extensions: If using extensions like hilt-work, include androidx.hilt:hilt-compiler with KSP, as recommended for versions 1.1.0 and above. This ensures all annotations are processed correctly, avoiding potential conflicts with Javac/KAPT processors, as noted in Dagger's KSP documentation.
Build Performance: KSP can reduce build times significantly, especially for large projects, making it a worthwhile upgrade from KAPT.

Table: Hilt and KSP Version Compatibility

Component	Version	Notes
Hilt (core)	2.56	Latest as of Dagger 2.56 release
KSP	1.9.24-1.0.20	Minimum required for Hilt 2.56
AndroidX Hilt (e.g., hilt-work)	1.2.0	Latest stable, supports KSP since 1.1.0
Kotlin	2.0.20	Compatible with KSP 1.9.24-1.0.20
Android Gradle Plugin	8.5.2	Ensure compatibility with Kotlin and KSP

Practical Example

For a project using Hilt with KSP, the migration involves replacing all kapt lines with ksp. For instance, if you had:

dependencies {
    implementation("com.google.dagger:hilt-android:2.48")
    kapt("com.google.dagger:hilt-compiler:2.48")
}

Update to:

dependencies {
    implementation("com.google.dagger:hilt-android:2.56")
    ksp("com.google.dagger:hilt-compiler:2.56")
}

And if using AndroidX Hilt, add:

implementation("androidx.hilt:hilt-work:1.2.0")
ksp("androidx.hilt:hilt-compiler:1.2.0")

Conclusion

The transition to Hilt with KSP is straightforward, requiring updates to Gradle plugins and dependencies. By using Hilt 2.56 and AndroidX Hilt 1.2.0 with KSP, you leverage faster annotation processing, enhancing build performance. Ensure compatibility with your project's Kotlin and Android Gradle Plugin versions, and test thoroughly to confirm all Hilt annotations are processed correctly.

Key Citations

MVVM vs Other Architectures

Abdul Rehman — Sun, 08 Jun 2025 18:32:57 +0000

Kotlin and Jetpack Compose favor MVVM (Model-View-ViewModel) because it offers better separation of concerns, making UI more reactive and business logic more manageable. Here's why MVVM is preferred over older patterns:

🔍 Comparison of MVVM vs. Other Architectures

Architecture	UI Logic	Business Logic	Testability	Code Separation	Lifecycle Handling
MVC (Model-View-Controller)	Controller tightly coupled to View	Business logic mixed with UI	Harder due to View-Controller coupling	Weak separation	Controller struggles with lifecycle
MVP (Model-View-Presenter)	Presenter decouples View from logic	Business logic in Presenter	Better, but Presenter can get bloated	Decent separation	Presenter still manually handles lifecycle
Viper	Clear responsibility via different layers	Strong business logic separation	Excellent	Overly complex for many apps	Good lifecycle separation
MVVM (Model-View-ViewModel)	ViewModel mediates between View and Model	UI state stored properly	Best due to ViewModel unit testing	Best separation with ViewModel handling UI state	ViewModel survives configuration changes

🔥 Why Kotlin & Jetpack Compose Prefer MVVM

✅ ViewModel survives lifecycle changes (screen rotations).

✅ Cleaner state management with StateFlow, LiveData, or MutableState.

✅ Encourages reactive UI updates (Jetpack Compose benefits greatly).

✅ Works smoothly with Coroutines & Flows for async tasks.

✅ Minimizes UI logic in Views, leading to scalable and maintainable apps.

MVP and MVC struggle with tight coupling, making state harder to manage, while MVVM ensures separation and flexibility—making it ideal for Jetpack Compose in Kotlin. 🚀

Easiest Way to Fetch REST API data using Retrofit in Android Jetpack Compose

Abdul Rehman — Sun, 08 Jun 2025 12:27:29 +0000

Let's set up Retrofit, Gson, and Kotlinx Coroutines to fetch a random quote from ZenQuotes API and display it dynamically in Jetpack Compose.

🔍 1️⃣ Add Dependencies (Retrofit, Gson, Coroutines)

Add these dependencies in your build.gradle.kts (Module-level):

dependencies {
    implementation("com.squareup.retrofit2:retrofit:2.9.0")
    implementation("com.squareup.retrofit2:converter-gson:2.9.0") // Convert JSON to Kotlin objects
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4") // Coroutines
    implementation("com.squareup.okhttp3:logging-interceptor:4.9.3") // Debugging HTTP calls
}

🏗 2️⃣ Create the Retrofit API Interface

ZenQuotes API provides random quotes in JSON format. Define the API interface:

import retrofit2.http.GET
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.Call

// Step 1: Define Data Model
data class QuoteResponse(val q: String, val a: String) // q = quote, a = author

// Step 2: Define API Interface
interface QuoteApiService {
    @GET("api/random") // Endpoint for random quote
    fun getRandomQuote(): Call<List<QuoteResponse>> // ZenQuotes returns a List
}

// Step 3: Create Retrofit Instance
object RetrofitInstance {
    private const val BASE_URL = "https://zenquotes.io/"

    val apiService: QuoteApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create()) // Convert JSON
            .build()
            .create(QuoteApiService::class.java)
    }
}

🚀 3️⃣ Fetch Quote Using Coroutines

Since Retrofit's default method (Call) is synchronous, let's use Coroutines for async operations.

Create a Repository for API Calls:

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class QuoteRepository {
    suspend fun fetchRandomQuote(): QuoteResponse? {
        return withContext(Dispatchers.IO) {
            try {
                val response = RetrofitInstance.apiService.getRandomQuote().execute()
                if (response.isSuccessful) response.body()?.get(0) else null // ZenQuotes returns a List
            } catch (e: Exception) {
                null // Handle errors
            }
        }
    }
}

🌐 4️⃣ Display Quote in Jetpack Compose

Modify your QuoteScreen to display fetched quote dynamically.

import androidx.lifecycle.viewModelScope
import androidx.lifecycle.ViewModel
import kotlinx.coroutines.launch

class QuoteViewModel : ViewModel() {
    private val repository = QuoteRepository()
    var quoteText by mutableStateOf("Tap button for a quote")
    var authorText by mutableStateOf("")

    fun getNewQuote() {
        viewModelScope.launch {
            val quote = repository.fetchRandomQuote()
            if (quote != null) {
                quoteText = "\"${quote.q}\""
                authorText = "- ${quote.a}"
            }
        }
    }
}

🎨 5️⃣ Connect ViewModel to Your UI (`QuoteScreen`)

Now, update your Composable to use QuoteViewModel.

@Composable
fun QuoteScreen(viewModel: QuoteViewModel = QuoteViewModel()) {
    Column(
        modifier = Modifier.fillMaxSize().padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Text(text = viewModel.quoteText, modifier = Modifier.padding(8.dp))
        Text(text = viewModel.authorText, modifier = Modifier.padding(8.dp))
        Button(onClick = { viewModel.getNewQuote() }) {
            Text("Get Quote")
        }
    }
}

🚀 Final Steps

Run the app and click the button to fetch a random quote.
ViewModel ensures state survival across recompositions.
Coroutines make the API call efficient without blocking UI.

Now you have a fully functional random quote generator integrated into Jetpack Compose! 🚀🔥

Android Kotlin Reading Data from HC-05 Bluetooth module

Abdul Rehman — Wed, 04 Jun 2025 14:33:28 +0000

Here is the first working code

package com.myfyp.posture
import android.content.Intent
import android.Manifest
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothManager
import android.bluetooth.BluetoothSocket
import android.content.Context
import android.content.pm.PackageManager
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import com.myfyp.posture.ui.theme.PostureDetectionBTTheme
import com.myfyp.posture.ui.navigation.AppNavigation
import java.util.UUID

import androidx.compose.runtime.*
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.io.IOException


// This is the standard Serial Port Profile (SPP) UUID
private val SPP_UUID: UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")
private const val TAG = "HC05_Reader"

class MainActivity : ComponentActivity() {
    private val requestBluetoothEnable = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
        if (result.resultCode == RESULT_OK) {
            Toast.makeText(this, "Bluetooth enabled!", Toast.LENGTH_SHORT).show()
        } else {
            Toast.makeText(this, "Bluetooth not enabled.", Toast.LENGTH_SHORT).show()
        }
    }

    private val requestPermissionsLauncher = registerForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { permissions ->
        var allGranted = true
        permissions.entries.forEach {
            if (!it.value) {
                allGranted = false
                Toast.makeText(this, "${it.key} not granted.", Toast.LENGTH_SHORT).show()
            }
        }
        if (allGranted) {
            Toast.makeText(this, "All Bluetooth permissions granted!", Toast.LENGTH_SHORT).show()
            // You can now proceed with Bluetooth operations
        } else {
            Toast.makeText(this, "Bluetooth permissions are required.", Toast.LENGTH_LONG).show()
        }
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
                    BluetoothReaderScreen(
                        requestBluetoothEnable = { intent -> requestBluetoothEnable.launch(intent) },
                        requestPermissions = { permissions -> requestPermissionsLauncher.launch(permissions) }
                    )
                }
            }
        }
        checkPermissions()
    }
    private fun checkPermissions() {
        val permissionsToRequest = mutableListOf<String>()

        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
            if (checkSelfPermission(Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
                permissionsToRequest.add(Manifest.permission.BLUETOOTH_SCAN)
            }
            if (checkSelfPermission(Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
                permissionsToRequest.add(Manifest.permission.BLUETOOTH_CONNECT)
            }
        } else { // Android 11 and lower
            if (checkSelfPermission(Manifest.permission.BLUETOOTH) != PackageManager.PERMISSION_GRANTED) {
                permissionsToRequest.add(Manifest.permission.BLUETOOTH)
            }
            if (checkSelfPermission(Manifest.permission.BLUETOOTH_ADMIN) != PackageManager.PERMISSION_GRANTED) {
                permissionsToRequest.add(Manifest.permission.BLUETOOTH_ADMIN)
            }
            if (checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                permissionsToRequest.add(Manifest.permission.ACCESS_FINE_LOCATION)
            }
        }

        if (permissionsToRequest.isNotEmpty()) {
            requestPermissionsLauncher.launch(permissionsToRequest.toTypedArray())
        }
    }

//    override fun onCreate(savedInstanceState: Bundle?) {
//        super.onCreate(savedInstanceState)
//        setContent {
//            PostureDetectionBTTheme {
//                Surface(
//                    modifier = Modifier.fillMaxSize(),
//                    color = MaterialTheme.colorScheme.background
//                ) {
//                    AppNavigation()
//                }
//            }
//        }
//    }
}


@Composable
fun BluetoothReaderScreen(
    requestBluetoothEnable: (Intent) -> Unit,
    requestPermissions: (Array<String>) -> Unit
) {
    val context = LocalContext.current
    val bluetoothManager: BluetoothManager? = remember { context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager }
    val bluetoothAdapter: BluetoothAdapter? = remember(bluetoothManager) { bluetoothManager?.adapter }

    var connectionStatus by remember { mutableStateOf("Disconnected") }
    var receivedData by remember { mutableStateOf("No data yet") }
    var hc05Device: BluetoothDevice? by remember { mutableStateOf(null) }
    var bluetoothSocket: BluetoothSocket? by remember { mutableStateOf(null) }

    val coroutineScope = rememberCoroutineScope()

    DisposableEffect(Unit) {
        onDispose {
            // Ensure socket is closed when the composable leaves the screen
            try {
                bluetoothSocket?.close()
                Log.d(TAG, "Bluetooth socket closed on dispose.")
            } catch (e: IOException) {
                Log.e(TAG, "Error closing socket: ${e.message}")
            }
        }
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp)
    ) {
        Text(text = "Connection Status: $connectionStatus")
        Spacer(modifier = Modifier.height(8.dp))
        Text(text = "Received Data: $receivedData")
        Spacer(modifier = Modifier.height(16.dp))

        Button(
            onClick = {
                // Request permissions if not granted
                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
                    requestPermissions(arrayOf(Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT))
                } else {
                    requestPermissions(arrayOf(Manifest.permission.BLUETOOTH, Manifest.permission.BLUETOOTH_ADMIN, Manifest.permission.ACCESS_FINE_LOCATION))
                }

                if (bluetoothAdapter == null) {
                    Toast.makeText(context, "Bluetooth not supported on this device.", Toast.LENGTH_LONG).show()
                    return@Button
                }

                if (!bluetoothAdapter.isEnabled) {
                    val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
                    requestBluetoothEnable(enableBtIntent)
                }
            }
        ) {
            Text("Check Bluetooth & Permissions")
        }

        Spacer(modifier = Modifier.height(8.dp))

        Button(
            onClick = {
                if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled) {
                    Toast.makeText(context, "Bluetooth is not enabled or supported.", Toast.LENGTH_SHORT).show()
                    return@Button
                }

                // IMPORTANT: Replace "HC-05" with the actual name of your HC-05 module
                // or use its MAC address if you know it (e.g., "00:11:22:33:AA:BB")
                val deviceNameOrAddress = "xx:xx:xx:xx:xx:xx" // Or "XX:XX:XX:XX:XX:XX"

                val pairedDevices: Set<BluetoothDevice> = if (
                    context.checkSelfPermission(Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED
                ) {
                    bluetoothAdapter.bondedDevices
                } else {
                    Toast.makeText(context, "BLUETOOTH_CONNECT permission not granted.", Toast.LENGTH_SHORT).show()
                    emptySet()
                }


                hc05Device = pairedDevices.find {
                    if (context.checkSelfPermission(Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED) {
                        it.name == deviceNameOrAddress || it.address == deviceNameOrAddress
                    } else {
                        false
                    }
                }

                if (hc05Device == null) {
                    Toast.makeText(context, "$deviceNameOrAddress not found in paired devices. Pair it first!", Toast.LENGTH_LONG).show()
                    connectionStatus = "Device not paired"
                    return@Button
                }

                coroutineScope.launch(Dispatchers.IO) {
                    try {
                        withContext(Dispatchers.Main) { connectionStatus = "Connecting..." }

                        if (context.checkSelfPermission(Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
                            withContext(Dispatchers.Main) {
                                Toast.makeText(context, "BLUETOOTH_CONNECT permission not granted.", Toast.LENGTH_SHORT).show()
                            }
                            return@launch
                        }

                        bluetoothSocket = hc05Device?.createRfcommSocketToServiceRecord(SPP_UUID)
                        bluetoothSocket?.connect()

                        withContext(Dispatchers.Main) {
                            connectionStatus = "Connected to ${hc05Device?.name}"
                            Toast.makeText(context, "Connected to HC-05!", Toast.LENGTH_SHORT).show()
                        }

                        // Start reading data
                        val inputStream = bluetoothSocket?.inputStream
                        val buffer = ByteArray(1024)
                        var bytes: Int

                        while (bluetoothSocket?.isConnected == true) {
                            try {
                                bytes = inputStream?.read(buffer) ?: -1
                                if (bytes > 0) {
                                    val readMessage = String(buffer, 0, bytes)
                                    withContext(Dispatchers.Main) {
                                        receivedData = readMessage
                                        Log.d(TAG, "Received: $readMessage")
                                    }
                                }
                            } catch (e: IOException) {
                                withContext(Dispatchers.Main) {
                                    connectionStatus = "Connection lost: ${e.message}"
                                    Toast.makeText(context, "Connection lost: ${e.message}", Toast.LENGTH_LONG).show()
                                }
                                Log.e(TAG, "Error reading from socket: ${e.message}")
                                break // Exit loop on error
                            }
                        }
                    } catch (e: IOException) {
                        withContext(Dispatchers.Main) {
                            connectionStatus = "Connection Failed: ${e.message}"
                            Toast.makeText(context, "Connection failed: ${e.message}", Toast.LENGTH_LONG).show()
                        }
                        Log.e(TAG, "Socket connection failed: ${e.message}")
                        try { bluetoothSocket?.close() } catch (e: IOException) { Log.e(TAG, "Error closing socket after fail: ${e.message}") }
                    }
                }
            }
        ) {
            Text("Connect & Read from HC-05")
        }

        Spacer(modifier = Modifier.height(8.dp))

        Button(
            onClick = {
                coroutineScope.launch(Dispatchers.IO) {
                    try {
                        bluetoothSocket?.close()
                        withContext(Dispatchers.Main) {
                            connectionStatus = "Disconnected"
                            Toast.makeText(context, "Disconnected.", Toast.LENGTH_SHORT).show()
                        }
                    } catch (e: IOException) {
                        withContext(Dispatchers.Main) {
                            Toast.makeText(context, "Error disconnecting: ${e.message}", Toast.LENGTH_SHORT).show()
                        }
                        Log.e(TAG, "Error closing socket: ${e.message}")
                    }
                }
            },
            enabled = bluetoothSocket?.isConnected == true // Enable only when connected
        ) {
            Text("Disconnect")
        }
    }
}

Firebase UI for Authentication Android Kotlin

Abdul Rehman — Sat, 24 May 2025 11:14:29 +0000

Here I will present you the way to use the Firebase UI for Firebase Authentication. Obviously you first have to create an android studio based Android Kotlin Project. Also, you have to create a firebase project. Go to the Tools menu in your Android Studio and then goto the firebase. It will openup a new sidebar menu where it will guide you to do the authentications.

Here you need to click

Now click on Connect to Firebase button

Here you need to create a new firebase project or choose any existing project which you want to use.

Now you need to click on Connect button

Now your project is connected you can safely close this window.

Now, when you come back to your android studio, you will see this connected sign in the right sidebar.

Enable Authentication in Firebase Console

Now it's time to enable the authentications in your firebase console project. For this, goto the Firebase Console and select your project and open it. Now click Authentication from the Build menu like shown in image below

Now click on Get started

This will open Authentication Providers list. From here, select, anonymous, email, and Google Authenticators.

To use the Google Authenticator, you have to do one more step, for which you have to go back to your android studio project and have to select your SHA Key.

Open the Project Settings, and add SHA-1 by scrolling down and clicking the button which says to add the SHA keys.

To find the SHA-1 key for your Android project in Android Studio using Gradle, you can use the following command in the terminal. This SHA-1 key is necessary for configuring your Firebase project settings.

Open Android Studio and navigate to your project.
Open the Terminal window in Android Studio. You can do this by going to View > Tool Windows > Terminal.
In the Terminal, navigate to the app directory of your project if you are not already there. You can use the cd command to change directories. For example:

   cd /path/to/your/project/app

Run the following Gradle command to generate the signing report, which includes the SHA-1 key:

   ./gradlew signingReport

Note: If you are on Windows, you might need to use gradlew.bat instead of ./gradlew:

   gradlew.bat signingReport

After running the command, you will see output in the Terminal that includes the SHA-1 key. Look for a section that resembles the following:

   Variant: debug
   Config: debug
   Store: /path/to/your/debug.keystore
   Alias: AndroidDebugKey
   MD5: XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX
   SHA1: XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX
   SHA-256: XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX
   Valid until: Monday, January 1, 2030

Copy the SHA-1 key from the output and use it in your Firebase project settings.

This command generates a signing report for all build variants, including the debug and release variants. Make sure to use the correct SHA-1 key for the variant you are configuring (e.g., debug for development, release for production).

Now you can see that the all three of Auth providers are enabled just like shown in the following picture.

Add Firebase SDK into your Android Studio Kotlin Project

Now you need to come back to your android studio project and you can either click on the "Add the Firebase Authentication SDK to your app" Button.

To add the Firebase Bill of Materials (BOM) to your Android Studio project using a build.gradle.kts (Kotlin DSL) file, you need to follow these steps:

Open your build.gradle.kts file: This file is typically located in the app directory of your project.
Add the Firebase BOM dependency: The Firebase BOM helps you manage the versions of Firebase libraries. You can add it to the dependencies block of your build.gradle.kts file.
Add the specific Firebase libraries you need: Use the implementation function to add the specific Firebase libraries you want to use.

Here is an example of how to do this:

plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
}

android {
    compileSdk = 33

    defaultConfig {
        applicationId = "com.example.yourapp"
        minSdk = 21
        targetSdk = 33
        versionCode = 1
        versionName = "1.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        getByName("release") {
            isMinifyEnabled = false
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
        }
    }
}

dependencies {
    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.8.0")
    implementation("androidx.core:core-ktx:1.8.0")
    implementation("androidx.appcompat:appcompat:1.5.1")
    implementation("com.google.android.material:material:1.6.1")
    implementation("androidx.constraintlayout:constraintlayout:2.1.4")

    // Add the Firebase BOM
    implementation(platform("com.google.firebase:firebase-bom:31.1.1"))

    // Add specific Firebase libraries
    implementation("com.google.firebase:firebase-analytics-ktx")
    implementation("com.google.firebase:firebase-auth-ktx")
    implementation("com.google.firebase:firebase-firestore-ktx")
    // Add other Firebase libraries as needed
}

Explanation:

Firebase BOM: The line implementation(platform("com.google.firebase:firebase-bom:31.1.1")) adds the Firebase BOM to your project. This helps manage the versions of Firebase libraries.
Specific Firebase Libraries: The lines implementation("com.google.firebase:firebase-analytics-ktx"), implementation("com.google.firebase:firebase-auth-ktx"), and implementation("com.google.firebase:firebase-firestore-ktx") add specific Firebase libraries to your project. You can add more libraries as needed.

Additional Steps:

Sync Your Project: After adding the dependencies, click on the "Sync Now" link that appears at the top of the build.gradle.kts file or go to File > Sync Project with Gradle Files.
Add Firebase Configuration: Make sure you have added the google-services.json file to your project. This file is downloaded from the Firebase console and should be placed in the app directory.

By following these steps, you will have successfully added the Firebase BOM and the necessary Firebase libraries to your Android Studio project using the build.gradle.kts file.

Add AuthActivity to handle Authentication

Using Firebase Authentication UI is a straightforward way to implement authentication in your Android application. Firebase Authentication UI provides a pre-built UI for common authentication flows, such as email/password, phone authentication, and social providers like Google, Facebook, and Twitter.

Based on the official FirebaseUI documentation, here are the easy-to-follow steps to integrate FirebaseUI for authentication in your Android project:

Add the Google Services Plugin :

In your project-level build.gradle file, add the Google services classpath:

  // Top-level build file where you can add configuration options common to all sub-projects/modules.
plugins {
alias(libs.plugins.android.application) apply false
alias(libs.plugins.kotlin.android) apply false
id("com.google.gms.google-services") version "4.4.2" apply false
}

In your app-level build.gradle file, apply the Google services plugin:

  plugins {
alias(libs.plugins.android.application)
alias(libs.plugins.kotlin.android)
id("com.google.gms.google-services")
}

Add FirebaseUI Dependencies

Add the necessary dependencies to your build.gradle.kts file:

dependencies {
    // Add the Firebase BOM
    implementation(platform("com.google.firebase:firebase-bom:31.1.1"))

    // Add Firebase Authentication
    implementation("com.google.firebase:firebase-auth-ktx")

    // Add FirebaseUI Auth
    implementation("com.firebaseui:firebase-ui-auth:9.0.0")

    // Required only if Facebook login support is required
    // Find the latest Facebook SDK releases here: https://goo.gl/Ce5L94
    implementation("com.facebook.android:facebook-android-sdk:8.x")
}

Enable Sign-In Methods in Firebase Console

Open the Firebase Console:
- Go to the Firebase Console.
- Select your project.
Enable Sign-In Methods:
- In the Firebase Console, go to the Authentication section.
- Enable the sign-in methods you want to support (e.g., Email/Password, Google, Facebook, etc.).
Configure Google Sign-In:
- If you enabled Google Sign-In, download the updated google-services.json file and replace the existing one in your project.
- Specify your app's SHA fingerprint in the Firebase Console.

Configure Facebook and Twitter:

If you enabled Facebook or Twitter sign-in, add the necessary string resources to your strings.xml file:

 <resources>
     <!-- Facebook application ID and custom URL scheme (app ID prefixed by 'fb'). -->
     <string name="facebook_application_id" translatable="false">YOUR_APP_ID</string>
     <string name="facebook_login_protocol_scheme" translatable="false">fbYOUR_APP_ID</string>
 </resources>

Create an Activity for Sign-In

Create a new activity (e.g., AuthActivity) to handle the FirebaseUI sign-in flow.

package com.any.of.your.package

import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.firebase.ui.auth.AuthUI
import com.firebase.ui.auth.FirebaseAuthUIActivityResultContract
import com.firebase.ui.auth.data.model.FirebaseAuthUIAuthenticationResult
import com.google.firebase.FirebaseApp
import com.google.firebase.auth.FirebaseAuth

class AuthActivity : AppCompatActivity() {
    private lateinit var auth: FirebaseAuth
    // Choose authentication providers
    val providers = arrayListOf(
        AuthUI.IdpConfig.EmailBuilder().build(),
        // AuthUI.IdpConfig.PhoneBuilder().build(),
        AuthUI.IdpConfig.GoogleBuilder().build(),
        // AuthUI.IdpConfig.FacebookBuilder().build(),
        // AuthUI.IdpConfig.TwitterBuilder().build(),
    )


    private val signInLauncher = registerForActivityResult(
        FirebaseAuthUIActivityResultContract(),
    ) { res ->
        onSignInResult(res)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContentView(R.layout.activity_auth)
        auth = FirebaseAuth.getInstance()
        // See: https://developer.android.com/training/basics/intents/result
        val signInLauncher = registerForActivityResult(
            FirebaseAuthUIActivityResultContract(),
        ) { res ->
            this.onSignInResult(res)
        }
        val btnLogin = findViewById<Button>(R.id.btnAuth)
        btnLogin.setOnClickListener {


            // Create and launch sign-in intent
            val signInIntent = AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .setLogo(R.drawable.ic_launcher_foreground) // Set logo drawable
                .setTheme(R.style.Base_Theme_LiveVitalsMonitoring) // Set theme
                .build()
            signInLauncher.launch(signInIntent)
          }

    }

    private fun onSignInResult(result: FirebaseAuthUIAuthenticationResult) {
        val response = result.idpResponse
        if (result.resultCode == RESULT_OK) {
            // Successfully signed in
            val user = FirebaseAuth.getInstance().currentUser
            // Go to the main activity or perform other actions
            startActivity(Intent(this, MainActivity::class.java))
            finish()
        } else {
            // Sign in failed. If response is null the user canceled the
            // sign-in flow using the back button. Otherwise check
            // response.getError().getErrorCode() and handle the error.
            if (response == null) {
                // User pressed back button
                finish()
            } else {
                // Handle error
                // response.getError().getErrorCode()
                if (response == null) {
                    Log.w("SignInActivity", "Sign-in cancelled by user")
                    Toast.makeText(this, "Sign-in cancelled", Toast.LENGTH_SHORT).show()
                } else {
                    Log.e("SignInActivity", "Sign-in error: ${response.error?.localizedMessage}", response.error)
                    Toast.makeText(this, "Sign-in failed: ${response.error?.localizedMessage}", Toast.LENGTH_LONG).show()
                }
            }
        }
    }
}

Google Services Runtime Error

This error, "Check your google-services plugin configuration, the default_web_client_id string wasn't populated," indicates an issue with your Firebase project setup and how your Android application is configured to use Google Sign-In.

Here's a breakdown of what's happening and how to fix it:

The Problem

When you use FirebaseUI-Auth for Google Sign-In, it expects a default_web_client_id to be present in your google-services.json file. This client ID is crucial for the secure communication between your Android app and Google's authentication servers.

The error message means:

google-services.json is missing or incorrect: You might not have the google-services.json file in your Android app's app/ directory, or the file you have is outdated/incomplete.
Missing default_web_client_id: Even if google-services.json is present, it might not contain the oauth_client entry with client_type of 3 (which corresponds to the web client ID) that FirebaseUI needs for Google Sign-In.

Solutions

1. Download and Replace `google-services.json`

This is the most common solution. You need to ensure your Android project has the correct and up-to-date configuration file from your Firebase project.

Go to your Firebase Project: Open your Firebase console (console.firebase.google.com) and navigate to your project.
Project settings: Click on the gear icon (Project settings) next to "Project Overview."
Your apps: In the "Your apps" section, select your Android app.
Download google-services.json: Click the "Download google-services.json" button.
Replace the existing file: Copy the newly downloaded google-services.json file into your Android project's app/ directory (e.g., your_project/app/google-services.json). Overwrite any existing file.
Clean and Rebuild:
- In Android Studio, go to Build > Clean Project.
- Then, go to Build > Rebuild Project.
- Run your app again.

2. Verify Google Sign-In is Enabled

Ensure that Google Sign-In is enabled for your Firebase project.

Firebase Console: In your Firebase project, go to Authentication in the left-hand menu.
Sign-in method: Click on the "Sign-in method" tab.
Enable Google: Make sure Google is enabled. If not, enable it and save the changes. This step will also ensure that the necessary OAuth client IDs are generated in your Firebase project, which are then included in your google-services.json file.

3. Check `build.gradle` (Project Level)

Ensure you have the Google services plugin applied at the project level.

In your project-level build.gradle file (e.g., your_project/build.gradle), make sure you have:

buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        // ...
        classpath 'com.google.gms:google-services:4.4.1' // Or the latest version
    }
}

allprojects {
    repositories {
        google()
        mavenCentral()
    }
}

4. Check `build.gradle` (App Level)

Ensure you have the Google services plugin applied and Firebase Bill of Materials (BOM) for dependency management at the app level.

In your app-level build.gradle file (e.g., your_project/app/build.gradle), ensure these lines are present:

plugins {
    id 'com.android.application'
    id 'com.google.gms.google-services' // Apply this plugin
    id 'org.jetbrains.kotlin.android' // If using Kotlin
}

android {
    // ...
}

dependencies {
    // Import the Firebase BoM
    implementation(platform("com.google.firebase:firebase-bom:32.8.1")) // Or the latest version
    // When using the BoM, you don't specify versions in Firebase library dependencies

    // Declare the dependency for the Firebase Authentication library
    // and other Firebase products you want to use
    implementation 'com.google.firebase:firebase-auth-ktx'
    implementation 'com.firebaseui:firebase-ui-auth:8.0.2' // Or the latest version for FirebaseUI-Auth

    // ... other dependencies
}

Crucially, make sure id 'com.google.gms.google-services' is applied at the very bottom of your app/build.gradle file, after all other plugins or apply plugin statements.

5. Validate `AuthActivity.kt` Code (Line 21)

The stack trace points to AuthActivity.kt:21. This means the error is triggered when your AuthActivity tries to build the Google Sign-In configuration. The most common cause is missing the default_web_client_id when constructing the AuthUI.IdpConfig.GoogleBuilder.

Ensure your AuthActivity.kt code (or equivalent) for setting up FirebaseUI for Google Sign-In looks something like this:

// Inside your AuthActivity or a method where you build the sign-in intent
private val signInLauncher = registerForActivityResult(FirebaseAuthUIActivityResultContract()) { result ->
    // Handle the sign-in result
}

// ...

val providers = arrayListOf(
    AuthUI.IdpConfig.GoogleBuilder().build() // This is where the error occurs if default_web_client_id is missing
    // Add other providers like Email, Phone, etc. if needed
)

// Create and launch sign-in intent
val signInIntent = AuthUI.getInstance()
    .createIntentBuilder()
    .setAvailableProviders(providers)
    .build()

signInLauncher.launch(signInIntent)

The AuthUI.IdpConfig.GoogleBuilder().build() call automatically tries to read the default_web_client_id from your google-services.json. If it's not there, you get this error.

In Summary

The error is a direct consequence of your Firebase project's Google Sign-In configuration not being correctly reflected in your Android app's google-services.json file. The primary solution is to ensure you have the latest and correct google-services.json file in your app/ directory, downloaded directly from your Firebase project settings.

Add Google Cloud Project to Firebase Project

To add a Google Cloud project to your existing Firebase project, you need to follow these steps:

Create a Google Cloud Project If you haven't already created a Google Cloud project, you can do so by following these steps:

Go to the Google Cloud Console.
Click on the project drop-down and select "New Project."
Enter a project name and click "Create."

Link Your Google Cloud Project to Firebase If you already have a Firebase project, you can link it to your Google Cloud project. Here’s how:

Go to the Firebase Console.
Select your existing Firebase project.
In the project overview page, click on the gear icon (Settings) next to "Project Overview" and select "Project settings."
In the "Project settings" page, go to the "Integrations" tab.
Under the "Google Cloud Platform" section, click on the "Link to Google Cloud Platform" button.
Follow the prompts to link your Firebase project to your Google Cloud project.

Add Firebase to Your Google Cloud Project If you want to add Firebase to an existing Google Cloud project, follow these steps:

Go to the Firebase Console.
Click on "Add project" and then "Add Firebase to your Google Cloud project."
Select the Google Cloud project you want to add Firebase to.
Follow the prompts to complete the setup.