DEV Community: Devika Android

Android MVVM: Pagination with Retrofit, Room Database & LiveData

Devika Android — Thu, 19 Mar 2026 08:37:07 +0000

In this blog, we will build a complete Android app using MVVM architecture that supports pagination using Retrofit and stores data locally using Room Database.

We will also learn how to handle API responses, implement infinite scrolling, manage loading states, and update boolean values dynamically in the database.

By the end of this tutorial, you will have a production-ready understanding of how modern Android apps handle pagination and offline data caching.

In this step, we add all the necessary dependencies required for building our pagination system using MVVM architecture.
This includes Room Database for local storage, Retrofit for API calls, Coroutines for background operations, and Lifecycle components for managing UI-related data.

    //sdp
    implementation("com.intuit.sdp:sdp-android:1.1.1")

    val roomVersion = "2.8.3"
    implementation("androidx.room:room-runtime:$roomVersion")
    implementation("androidx.room:room-ktx:$roomVersion")
    kapt("androidx.room:room-compiler:$roomVersion")


    implementation("com.squareup.retrofit2:retrofit:2.9.0")
    implementation("com.squareup.retrofit2:converter-gson:2.9.0")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
    implementation("com.squareup.okhttp3:logging-interceptor:4.11.0")

    // Lifecycle ViewModel & Runtime (latest stable Lifecycle)
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.10.0")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.10.0")

Setting up Retrofit API Client
we configure our Retrofit client using a singleton pattern to ensure a single instance is used throughout the app. The base URL is defined, and Gson is used to automatically convert JSON responses into Kotlin data classes.

We also attach an OkHttp logging interceptor, which helps in debugging by logging complete request and response data in the console.

object ApiClient {
    private const val BASE_URL = "https://dummyjson.com/"

    private val logging = HttpLoggingInterceptor().apply {
        level = HttpLoggingInterceptor.Level.BODY
    }

    private val okHttp = OkHttpClient.Builder()
        .addInterceptor(logging)
        .build()

    val apiService: ApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .client(okHttp)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}


interface ApiService {
    @GET("todos")
    suspend fun getTodos(
        @Query("limit") limit: Int,
        @Query("skip") skip: Int
    ): Response<TodoModel>
}

Model For Api and Entity for Database

data class TodoModel(
    @SerializedName("limit")
    @Expose
    var limit: Int,
    @SerializedName("skip")
    @Expose
    var skip: Int,
    @SerializedName("todos")
    @Expose
    var todos: List<Todo>,
    @SerializedName("total")
    @Expose
    var total: Int
) {
    data class Todo(
        @SerializedName("completed")
        @Expose
        var completed: Boolean,
        @SerializedName("id")
        @Expose
        var id: Int,
        @SerializedName("todo")
        @Expose
        var todo: String,
        @SerializedName("userId")
        @Expose
        var userId: Int
    )
}


@Entity(tableName = "todosTable")
data class TodoEntity(
    @PrimaryKey val id: Int,
    val todo: String,
    val completed: Boolean,
    val userId: Int,
    val page: Int
)

Setting up Room Database
In this step, we configure our Room Database by defining all the required entities, including both User and Todo tables. We also declare abstract DAO methods to interact with the database.

The DatabaseBuilder ensures a singleton instance of the database using a synchronized block. Additionally, fallbackToDestructiveMigration() is used to handle schema changes during development by recreating the database when the version is updated.


@Database(entities = [User::class,TodoEntity::class], version = 2)
abstract class AppDatabase: RoomDatabase() {
    abstract fun userDao(): UserDao

    abstract fun todoDao(): TodoDAO
}




object DatabaseBuilder {
    private var INSTANCE: AppDatabase? = null

    fun getInstance(context: Context): AppDatabase {
        return INSTANCE ?: synchronized(this) {
            val instance = Room.databaseBuilder(
                context.applicationContext,
                AppDatabase::class.java,
                "user_db"
            ).fallbackToDestructiveMigration().build()
            INSTANCE = instance
            instance
        }
    }
}

Dao class for inser, read , delte & update

@Dao
interface TodoDAO {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertAll(list: List<TodoEntity>)

    @Query("SELECT * FROM todosTable ORDER BY id ASC")
    fun getTodos(): LiveData<List<TodoEntity>>

    @Query("UPDATE todosTable SET completed = :status WHERE id = :id")
    suspend fun updateCompleted(id: Int, status: Boolean)

    @Query("DELETE FROM todosTable WHERE id = :id")
    suspend fun deleteItem(id: Int)

}

Repository

class TodoRepository(
    private val api: ApiService,
    private val dao: TodoDAO
) {
    fun getTodos(): LiveData<List<TodoEntity>> {
        return dao.getTodos()
    }

    suspend fun loadTodos(page: Int, limit: Int) {
        val skip = page * limit
        val response = api.getTodos(limit, skip)
        val body = response.body()

        if (response.isSuccessful && body != null) {

            val list = body.todos.map {
                TodoEntity(
                    id = it.id,
                    todo = it.todo,
                    completed = it.completed,
                    userId = it.userId,
                    page = page
                )
            }

            dao.insertAll(list)

        } else {
            Log.e("API_ERROR", response.message())
        }

    }

    suspend fun toggleTodo(todo: TodoEntity) {
        dao.updateCompleted(todo.id, !todo.completed)
    }

}

Modelclass with Factory

class TODOViewModel(
    private val repo: TodoRepository
): ViewModel() {
    private var page = 0
    private val limit = 10

    val todos: LiveData<List<TodoEntity>> = repo.getTodos()

    private val _isLoading = MutableLiveData(false)
    val isLoading: LiveData<Boolean> = _isLoading

    fun loadNextPage() {
        if (_isLoading.value == true) return

        _isLoading.value = true

        viewModelScope.launch {
            try {
                repo.loadTodos(page, limit)
                page++
            } catch (e: Exception) {
                e.printStackTrace()
            } finally {
                _isLoading.value = false
            }
        }
    }

    fun toggle(todo: TodoEntity) {
        viewModelScope.launch {
            repo.toggleTodo(todo)
        }
    }

}


class ViewModelFactory(
    private val repo: TodoRepository,
) : ViewModelProvider.Factory {

    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return when (modelClass) {
            TODOViewModel::class.java -> TODOViewModel(repo) as T

            else -> super.create(modelClass)
        }

    }
}

Set up with all Data in MAinActivity

class ApiWithRoomDBActivity : AppCompatActivity() {
    private lateinit var viewModel: TODOViewModel
    private lateinit var dao: TodoDAO
    private lateinit var repo: TodoRepository
    private lateinit var adapter: TodoAdapter
    private lateinit var binding: ActivityApiWithRoomDbactivityBinding
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()

        binding = DataBindingUtil.setContentView(this, R.layout.activity_api_with_room_dbactivity)

        dao = DatabaseBuilder.getInstance(this).todoDao()
        repo = TodoRepository(ApiClient.apiService, dao)

        viewModel =
            ViewModelProvider.create(this, ViewModelFactory(repo = repo))[TODOViewModel::class.java]
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }

        initView()
    }

    private fun initView() {

        adapter = TodoAdapter(onUpdate = { itemData ->
            viewModel.toggle(itemData)
        }, onDelete = { itemData ->
            lifecycleScope.launch {
                dao.deleteItem(itemData.id)
            }
        })
        binding.rvTodo.layoutManager = LinearLayoutManager(this)
        binding.rvTodo.adapter = adapter


        viewModel.loadNextPage()

        viewModel.todos.observe(this) { list ->
            adapter.addAll(ArrayList(list))
        }

        viewModel.isLoading.observe(this) { isLoading ->
            if (isLoading) {
                binding.pbTodo.visibility = View.VISIBLE
            } else {
                binding.pbTodo.visibility = View.GONE
            }
        }

        binding.rvTodo.addOnScrollListener(object :
            RecyclerView.OnScrollListener() {

            override fun onScrolled(rv: RecyclerView, dx: Int, dy: Int) {
                super.onScrolled(rv, dx, dy)

                if (!rv.canScrollVertically(1)) {
                    viewModel.loadNextPage()
                }
            }
        })

    }
}

How to Implement Room Database CRUD in Android with RecyclerView (Step-by-Step Kotlin Guide)

Devika Android — Wed, 18 Mar 2026 11:52:17 +0000

In this blog, we will learn how to implement complete CRUD (Create, Read, Update, Delete) operations using Room Database in Android with Kotlin. This guide covers a practical implementation using RecyclerView to display data and perform real-time updates.

We will build a simple user management feature where users can add, view, update, and delete records. The project uses modern Android development practices including Coroutines, LiveData for observing database changes, and a clean adapter-based RecyclerView setup.

By the end of this tutorial, you will understand how to:
Insert data into Room Database
Observe and display data using LiveData
Update existing records dynamically
Delete items directly from RecyclerView
Structure your code for better scalability

class RoomDatabaseActivity : AppCompatActivity() {
    private lateinit var binding: ActivityRoomDatabaseBinding
    private lateinit var db: AppDatabase

    private lateinit var userAdapter: UserAdapter
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        binding = DataBindingUtil.setContentView(this, R.layout.activity_room_database)
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }
        initView()
    }

    private fun initView() {
        db = DatabaseBuilder.getInstance(this@RoomDatabaseActivity)

        userAdapter = UserAdapter(onDelete = { userData ->
            lifecycleScope.launch {
                db.userDao().deleteUser(userData)
            }
        }, onUpdate = { userData ->
            lifecycleScope.launch {
                db.userDao().updateUser(
                    userData.copy(name = userData.name + " Updated")
                )
            }
        })

        binding.rvUser.adapter = userAdapter
        binding.rvUser.layoutManager = LinearLayoutManager(this)

        binding.btnSubmit.setOnClickListener {
            if (binding.edtAge.text.toString().isNotEmpty() && binding.edtName.text.toString()
                    .isNotEmpty()
            ) {
                lifecycleScope.launch {

                    db.userDao().insertUser(
                        User(
                            name = binding.edtName.text.toString().trim(),
                            age = binding.edtAge.text.toString().toInt()
                        )
                    )
                }
            } else {
                Toast.makeText(this, "Enter Name & Age", Toast.LENGTH_SHORT).show()
            }
        }

        lifecycleScope.launch {
            db.userDao().getAllUsers().observe(this@RoomDatabaseActivity) { userList ->
                userAdapter.setData(userList)
            }
        }
    }
}

implement Room Database in Android with Kotlin, including Entity, DAO, CRUD operations, and a singleton database setup using best practices.

Database class

@Database(entities = [User::class], version = 1)
abstract class AppDatabase: RoomDatabase() {
    abstract fun userDao(): UserDao
}

User Table(Model)

@Entity(tableName = "user_table")
data class User(
    @PrimaryKey(autoGenerate = true)
    val id: Int = 0,
    val name: String,
    val age: Int
)

UserDao Class

@Dao
interface UserDao {
    // CREATE
    @Insert
    suspend fun insertUser(user: User)

    // READ
    @Query("SELECT * FROM user_table")
    fun getAllUsers(): LiveData<List<User>>

    // UPDATE
    @Update
    suspend fun updateUser(user: User)

    // DELETE
    @Delete
    suspend fun deleteUser(user: User)
}

Create Database Instance


object DatabaseBuilder {
    private var INSTANCE: AppDatabase? = null

    fun getInstance(context: Context): AppDatabase {
        return INSTANCE ?: synchronized(this) {
            val instance = Room.databaseBuilder(
                context.applicationContext,
                AppDatabase::class.java,
                "user_db"
            ).build()
            INSTANCE = instance
            instance
        }
    }
}

Adapter For Display Data

class UserAdapter(
    private val onDelete: (User) -> Unit,
    private val onUpdate: (User) -> Unit
) : RecyclerView.Adapter<UserAdapter.ViewHolder>() {
    private var list = ArrayList<User>()

    fun setData(data: List<User>) {
        list.clear()
        list.addAll(data)
        notifyDataSetChanged()
    }

    override fun onCreateViewHolder(
        parent: ViewGroup,
        viewType: Int
    ): ViewHolder {
        val binding =
            ItemUserDesignBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        return ViewHolder(binding)
    }

    override fun onBindViewHolder(
        holder: ViewHolder,
        position: Int
    ) {
        val itemData = list[position]
        holder.setData(itemData, onDelete, onUpdate)

    }

    override fun getItemCount(): Int {
        return list.size
    }

    class ViewHolder(private val binding: ItemUserDesignBinding) :
        RecyclerView.ViewHolder(binding.root) {
        fun setData(itemData: User, onDelete: (User) -> Unit, onUpdate: (User) -> Unit) {
            binding.tvName.text = itemData.name
            binding.tvAge.text = itemData.age.toString()

            binding.btnDelete.setOnClickListener {
                onDelete(itemData)
            }

            binding.btnUpdate.setOnClickListener {
                onUpdate(itemData)
            }
        }
    }
}

This guide demonstrates how to implement Room Database in Android using Kotlin. It covers creating an Entity to define the table structure, a DAO for handling CRUD operations, and a Database class to manage data access.

A singleton pattern is used to ensure a single instance of the database throughout the app. LiveData is utilized to observe data changes and automatically update the UI, making the app more reactive and efficient.

Overall, this setup provides a simple and scalable approach to local data storage in Android applications.

Digital Wellbeing : Total uses time and Categories

Devika Android — Wed, 18 Mar 2026 10:13:22 +0000

In today’s fast-paced digital world, we spend a significant amount of time on our smartphones. While technology makes life easier, excessive screen time can negatively impact our productivity, focus, and mental health.

A Digital Wellbeing app helps users monitor and manage their daily screen usage, enabling them to build healthier digital habits and maintain a better work-life balance.

Manifest File

 <uses-permission android:name="android.permission.PACKAGE_USAGE_STATS"
        tools:ignore="ProtectedPermissions" />

    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"
        tools:ignore="PackageVisibilityPolicy,QueryAllPackagesPermission" />

    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>

    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.DigitWellBeing">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <service
            android:name=".MyAccessibilityService"
            android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE"
            android:exported="true">

            <intent-filter>
                <action android:name="android.accessibilityservice.AccessibilityService"/>
            </intent-filter>

            <meta-data
                android:name="android.accessibilityservice"
                android:resource="@xml/accessibility_config"/>
        </service>
    </application>

Model Class

data class AppUsage(
    val appName: String,
    val packageName: String,
    val usageTime: Long,
    val category: String
)

Main Activity

class MainActivity : AppCompatActivity() {
    private lateinit var binding: ActivityMainBinding
    private lateinit var adapter: AppUsageAdapter
    val categories = listOf(
        "All Categories",
        "No Specified",
        "Education/Business",
        "Entertainment",
        "Family",
        "Game",
        "Health/Fitness",
        "Social Networking",
        "System Apps",
        "Utility"
    )

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }
    }


    private fun initView() {

        val spinnerAdapter = ArrayAdapter(
            this,
            android.R.layout.simple_spinner_item,
            categories
        )

        spinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
        binding.spinnerCategories.adapter = spinnerAdapter

        adapter = AppUsageAdapter(emptyList(), { itemData ->

            if (Settings.canDrawOverlays(this) && isAccessibilityServiceEnabled(this)) {
                showTimerDialog(itemData)
            } else {
                if (!Settings.canDrawOverlays(this)) {
                    val intent = Intent(
                        Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
                        Uri.parse("package:$packageName")
                    )
                    startActivity(intent)
                }

                if (!isAccessibilityServiceEnabled(this)) {
                    startActivity(Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS))
                }
            }

        })
        binding.recyclerApps.layoutManager = LinearLayoutManager(this)
        binding.recyclerApps.adapter = adapter

        val calendar = Calendar.getInstance()
        calendar.set(Calendar.HOUR_OF_DAY, 0)
        calendar.set(Calendar.MINUTE, 0)
        calendar.set(Calendar.SECOND, 0)

        val startTime = calendar.timeInMillis
        val endTime = System.currentTimeMillis()

        val usageStatsManager = getSystemService(USAGE_STATS_SERVICE) as UsageStatsManager

        val stats = usageStatsManager.queryUsageStats(
            UsageStatsManager.INTERVAL_DAILY,
            startTime,
            endTime
        )

        val pm = packageManager
        val appMap = mutableMapOf<String, AppUsage>()

        for (usage in stats) {
            val totalTime = usage.totalTimeInForeground

            if (totalTime > 0) {
                try {
                    val packageName = usage.packageName

                    val appInfo = pm.getApplicationInfo(packageName, 0)
                    val appName = pm.getApplicationLabel(appInfo).toString()

                    val category = getCategoryName(appInfo.category, packageName)

                    if (appMap.containsKey(packageName)) {
                        val existing = appMap[packageName]!!
                        appMap[packageName] = existing.copy(
                            usageTime = existing.usageTime + totalTime
                        )
                    } else {
                        appMap[packageName] = AppUsage(
                            appName = appName,
                            packageName = packageName,
                            usageTime = totalTime,
                            category = category
                        )
                    }

                } catch (e: Exception) {
                    e.printStackTrace()
                }
            }
        }

        val appList = appMap.values
            .sortedByDescending { it.usageTime }

        binding.spinnerCategories.onItemSelectedListener =
            object : AdapterView.OnItemSelectedListener {
                override fun onItemSelected(
                    parent: AdapterView<*>,
                    view: View?,
                    position: Int,
                    id: Long
                ) {

                    val selectedCategory = categories[position]
                    val filteredList = filterApps(selectedCategory, appList)

                    adapter.updateList(filteredList)
                }

                override fun onNothingSelected(parent: AdapterView<*>) {}
            }

        val totalUsageTime = appList.sumOf { it.usageTime }

        val formattedTime = formatTime(totalUsageTime)

        binding.tvTotalTime.text = "Total Uses Time:- $formattedTime"
    }

    override fun onResume() {
        super.onResume()
        if (!isUsageAccessGranted(this)) {
            startActivity(Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS))
        } else {
            initView()
        }
    }

    fun filterApps(category: String, list: List<AppUsage>): List<AppUsage> {
        return if (category == "All Categories") {
            list
        } else {
            list.filter { it.category == category }
        }
    }

    fun isUsageAccessGranted(context: Context): Boolean {
        val appOps = context.getSystemService(APP_OPS_SERVICE) as AppOpsManager

        val mode = appOps.checkOpNoThrow(
            AppOpsManager.OPSTR_GET_USAGE_STATS,
            android.os.Process.myUid(),
            context.packageName
        )

        return if (mode == AppOpsManager.MODE_DEFAULT) {
            context.checkCallingOrSelfPermission(
                android.Manifest.permission.PACKAGE_USAGE_STATS
            ) == PackageManager.PERMISSION_GRANTED
        } else {
            mode == AppOpsManager.MODE_ALLOWED
        }
    }

    fun isAccessibilityServiceEnabled(context: Context): Boolean {
        val expectedComponent = ComponentName(context, MyAccessibilityService::class.java)
        val enabledServices = Settings.Secure.getString(
            context.contentResolver,
            Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES
        ) ?: return false

        return enabledServices.contains(expectedComponent.flattenToString())
    }

    fun formatTime(ms: Long): String {
        val seconds = ms / 1000
        val minutes = seconds / 60
        val hours = minutes / 60

        return "${hours}h ${minutes % 60}m"
    }

    fun getCategoryName(category: Int, packageName: String): String {
        return when (category) {
            ApplicationInfo.CATEGORY_GAME -> "Game"
            ApplicationInfo.CATEGORY_SOCIAL -> "Social Networking"
            ApplicationInfo.CATEGORY_PRODUCTIVITY -> "Education/Business"
            ApplicationInfo.CATEGORY_AUDIO,
            ApplicationInfo.CATEGORY_VIDEO -> "Entertainment"

            ApplicationInfo.CATEGORY_NEWS -> "Education/Business"
            ApplicationInfo.CATEGORY_MAPS -> "Utility"
            ApplicationInfo.CATEGORY_ACCESSIBILITY -> "Utility"
            ApplicationInfo.CATEGORY_IMAGE -> "Entertainment"
            ApplicationInfo.CATEGORY_UNDEFINED -> {
                if (isSystemApp(packageName)) "System Apps"
                else "No Specified"
            }

            else -> "No Specified"
        }
    }

    fun isSystemApp(packageName: String): Boolean {
        return try {
            val appInfo = packageManager.getApplicationInfo(packageName, 0)
            (appInfo.flags and ApplicationInfo.FLAG_SYSTEM) != 0
        } catch (e: Exception) {
            false
        }
    }

    fun showTimerDialog(app: AppUsage) {
        val dialog = Dialog(this)
        val binding = DialogTimerDesignBinding.inflate(LayoutInflater.from(this), null, false)
        dialog.setContentView(binding.root)

        binding.btnSet.setOnClickListener {
            val minutes = binding.etMinutes.text.toString().toIntOrNull() ?: 0

            if (minutes > 0) {
                val endTime = System.currentTimeMillis() + minutes * 60 * 1000

                val pref = getSharedPreferences("app_limits", MODE_PRIVATE)
                pref.edit { putLong(app.packageName, endTime) }

                Toast.makeText(this, "Timer Set", Toast.LENGTH_SHORT).show()
                dialog.dismiss()
            }
        }

        dialog.show()
    }
}

Serviece Class

package com.example.digitwellbeing

import android.accessibilityservice.AccessibilityService
import android.graphics.PixelFormat
import android.os.Handler
import android.os.Looper
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.WindowManager
import android.view.accessibility.AccessibilityEvent
import android.widget.Button

class MyAccessibilityService : AccessibilityService() {

    private var windowManager: WindowManager? = null
    private var overlayView: View? = null
    private var currentPackage: String? = null
    private var isHandlerStarted = false

    override fun onAccessibilityEvent(event: AccessibilityEvent?) {
        Log.d("ACCESS_SERVICE", "Event: ${event?.packageName}")

        val pkg = event?.packageName?.toString() ?: return

        currentPackage = pkg

        // 🔥 Start handler here (ONLY ONCE)
        if (!isHandlerStarted) {
            isHandlerStarted = true
            handler.post(runnable)
        }

        if (event?.eventType == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED ||
            event?.eventType == AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED) {

            currentPackage = event.packageName?.toString()
        }
    }

    override fun onInterrupt() {
        TODO("Not yet implemented")
    }

    override fun onServiceConnected() {
        super.onServiceConnected()
        Log.d("ACCESS_SERVICE", "Service Connected ✅")
        handler.post(runnable)
    }

    private val handler = Handler(Looper.getMainLooper())

    private val runnable = object : Runnable {
        override fun run() {

            currentPackage?.let { packageName ->

                if (packageName == this@MyAccessibilityService.packageName) return

                val pref = getSharedPreferences("app_limits", MODE_PRIVATE)
                val endTime = pref.getLong(packageName, 0)

                if (endTime > 0 && System.currentTimeMillis() > endTime) {
                    showOverlay()
                }
            }

            handler.postDelayed(this, 1000) // every 1 sec
        }
    }


    private fun showOverlay() {
        Log.d("BLOCK_CHECK", "LIMIT EXCEEDED 🚫")

        if (overlayView != null) return

        windowManager = getSystemService(WINDOW_SERVICE) as WindowManager

        val inflater = LayoutInflater.from(this)
        overlayView = inflater.inflate(R.layout.overlay_block, null)

        val params = WindowManager.LayoutParams(
            WindowManager.LayoutParams.MATCH_PARENT,
            WindowManager.LayoutParams.MATCH_PARENT,
            WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
            0,
            PixelFormat.TRANSLUCENT
        )

        windowManager?.addView(overlayView, params)

        overlayView?.findViewById<Button>(R.id.btnClose)?.setOnClickListener {
            removeOverlay()
        }
    }

    private fun removeOverlay() {
        if (overlayView != null) {
            windowManager?.removeView(overlayView)
            overlayView = null
        }
    }
}

Resources (accessibility_config)

<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
    android:accessibilityEventTypes="typeWindowStateChanged|typeWindowContentChanged"
    android:accessibilityFeedbackType="feedbackGeneric"
    android:accessibilityFlags="flagDefault"
    android:canRetrieveWindowContent="false"
    android:description="@string/accessibility_desc"
    android:notificationTimeout="100" />

<string name="accessibility_desc">
    This app monitors app usage to block apps after time limit.
</string>

This app acts as a personal assistant that guides users toward mindful usage. It encourages breaks, limits unnecessary usage, and promotes a healthier lifestyle.Digital wellbeing is not about avoiding technology but using it wisely. With the help of this app, users can take control of their digital life and create a more balanced and productive routine.

Modern Android File Manager Implementation Using MediaStore and PackageManager

Devika Android — Mon, 16 Mar 2026 10:27:52 +0000

SYSTEM_ALERT_WINDOW: Allows the app to display content on top of other apps (like chat heads or floating windows).
FOREGROUND_SERVICE: Lets the app run important tasks in the foreground with a visible notification so the system doesn’t kill it.
FOREGROUND_SERVICE_DATA_SYNC: Specifically allows a foreground service to perform data synchronization tasks (like uploading or downloading files).
POST_NOTIFICATIONS: Allows the app to send and display notifications to the user (required from Android 13+).
These permissions are mainly used for background tasks, overlays, and showing notifications while the app is actively running important processes.

   //sdp
   implementation("com.intuit.sdp:sdp-android:1.1.1")

// Glide (latest stable major — Glide 5.x)
   implementation("com.github.bumptech.glide:glide:5.0.5")
   kapt("com.github.bumptech.glide:compiler:5.0.5")

 // Lifecycle ViewModel & Runtime (latest stable Lifecycle)
   implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.10.0")
   implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.10.0")

   <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
   <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
   <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
   <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
   <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" />
   <uses-permission
       android:name="android.permission.PACKAGE_USAGE_STATS"
       tools:ignore="ProtectedPermissions" />l̥

   <queries>
       <package android:name="com.google.android.youtube" />
       <package android:name="com.android.launcher3" />
       <package android:name="com.instagram.android" />
       <package android:name="com.whatsapp" />
   </queries>


if do this
   <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
   <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

This code is used to check and request Usage Access Permission, not normal storage permission.
hasUsagePermission() checks whether the app has permission to access app usage statistics using AppOpsManager.OPSTR_GET_USAGE_STATS.
If permission is not granted, requestUsagePermission() opens the Usage Access Settings screen using Settings.ACTION_USAGE_ACCESS_SETTINGS.
The user must manually enable the permission from system settings (it cannot be granted automatically)
This permission (PACKAGE_USAGE_STATS) is mainly used to track which apps are used and for how long.
It is not required for accessing files from storage.

  if (!Common.hasUsagePermission(requireActivity())) {
           Common.requestUsagePermission(requireActivity())
       }

  fun requestUsagePermission(context: Context) {
       context.startActivity(Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS))
   }

   fun hasUsagePermission(context: Context): Boolean {
       val appOps = context.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
       val mode = appOps.checkOpNoThrow(
           AppOpsManager.OPSTR_GET_USAGE_STATS, android.os.Process.myUid(), context.packageName
       )
       return mode == AppOpsManager.MODE_ALLOWED
   }
MANAGE_EXTERNAL_STORAGE permission is not required for this use case.
Use READ_MEDIA_IMAGES / VIDEO / AUDIO (Android 13+) or READ_EXTERNAL_STORAGE (Android 12 and below).
Your structure is clean and suitable for a basic File Manager app.
binding.btnFileManager.id -> {

               if (hasStoragePermission()) {

                   if (!Environment.isExternalStorageManager()) {
                       val intent = Intent(
                           Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION
                       )
                       startActivity(intent)
                   } else {
                       requireActivity().startActivity(
                           Intent(
                               requireActivity(),
                               FileManagerActivity::class.java
                           )
                       )
                   }


               } else {
                   requestPermissions(requireActivity())
                   Toast.makeText(requireActivity(), "Please allow Permission", Toast.LENGTH_SHORT)
                       .show()
               }
           }

fun hasStoragePermission(): Boolean {

       return if (Build.VERSION.SDK_INT >= 33) {

           ContextCompat.checkSelfPermission(
               requireActivity(),
               Manifest.permission.READ_MEDIA_IMAGES
           ) == PackageManager.PERMISSION_GRANTED &&

                   ContextCompat.checkSelfPermission(
                       requireActivity(),
                       Manifest.permission.READ_MEDIA_VIDEO
                   ) == PackageManager.PERMISSION_GRANTED &&

                   ContextCompat.checkSelfPermission(
                       requireActivity(),
                       Manifest.permission.READ_MEDIA_AUDIO
                   ) == PackageManager.PERMISSION_GRANTED

       } else {
           ContextCompat.checkSelfPermission(
               requireActivity(),
               Manifest.permission.READ_EXTERNAL_STORAGE
           ) == PackageManager.PERMISSION_GRANTED
       }
   }


   fun requestPermissions(activity: Activity) {

       if (Build.VERSION.SDK_INT >= 33) {
           activity.requestPermissions(
               arrayOf(
                   Manifest.permission.READ_MEDIA_IMAGES,
                   Manifest.permission.READ_MEDIA_VIDEO,
                   Manifest.permission.READ_MEDIA_AUDIO,
                   Manifest.permission.READ_EXTERNAL_STORAGE
               ),
               100
           )

       } else {
           activity.requestPermissions(
               arrayOf(
                   Manifest.permission.READ_EXTERNAL_STORAGE
               ),
               100
           )
       }
   }

MediaStore to get images, videos, audio, PDF, and APK files count and total size.
getCategoryStats() calculates file count and total storage size using MediaStore.MediaColumns.SIZE.
APK files are filtered using MIME type "application/vnd.android.package-archive".
getAppStats() correctly separates Installed Apps and System Apps using PackageManager.

class FileManagerActivity : AppCompatActivity() {
   private lateinit var binding: ActivityFileManagerBinding
   private var categoryList: List<CategoryModel> = ArrayList()
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       enableEdgeToEdge()
       binding = DataBindingUtil.setContentView(this, R.layout.activity_file_manager)
       ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
           val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
           v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
           insets
       }

       initView()
   }

   private fun initView() {

       val adapter = FileCatAdapter { itemData ->
           Log.e("TAG", "initView:gggg ${itemData.name} ")
           when (itemData.name.trim()) {
               "Images" -> {
                   val imageIntent = Intent(this, AllImagesActivity::class.java)
                   imageIntent.putExtra("content", "Images")
                   startActivity(imageIntent)
               }

               "Videos" -> {
                   val videoIntent = Intent(this, AllImagesActivity::class.java)
                   videoIntent.putExtra("content", "Videos")
                   startActivity(videoIntent)
               }

               "Audio" -> {
                   val audioIntent = Intent(this, AllImagesActivity::class.java)
                   audioIntent.putExtra("content", "Audio")
                   startActivity(audioIntent)
               }

               "PDF" -> {
                   val documentIntent = Intent(this, AllImagesActivity::class.java)
                   documentIntent.putExtra("content", "PDF")
                   startActivity(documentIntent)
               }

               "APK" -> {
                   val apkIntent = Intent(this, AllAppsActivity::class.java)
                   apkIntent.putExtra("content", "APK")
                   startActivity(apkIntent)
               }

               "Installed Apps" -> {
                   val installAppIntent = Intent(this, AllAppsActivity::class.java)
                   installAppIntent.putExtra("content", "Installed Apps")
                   startActivity(installAppIntent)
               }

               "System Apps" -> {
                   val systemAppsIntent = Intent(this, AllAppsActivity::class.java)
                   systemAppsIntent.putExtra("content", "System Apps")
                   startActivity(systemAppsIntent)
               }




           }

       }
       binding.rvCategories.adapter = adapter
       binding.rvCategories.layoutManager = GridLayoutManager(this, 2)

       lifecycleScope.launch(Dispatchers.Main) {
           categoryList = getAllCategories(this@FileManagerActivity)
           adapter.addAll(ArrayList(categoryList))
       }

   }

   suspend fun getAllCategories(context: Context): List<CategoryModel> {

       val imageStats = getCategoryStats(
           context,
           MediaStore.Images.Media.EXTERNAL_CONTENT_URI
       )

       val videoStats = getCategoryStats(
           context,
           MediaStore.Video.Media.EXTERNAL_CONTENT_URI
       )

       val audioStats = getCategoryStats(
           context,
           MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
       )

       val docUri = MediaStore.Files.getContentUri("external")

       val docSelection =
           "${MediaStore.Files.FileColumns.MIME_TYPE} IN (?,?,?,?)"

       val docArgs = arrayOf(
           "application/pdf",
          /* "application/msword",
           "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
           "text/plain"*/
       )

       val docStats = getCategoryStats(
           context,
           docUri,
           docSelection,
           docArgs
       )

       val apkSelection =
           "${MediaStore.Files.FileColumns.MIME_TYPE}=?"

       val apkArgs = arrayOf(
           "application/vnd.android.package-archive"
       )

       val apkStats = getCategoryStats(
           context,
           docUri,
           apkSelection,
           apkArgs
       )

       val appStats = getAppStats(context)

       return listOf(
           CategoryModel(
               "Images",
               imageStats.count,
               formatSize(imageStats.totalSize),
               R.drawable.ic_launcher_foreground
           ),
           CategoryModel(
               "Videos",
               videoStats.count,
               formatSize(videoStats.totalSize),
               R.drawable.ic_launcher_foreground
           ),
           CategoryModel(
               "Audio",
               audioStats.count,
               formatSize(audioStats.totalSize),
               R.drawable.ic_launcher_foreground
           ),
           CategoryModel(
               "PDF",
               docStats.count,
               formatSize(docStats.totalSize),
               R.drawable.ic_launcher_foreground
           ),
           CategoryModel(
               "APK",
               apkStats.count,
               formatSize(apkStats.totalSize),
               R.drawable.ic_launcher_foreground
           ),
           CategoryModel(
               "Installed Apps",
               appStats.userCount,
               "",
               R.drawable.ic_launcher_foreground
           ),
           CategoryModel(
               "System Apps",
               appStats.systemCount,
               "",
               R.drawable.ic_launcher_foreground
           )
       )
   }


   fun formatSize(size: Long): String {

       val kb = 1024
       val mb = kb * 1024
       val gb = mb * 1024

       return when {
           size >= gb -> String.format("%.2f GB", size.toFloat() / gb)
           size >= mb -> String.format("%.2f MB", size.toFloat() / mb)
           size >= kb -> String.format("%.2f KB", size.toFloat() / kb)
           else -> "$size Bytes"
       }
   }

   suspend fun getCategoryStats(
       context: Context,
       uri: Uri,
       selection: String? = null,
       selectionArgs: Array<String>? = null
   ): CategoryStats = withContext(Dispatchers.IO) {

       var totalSize = 0L
       var count = 0

       val projection = arrayOf(
           MediaStore.MediaColumns.SIZE
       )

       context.contentResolver.query(
           uri,
           projection,
           selection,
           selectionArgs,
           null
       )?.use { cursor ->

           val sizeColumn =
               cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.SIZE)

           while (cursor.moveToNext()) {
               totalSize += cursor.getLong(sizeColumn)
               count++
           }
       }

       CategoryStats(count, totalSize)
   }

   fun getAppStats(context: Context): AppStats {

       val pm = context.packageManager
       val apps = pm.getInstalledApplications(PackageManager.GET_META_DATA)

       var systemCount = 0
       var userCount = 0

       apps.forEach { appInfo ->

           val isSystem =
               (appInfo.flags and ApplicationInfo.FLAG_SYSTEM) != 0

           val isUpdatedSystem =
               (appInfo.flags and ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0

           if (isSystem && !isUpdatedSystem) {
               systemCount++
           } else {
               userCount++
           }
       }

       return AppStats(systemCount, userCount)
   }
}

CategoryModel → Represents each main category (Images, Videos, APK, etc.) with name, file count, total formatted size, and icon.
CategoryStats → Used internally to store raw count and total size (Long) before formatting.
MediaModel → Represents individual media files (image, video, audio) with name, size, URI, type, and optional duration (for videos).
AppStats → Stores total number of system apps and user-installed apps.
AllAppsModel → Represents individual installed apps with app name, package name, icon, version name, and system/user flag.

data class CategoryModel(
   val name: String,
   val count: Int,
   val totalSize: String,
   val icon: Int
)

data class CategoryStats(
   val count: Int,
   val totalSize: Long
)

data class MediaModel(
   val name: String,
   val size: Long,
   val formattedSize: String,
   val uri: Uri,
   val type: MediaType? = null,
   val duration: Long? = null   // video ke liye
)

data class AppStats(
   val systemCount: Int,
   val userCount: Int
)

data class AllAppsModel(
   val appName: String,
   val packageName: String,
   val icon: Drawable? = null,
   val versionName: String,
   val isSystemApp: Boolean
)

File Count Adapter


class FileCatAdapter(val onClick: (itemData: CategoryModel) -> Unit) :
   RecyclerView.Adapter<FileCatAdapter.FileDataHolder>() {
   private var fileList: ArrayList<CategoryModel> = ArrayList()
   override fun onCreateViewHolder(
       parent: ViewGroup,
       viewType: Int
   ): FileDataHolder {
       val binding = FileDesignBinding.inflate(LayoutInflater.from(parent.context), parent, false)
       return FileDataHolder(binding)
   }

   override fun onBindViewHolder(
       holder: FileDataHolder,
       position: Int
   ) {
       val itemData = fileList[position]
       holder.setData(itemData)

       holder.itemView.setOnClickListener {
           onClick.invoke(itemData)
       }
   }

   override fun getItemCount(): Int {
       return fileList.size
   }

   fun addAll(fileList: ArrayList<CategoryModel>) {
       this.fileList = ArrayList()
       this.fileList.addAll(fileList)
       notifyDataSetChanged()
   }

   class FileDataHolder(val binding: FileDesignBinding) : RecyclerView.ViewHolder(binding.root) {

       fun setData(itemData: CategoryModel) {
           binding.tvTitle.text = itemData.name
           binding.tvCount.text = "${itemData.count}"
           binding.tvSize.text = itemData.totalSize
       }

   }
}

This is a RecyclerView Adapter used to display file categories (Images, Videos, APK, etc.).
It takes a click listener lambda (onClick) to handle item clicks dynamically from the activity.

class AllImagesActivity : AppCompatActivity() {
   private lateinit var binding: ActivityAllImagesBinding

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       enableEdgeToEdge()
       binding = DataBindingUtil.setContentView(this, R.layout.activity_all_images)
       ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
           val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
           v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
           insets
       }

       initView()
   }

   private fun initView() {
       val adapter = AllImagesAdapter()
       binding.rvAllImages.adapter = adapter
       binding.rvAllImages.layoutManager = GridLayoutManager(this, 2)

       val content = intent.getStringExtra("content")
       Log.e("TAG", "initView:33 $content")

       when (content) {
           "Images" -> {
               lifecycleScope.launch(Dispatchers.Main) {
                   val imageList = getAllImages(this@AllImagesActivity)
                   adapter.addAll(ArrayList(imageList))
               }
           }

           "Videos" -> {
               lifecycleScope.launch(Dispatchers.Main) {
                   val videoList = getAllVideos(this@AllImagesActivity)
                   adapter.addAll(ArrayList(videoList))
               }
           }

           "Audio" -> {
               lifecycleScope.launch(Dispatchers.Main) {
                   val audioList = getAllAudio(this@AllImagesActivity)
                   adapter.addAll(ArrayList(audioList))
               }
           }

           "PDF" -> {
               lifecycleScope.launch(Dispatchers.Main) {
                   val documentList = getAllDocuments(this@AllImagesActivity)
                   adapter.addAll(ArrayList(documentList))
               }
           }
       }


   }

   suspend fun getAllImages(context: Context): List<MediaModel> =
       withContext(Dispatchers.IO) {

           val imageList = mutableListOf<MediaModel>()

           val projection = arrayOf(
               MediaStore.Images.Media._ID,
               MediaStore.Images.Media.DISPLAY_NAME,
               MediaStore.Images.Media.SIZE
           )

           val sortOrder =
               "${MediaStore.Images.Media.DATE_ADDED} DESC"

           context.contentResolver.query(
               MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
               projection,
               null,
               null,
               sortOrder
           )?.use { cursor ->

               val idColumn =
                   cursor.getColumnIndexOrThrow(MediaStore.Images.Media._ID)
               val nameColumn =
                   cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DISPLAY_NAME)
               val sizeColumn =
                   cursor.getColumnIndexOrThrow(MediaStore.Images.Media.SIZE)

               while (cursor.moveToNext()) {

                   val id = cursor.getLong(idColumn)
                   val name = cursor.getString(nameColumn)
                   val size = cursor.getLong(sizeColumn)

                   val contentUri = ContentUris.withAppendedId(
                       MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                       id
                   )

                   imageList.add(
                       MediaModel(
                           name = name ?: "Unknown",
                           size = size,
                           formattedSize = Common.formatSize(size),
                           uri = contentUri,
                           type = MediaType.IMAGE,
                           null
                       )
                   )
               }
           }

           imageList
       }


   suspend fun getAllVideos(context: Context): List<MediaModel> =
       withContext(Dispatchers.IO) {

           val list = mutableListOf<MediaModel>()

           val projection = arrayOf(
               MediaStore.Video.Media._ID,
               MediaStore.Video.Media.DISPLAY_NAME,
               MediaStore.Video.Media.SIZE,
               MediaStore.Video.Media.DURATION
           )

           context.contentResolver.query(
               MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
               projection,
               null,
               null,
               "${MediaStore.Video.Media.DATE_ADDED} DESC"
           )?.use { cursor ->

               val idCol = cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID)
               val nameCol = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME)
               val sizeCol = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.SIZE)
               val durationCol = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DURATION)

               while (cursor.moveToNext()) {

                   val id = cursor.getLong(idCol)
                   val name = cursor.getString(nameCol)
                   val size = cursor.getLong(sizeCol)
                   val duration = cursor.getLong(durationCol)

                   val uri = ContentUris.withAppendedId(
                       MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
                       id
                   )

                   list.add(
                       MediaModel(
                           name = name ?: "Unknown",
                           size = size,
                           formattedSize = Common.formatSize(size),
                           uri = uri,
                           type = MediaType.VIDEO,
                           duration = duration
                       )
                   )
               }
           }

           list
       }


   suspend fun getAllAudio(context: Context): List<MediaModel> =
       withContext(Dispatchers.IO) {

           val list = mutableListOf<MediaModel>()

           val projection = arrayOf(
               MediaStore.Audio.Media._ID,
               MediaStore.Audio.Media.DISPLAY_NAME,
               MediaStore.Audio.Media.SIZE,
               MediaStore.Audio.Media.DURATION
           )

           context.contentResolver.query(
               MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
               projection,
               null,
               null,
               "${MediaStore.Audio.Media.DATE_ADDED} DESC"
           )?.use { cursor ->

               val idCol = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media._ID)
               val nameCol = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.DISPLAY_NAME)
               val sizeCol = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.SIZE)
               val durationCol = cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.DURATION)

               while (cursor.moveToNext()) {

                   val id = cursor.getLong(idCol)
                   val name = cursor.getString(nameCol)
                   val size = cursor.getLong(sizeCol)
                   val duration = cursor.getLong(durationCol)

                   val uri = ContentUris.withAppendedId(
                       MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
                       id
                   )

                   list.add(
                       MediaModel(
                           name = name ?: "Unknown",
                           size = size,
                           formattedSize = Common.formatSize(size),
                           uri = uri,
                           type = MediaType.AUDIO,
                           duration = duration
                       )
                   )
               }
           }

           list
       }


   suspend fun getAllDocuments(context: Context): List<MediaModel> =
       withContext(Dispatchers.IO) {

           val list = mutableListOf<MediaModel>()

           val uri = MediaStore.Files.getContentUri("external")

           val projection = arrayOf(
               MediaStore.Files.FileColumns._ID,
               MediaStore.Files.FileColumns.DISPLAY_NAME,
               MediaStore.Files.FileColumns.SIZE,
               MediaStore.Files.FileColumns.MIME_TYPE
           )

           val selection =
               "${MediaStore.Files.FileColumns.MIME_TYPE}=?"

           val selectionArgs = arrayOf("application/pdf")

           context.contentResolver.query(
               uri,
               projection,
               selection,
               selectionArgs,
               "${MediaStore.Files.FileColumns.DATE_ADDED} DESC"
           )?.use { cursor ->

               val idCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns._ID)
               val nameCol =
                   cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DISPLAY_NAME)
               val sizeCol = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.SIZE)

               while (cursor.moveToNext()) {

                   val id = cursor.getLong(idCol)
                   val name = cursor.getString(nameCol)
                   val size = cursor.getLong(sizeCol)

                   val contentUri = ContentUris.withAppendedId(uri, id)

                   list.add(
                       MediaModel(
                           name = name ?: "Unknown",
                           size = size,
                           formattedSize = Common.formatSize(size),
                           uri = contentUri,
                           type = MediaType.DOCUMENT
                       )
                   )
               }
           }

           list
       }


}

enum class MediaType {
   IMAGE,
   VIDEO,
   AUDIO,
   DOCUMENT
}

AllImagesActivity displays media files (Images, Videos, Audio, PDF) based on the selected category from intent.
It uses RecyclerView with GridLayoutManager to show items in a 2-column grid.

class AllImagesAdapter : RecyclerView.Adapter<AllImagesAdapter.ImageViewHolder>() {
   private var allImageList: ArrayList<MediaModel> = ArrayList()
   override fun onCreateViewHolder(
       parent: ViewGroup,
       viewType: Int
   ): ImageViewHolder {
       val binding = ImageDesignBinding.inflate(LayoutInflater.from(parent.context), parent, false)
       return ImageViewHolder(binding)
   }

   override fun onBindViewHolder(
       holder: ImageViewHolder,
       position: Int
   ) {
       val itemData = allImageList[position]
       holder.setData(itemData)
   }

   override fun getItemCount(): Int {
       return allImageList.size
   }

   fun addAll(fileList: ArrayList<MediaModel>) {
       this.allImageList = ArrayList()
       this.allImageList.addAll(fileList)
       notifyDataSetChanged()
   }

   class ImageViewHolder(val binding: ImageDesignBinding) : RecyclerView.ViewHolder(binding.root) {
       fun setData(itemData: MediaModel) {
           binding.tvTitle.text = itemData.name
           binding.tvSize.text = itemData.formattedSize
           Glide.with(binding.ivImage.context).load(itemData.uri).into(binding.ivImage)
       }
   }
}

AllAppsActivity displays APK files, Installed Apps, and System Apps based on the selected category from intent.
It uses a RecyclerView with GridLayoutManager (3 columns) to show app items.


class AllAppsActivity : AppCompatActivity() {
   private lateinit var binding: ActivityAllAppsBinding

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       enableEdgeToEdge()
       binding = DataBindingUtil.setContentView(this, R.layout.activity_all_apps)
       ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
           val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
           v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
           insets
       }

       initView()
   }

   private fun initView() {
       val content = intent.getStringExtra("content")

       val adapter = AllAppsAdapter()
       binding.rvAllApps.adapter = adapter
       binding.rvAllApps.layoutManager = GridLayoutManager(this, 3)

       when (content) {
           "APK" -> {
               val apkList = getAllApkFiles()
               adapter.addAll(ArrayList(apkList))
           }

           "Installed Apps" -> {
               lifecycleScope.launch(Dispatchers.Main) {
                   val apkList = getInstalledApps(this@AllAppsActivity)
                   adapter.addAll(ArrayList(apkList))
               }
           }

           "System Apps" -> {
               lifecycleScope.launch(Dispatchers.Main) {
                   val apkList = getSystemApps(this@AllAppsActivity)
                   adapter.addAll(ArrayList(apkList))
               }
           }
       }

   }


   fun getAllApkFiles(): List<AllAppsModel> {

       val root = Environment.getExternalStorageDirectory()
       val apkList = mutableListOf<AllAppsModel>()

       root.walkTopDown().forEach { file ->

           if (file.isFile && file.extension.equals("apk", true)) {

               apkList.add(
                   AllAppsModel(
                       appName = file.nameWithoutExtension,
                       packageName = file.absolutePath,
                       icon = null,
                       versionName = "",
                       isSystemApp = false
                   )
               )
           }
       }

       return apkList
   }

   suspend fun getInstalledApps(context: Context): List<AllAppsModel> =
       withContext(Dispatchers.IO) {

           val pm = context.packageManager
           val apps = pm.getInstalledApplications(PackageManager.GET_META_DATA)

           val appList = mutableListOf<AllAppsModel>()

           apps.forEach { appInfo ->

               val packageInfo =
                   pm.getPackageInfo(appInfo.packageName, 0)

               val apkFile = File(appInfo.sourceDir)
               val appSize = if (apkFile.exists()) apkFile.length() else 0L

               val isSystem =
                   (appInfo.flags and ApplicationInfo.FLAG_SYSTEM) != 0

               val isUpdatedSystem =
                   (appInfo.flags and ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0

               val finalIsSystem = isSystem && !isUpdatedSystem

               appList.add(
                   AllAppsModel(
                       appName = pm.getApplicationLabel(appInfo).toString(),
                       packageName = appInfo.packageName,
                       icon = pm.getApplicationIcon(appInfo),
                       versionName = packageInfo.versionName ?: "",
                       /*apkPath = appInfo.sourceDir,
                       size = appSize,*/
                       isSystemApp = finalIsSystem
                   )
               )
           }

           appList.sortedBy { it.appName.lowercase() }
       }

   suspend fun getSystemApps(context: Context): List<AllAppsModel> =
       withContext(Dispatchers.IO) {

           val pm = context.packageManager
           val apps = pm.getInstalledApplications(PackageManager.GET_META_DATA)

           val systemApps = mutableListOf<AllAppsModel>()

           apps.forEach { appInfo ->

               val isSystem =
                   (appInfo.flags and ApplicationInfo.FLAG_SYSTEM) != 0

               val isUpdatedSystem =
                   (appInfo.flags and ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0

               // Pure system apps only
               if (isSystem && !isUpdatedSystem) {

                   val packageInfo =
                       pm.getPackageInfo(appInfo.packageName, 0)

                   val apkFile = File(appInfo.sourceDir)
                   val size = if (apkFile.exists()) apkFile.length() else 0L

                   systemApps.add(
                       AllAppsModel(
                           appName = pm.getApplicationLabel(appInfo).toString(),
                           packageName = appInfo.packageName,
                           icon = pm.getApplicationIcon(appInfo),
                           versionName = packageInfo.versionName ?: "",
                           /*   apkPath = appInfo.sourceDir,
                              size = size,*/
                           isSystemApp = true
                       )
                   )
               }
           }

           systemApps.sortedBy { it.appName.lowercase() }
       }


}

AllAppsAdapter is a RecyclerView Adapter used to display APK files and installed/system apps.
It stores a list of AllAppsModel and binds app data using ViewBinding (AppsDesignBinding).

class AllAppsAdapter : RecyclerView.Adapter<AllAppsAdapter.AppsViewHolder>() {

   private var allAppsList: ArrayList<AllAppsModel> = ArrayList()

   override fun onCreateViewHolder(
       parent: ViewGroup,
       viewType: Int
   ): AppsViewHolder {
       val binding = AppsDesignBinding.inflate(LayoutInflater.from(parent.context), parent, false)
       return AppsViewHolder(binding)
   }

   override fun onBindViewHolder(
       holder: AppsViewHolder,
       position: Int
   ) {
       val itemData = allAppsList[position]
       holder.setData(itemData)
   }

   override fun getItemCount(): Int {
       return allAppsList.size
   }

   fun addAll(fileList: ArrayList<AllAppsModel>) {
       this.allAppsList = ArrayList()
       this.allAppsList.addAll(fileList)
       notifyDataSetChanged()
   }

   class AppsViewHolder(val binding: AppsDesignBinding) : RecyclerView.ViewHolder(binding.root) {
       fun setData(itemData: AllAppsModel) {
           binding.tvAppName.text = itemData.appName
//            Glide.with(binding.ivImage.context).load(itemData.uri).into(binding.ivImage)
       }
   }
}

This File Manager app is built using a clean and structured architecture with Activities, Adapters, and Data Models. It uses MediaStore to fetch images, videos, audio, documents, and APK files along with their count and total storage size. Installed and system apps are retrieved using PackageManager with proper filtering logic. RecyclerView with GridLayoutManager is used to display categories, media files, and apps efficiently. Coroutines with Dispatchers.IO ensure background processing for smooth performance. Overall, the implementation is modern, organized, and suitable for a functional Android File Manager application.

Android MVVM, Dagger Hilt & Room Database with Local Storage

Devika Android — Mon, 16 Mar 2026 10:16:24 +0000

📱 Android App Project with MVVM, Dagger Hilt, and Room Database
This Android project is built using modern Android development practices, leveraging the MVVM (Model-View-ViewModel) architectural pattern. It incorporates Dagger Hilt for efficient and scalable dependency injection and Room Database for local data storage and persistence.
🔧 Key Technologies Used:
MVVM Architecture: Ensures a clean separation of concerns, making the codebase more modular, testable, and maintainable.
Dagger Hilt: Simplifies dependency injection in Android by providing a standard way to manage app-level dependencies.
Room Database: Provides an abstraction layer over SQLite to allow robust database access while maintaining compile-time verification of SQL queries.
✅ Project Goals:
Implement a clean and scalable architecture for Android applications.
Use dependency injection to reduce boilerplate code and improve testability.
Store and manage structured local data using Room with LiveData and Coroutines support.
This project serves as a foundation for building efficient, scalable, and maintainable Android applications using best practices and modern tools recommended by Google.

Gradle Dependencies

  //UI size
   implementation("com.intuit.sdp:sdp-android:1.1.1")

   //API Calling(Retrofit)
   implementation("com.squareup.retrofit2:retrofit:2.9.0")
   implementation("com.squareup.retrofit2:converter-gson:2.9.0")
   implementation("com.squareup.okhttp3:logging-interceptor:4.12.0")


   //Dagger Hilt
   implementation("com.google.dagger:hilt-android:2.51.1")
   kapt("com.google.dagger:hilt-android-compiler:2.51.1")


   //lifeCycleScopes
   implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7")
   implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.7")


   //for viewModels()
   implementation("androidx.navigation:navigation-fragment-ktx:2.5.3")

   //Glide
   implementation("com.github.bumptech.glide:glide:4.16.0")
//Room Database
val room_version = "2.6.1"
   implementation("androidx.room:room-runtime:$room_version")
   implementation("androidx.room:room-ktx:$room_version")
   kapt("androidx.room:room-compiler:$room_version")

// Allow references to generated code
kapt {
   correctErrorTypes = true
}
plugins {
   id("com.android.application")
   id("org.jetbrains.kotlin.android")
   id("kotlin-kapt")
   id("com.google.dagger.hilt.android")
   id("kotlin-android")
}

id("com.google.dagger.hilt.android") version "2.51.1" apply false

Create Application class with @HiltAndroid App Annotation

@HiltAndroidApp
class ApplicationClass : Application() {

}
Create AppModule for Singleton Objects
@Module
@InstallIn(SingletonComponent::class)
class AppModule {

   @Provides
   fun provideApiClient(): Retrofit {

       val loggingInterceptor = HttpLoggingInterceptor().apply {
           level = HttpLoggingInterceptor.Level.BODY
       }
       val okHttpClient: OkHttpClient = OkHttpClient.Builder()
           .addInterceptor(loggingInterceptor)
           .addInterceptor(Interceptor { chain ->
               val request = chain.request().newBuilder()
               request.header("Content-Type", "application/json")
               request.header(
                   "Authorization",
                   "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjozMDgsIm1vYmlsZV9ubyI6Ijk2NjI0NDU1NzMiLCJlbWFpbF9pZCI6InRlc3R3b3MwQGdtYWlsLmNvbSIsImNvdW50cnlfaWQiOjEsInJvbGVfbmFtZSI6ImJ1eWVyIiwic2VsbGVyX2lkIjoxODUsImJ1eWVyX2lkIjoxNTgsIm5hbWUiOiJLZWxzZXkgSmFja3Nvbm4iLCJ0eXBlIjoibG9naW4iLCJpYXQiOjE3NDMxMzY3MTAsImV4cCI6MTc3NDY3MjcxMH0.z8vmQiXUupZvyu-QM0vWCbsCS7846fBBeWRgYFUZVDU"
               )
               chain.proceed(request.build())
           }).build()

       return Retrofit.Builder()
           .baseUrl(Constance.BASEURL)
           .client(okHttpClient)
           .addConverterFactory(GsonConverterFactory.create())
           .build()
   }

   @Provides
   fun provideApiService(retrofit: Retrofit): ApiService {
       return retrofit.create(ApiService::class.java)
   }

   @Provides
   fun provideDatabase(@ApplicationContext context: Context): MyDatabase {
       return Room.databaseBuilder(context, MyDatabase::class.java, Constance.DBNAME).build()
   }

   @Provides
   fun provideContext(@ApplicationContext context: Context): Context {
       return context
   }

}

Create View Models with hiltViewModel

@HiltViewModel
class HomeViewModel @Inject constructor(
   private val context: Application,
   private val repository: HomeRepository,
   private val myDatabase: MyDatabase
) : AndroidViewModel(context) {
   private var _dishesList: MutableLiveData<Resource<List<GetDishes.ResponseData.Dish>>> =
       MutableLiveData()
   val dishesList: LiveData<Resource<List<GetDishes.ResponseData.Dish>>> = _dishesList

   fun fetchDishes(hashMap: HashMap<String, Any>) {
       viewModelScope.launch(Dispatchers.IO) {
           _dishesList.postValue(Resource.Loading())
           repository.getAllDishes(hashMap).data?.responseData?.dishes?.let {
               _dishesList.postValue(Resource.Success(it))
               myDatabase.dishDao().insertDishes(it)
           }
       }
   }

}

Create a Repository for Data Fetch to the server

class HomeRepository @Inject constructor(private val apiService: ApiService) {

   suspend fun getAllDishes(dishDetails: HashMap<String, Any>): Resource<GetDishes> {

       return try {
           val response = apiService.getDishes(dishDetails)
           if (response.isSuccessful && response.body() != null) {
               Resource.Success(response.body()!!)
           } else {
               Resource.Error("${Constance.APIERROR}  ${response.code()}")
           }

       } catch (e: Exception) {
           Resource.Error("${Constance.APIERROR}  ${e.localizedMessage}")
       }
   }

}

Create Api Interface For api calling

interface ApiService {

   @POST("get-dishes")
   suspend fun getDishes(@Body dishObject: HashMap<String, Any>): Response<GetDishes>

}

Create Room Database ( DAO, Database, DataModelclass & TypeConverter

@Dao
interface DishesDAO {
   @Insert(onConflict = OnConflictStrategy.REPLACE)
   suspend fun insertDishes(dishesData: List<GetDishes.ResponseData.Dish>)

   @Query("UPDATE Dishes SET  isFavorite=:isFavorite WHERE itemId=:id")
   suspend fun updateDish(id: Int, isFavorite: Boolean)

   @Query("SELECT * FROM dishes")
   fun getAllDishes(): LiveData<List<GetDishes.ResponseData.Dish>>

   @Query("SELECT * FROM dishes")
   suspend fun getAllDishesList(): List<GetDishes.ResponseData.Dish>

}
@Database(entities = [GetDishes.ResponseData.Dish::class], version = 6, exportSchema = false)
@TypeConverters(
   FoodItemAvailableTimeTypeConverter::class,
   CartTypeConverter::class,
   FoodImageTypeConverter::class,
   FoodItemVariantTypeConverter::class,
   FoodSellerTypeConverter::class,
   FoodSellerAvailableDayConverter::class
)
abstract class MyDatabase : RoomDatabase() {
   abstract fun dishDao(): DishesDAO
}
class FoodItemAvailableTimeTypeConverter {
   @TypeConverter
   fun fromList(value: List<GetDishes.ResponseData.Dish.FoodItemAvailableTime>): String {
       return Gson().toJson(value)
   }

   @TypeConverter
   fun toList(value: String): List<GetDishes.ResponseData.Dish.FoodItemAvailableTime> {
       val type =
           object : TypeToken<List<GetDishes.ResponseData.Dish.FoodItemAvailableTime>>() {}.type
       return Gson().fromJson(value, type)
   }
}

class CartTypeConverter {
   @TypeConverter
   fun fromCart(value: GetDishes.ResponseData.Dish.Cart): String {
       return Gson().toJson(value)
   }

   @TypeConverter
   fun toCart(value: String): GetDishes.ResponseData.Dish.Cart {
       return Gson().fromJson(value, GetDishes.ResponseData.Dish.Cart::class.java)
   }
}

class FoodImageTypeConverter {
   private val gson = Gson()

   @TypeConverter
   fun fromFoodImageList(value: List<GetDishes.ResponseData.Dish.FoodItemImage>?): String {
       return gson.toJson(value) // Convert list to JSON
   }

   @TypeConverter
   fun toFoodImageList(value: String?): List<GetDishes.ResponseData.Dish.FoodItemImage>? {
       if (value == null) return emptyList()
       val type = object : TypeToken<List<GetDishes.ResponseData.Dish.FoodItemImage>>() {}.type
       return gson.fromJson(value, type) // Convert JSON back to list
   }
}

class FoodItemVariantTypeConverter {

   @TypeConverter
   fun fromFoodItemVariantList(value: List<GetDishes.ResponseData.Dish.FoodItemVariant>): String {
       return Gson().toJson(value)
   }

   @TypeConverter
   fun toFoodItemVariantList(value: String): List<GetDishes.ResponseData.Dish.FoodItemVariant> {
       val type = object : TypeToken<List<GetDishes.ResponseData.Dish.FoodItemVariant>>() {}.type
       return Gson().fromJson(value, type)
   }
}

class FoodSellerTypeConverter {

   @TypeConverter
   fun fromFoodSeller(value: GetDishes.ResponseData.Dish.FoodSeller): String {
       return Gson().toJson(value)
   }

   @TypeConverter
   fun toFoodSeller(value: String): GetDishes.ResponseData.Dish.FoodSeller {
       return Gson().fromJson(value, GetDishes.ResponseData.Dish.FoodSeller::class.java)
   }
}

class FoodSellerAvailableDayConverter {
   @TypeConverter
   fun fromFoodSellerAvailableDayList(value: List<GetDishes.ResponseData.Dish.FoodSeller.FoodSellerAvailableDay>): String {
       return Gson().toJson(value)
   }

   @TypeConverter
   fun toFoodSellerAvailableDayList(value: String): List<GetDishes.ResponseData.Dish.FoodSeller.FoodSellerAvailableDay> {
       val type = object :
           TypeToken<List<GetDishes.ResponseData.Dish.FoodSeller.FoodSellerAvailableDay>>() {}.type
       return Gson().fromJson(value, type)
   }
}
data class GetDishes(
   @SerializedName("ResponseData")
   @Expose
   var responseData: ResponseData,
   @SerializedName("ResponseStatus")
   @Expose
   var responseStatus: Int,
   @SerializedName("ResponseText")
   @Expose
   var responseText: String,
   @SerializedName("status")
   @Expose
   var status: Int,
   @SerializedName("success")
   @Expose
   var success: Boolean
) {
   data class ResponseData(
       @SerializedName("count")
       @Expose
       var count: Int,
       @SerializedName("dishes")
       @Expose
       var dishes: List<Dish>
   ) {
       @Entity(tableName = "Dishes")
       data class Dish(
           @SerializedName("accept_advance_order")
           @Expose
           var acceptAdvanceOrder: Int? = 0,
           @SerializedName("advance_order_time_span")
           @Expose
           var advanceOrderTimeSpan: String? = null,
           @SerializedName("apply_gst")
           @Expose
           var applyGst: Int? = null,
           @SerializedName("available_dishes")
           @Expose
           var availableDishes: Int? = null,
           @SerializedName("cart")
           @Expose
           @TypeConverters(CartTypeConverter::class)
           var cart: Cart? = null,
           @SerializedName("category_id")
           @Expose
           var categoryId: Int? = null,
           @SerializedName("created_date")
           @Expose
           var createdDate: String? = null,
           @SerializedName("currency")
           @Expose
           var currency: String? = null,
           @SerializedName("description")
           @Expose
           var description: String? = null,
           /*@SerializedName("discount_expires_in")
           @Expose
           var discountExpiresIn: Any,*/
           @SerializedName("discount_percent")
           @Expose
           var discountPercent: Int? = 0,
           /*@SerializedName("discount_validity")
           @Expose
           var discountValidity: Any,*/
           @SerializedName("dish_type")
           @Expose
           var dishType: String? = "",
           @SerializedName("distance")
           @Expose
           var distance: Double? = 0.0,
           @SerializedName("food_item_available_times")
           @Expose
           @TypeConverters(FoodItemAvailableTimeTypeConverter::class)
           var foodItemAvailableTimes: List<FoodItemAvailableTime>? = null,
           @SerializedName("food_item_images")
           @Expose
           @TypeConverters(FoodImageTypeConverter::class)
           var foodItemImages: List<FoodItemImage>? = null,
           @SerializedName("food_item_variants")
           @Expose
           @TypeConverters(FoodItemVariantTypeConverter::class)
           var foodItemVariants: List<FoodItemVariant>? = null,
           @SerializedName("food_seller")
           @Expose
           @TypeConverters(FoodSellerTypeConverter::class)
           var foodSeller: FoodSeller? = null,
           @SerializedName("gst")
           @Expose
           var gst: String? = "",
           @SerializedName("gst_type")
           @Expose
           var gstType: String? = "",
           @SerializedName("is_available")
           @Expose
           var isAvailable: Int? = 0,
           @SerializedName("is_favorite")
           @Expose
           var isFavorite: Boolean? = false,
           @SerializedName("is_recommended")
           @Expose
           var isRecommended: Int? = 0,

           @SerializedName("item_id")
           @Expose
           @PrimaryKey(autoGenerate = false)
           var itemId: Int = 0,

           @SerializedName("item_name")
           @Expose
           var itemName: String? = "",
           @SerializedName("make_to_order_time")
           @Expose
           var makeToOrderTime: String? = null,
           /* @SerializedName("packing_charges")
            @Expose
            var packingCharges: Any,*/
           @SerializedName("price")
           @Expose
           var price: Int? = null,
           @SerializedName("rating")
           @Expose
           var rating: Double? = null,
           @SerializedName("sameDayOrder")
           @Expose
           var sameDayOrder: Boolean? = null,
           @SerializedName("seller_id")
           @Expose
           var sellerId: Int? = null,
           @SerializedName("sold_dishes")
           @Expose
           @Nullable
           var soldDishes: Int? = null,
           @SerializedName("sub_category_id")
           @Expose
           var subCategoryId: Int? = null,
           @SerializedName("total_reviews")
           @Expose
           var totalReviews: Int? = null,
           @SerializedName("traveling_time")
           @Expose
           var travelingTime: Double? = 0.0,
           @SerializedName("weight")
           @Expose
           var weight: String? = ""
       ) {
           data class Cart(
               @SerializedName("is_cart_item")
               @Expose
               var isCartItem: Boolean? = false,
               @SerializedName("quantity")
               @Expose
               var quantity: Int? = 0
           )

           data class FoodItemAvailableTime(
               @SerializedName("from_time")
               @Expose
               var fromTime: String? = "",
               @SerializedName("time")
               @Expose
               var time: String? = "",
               @SerializedName("to_time")
               @Expose
               var toTime: String? = ""
           )

           data class FoodItemImage(
               @SerializedName("image_url")
               @Expose
               var imageUrl: String? = ""
           )

           data class FoodItemVariant(
               @SerializedName("available_dishes")
               @Expose
               var availableDishes: Int? = 0,
               /*@SerializedName("discount_expires_in")
               @Expose
               var discountExpiresIn: Any,*/
               @SerializedName("discount_percent")
               @Expose
               var discountPercent: Int? = 0,
               @SerializedName("item_id")
               @Expose
               var itemId: Int? = 0,
               @SerializedName("max_dishes_per_day")
               @Expose
               var maxDishesPerDay: Int? = 0,
               /*@SerializedName("packing_charges")
               @Expose
               var packingCharges: Any,*/
               @SerializedName("price")
               @Expose
               var price: Int? = 0,
               @SerializedName("variant_id")
               @Expose
               var variantId: Int? = 0,
               @SerializedName("weight")
               @Expose
               var weight: String? = ""
           )

           data class FoodSeller(
               @SerializedName("accept_orders")
               @Expose
               var acceptOrders: Int? = 0,
               @SerializedName("business_name")
               @Expose
               var businessName: String? = "",
               @SerializedName("food_seller_available_days")
               @Expose
               @TypeConverters(FoodSellerAvailableDay::class)
               var foodSellerAvailableDays: List<FoodSellerAvailableDay>? = null,
               @SerializedName("is_active")
               @Expose
               var isActive: Int? = 0,
               @SerializedName("lattitude")
               @Expose
               var lattitude: String? = "",
               @SerializedName("longitude")
               @Expose
               var longitude: String? = "",
               @SerializedName("seller_id")
               @Expose
               var sellerId: Int? = 0,
               @SerializedName("seller_type")
               @Expose
               var sellerType: String? = "",
               @SerializedName("type_of_food")
               @Expose
               var typeOfFood: String? = "",
               @SerializedName("user_id")
               @Expose
               var userId: Int? = 0
           ) {
               data class FoodSellerAvailableDay(
                   @SerializedName("day_name")
                   @Expose
                   var dayName: String? = "",
                   @SerializedName("food_seller_available_times")
                   @Expose
                   var foodSellerAvailableTimes: List<FoodSellerAvailableTime>? = null,
                   @SerializedName("id")
                   @Expose
                   var id: Int? = 0,
                   @SerializedName("seller_id")
                   @Expose
                   var sellerId: Int? = 0,
                   @SerializedName("status")
                   @Expose
                   var status: Boolean? = false
               ) {
                   data class FoodSellerAvailableTime(
                       @SerializedName("day_id")
                       @Expose
                       var dayId: Int? = 0,
                       @SerializedName("from_time")
                       @Expose
                       var fromTime: String? = "",
                       @SerializedName("id")
                       @Expose
                       var id: Int? = 0,
                       @SerializedName("seller_id")
                       @Expose
                       var sellerId: Int? = 0,
                       @SerializedName("status")
                       @Expose
                       var status: Boolean? = false,
                       @SerializedName("to_time")
                       @Expose
                       var toTime: String? = ""
                   )
               }
           }
       }
   }
}

How to load Fragments: Hide Show

fun showFragment(fragment: Fragment, tag: String, shouldRefresh: Boolean = false): Boolean {
       val transaction = fragmentManager.beginTransaction()
       val existingFragment = fragmentManager.findFragmentByTag(tag)

       if (existingFragment != null) {
           if (shouldRefresh) {
               existingFragment.arguments = fragment.arguments // Update arguments
               if (existingFragment is Refreshable) {
                   existingFragment.refreshData() // Ensure data is refreshed
               }
           }
           transaction.show(existingFragment)
           fragmentManager.popBackStack(tag, 0) // Bring to top
       } else {
           transaction.add(binding.flContainer.id, fragment, tag)
//            transaction.addToBackStack(tag)
       }

       fragmentManager.fragments.forEach {
           if (it != existingFragment && it.isAdded) {
               transaction.hide(it)
           }
       }

       transaction.commitAllowingStateLoss()
       return true
   }

Android RecyclerView Pagination


class MainActivity : AppCompatActivity() {

   private lateinit var adapter: ItemAdapter
   private var isLoading = false
   private var currentPage = 1
   private val pageSize = 20
   private var isLastPage = false

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)

       val recyclerView = findViewById<RecyclerView>(R.id.recyclerView)
       adapter = ItemAdapter(mutableListOf())
       recyclerView.adapter = adapter
       recyclerView.layoutManager = LinearLayoutManager(this)

       loadItems()

       recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
           override fun onScrolled(rv: RecyclerView, dx: Int, dy: Int) {
               super.onScrolled(rv, dx, dy)
               val layoutManager = rv.layoutManager as LinearLayoutManager
               val totalItemCount = layoutManager.itemCount
               val lastVisible = layoutManager.findLastVisibleItemPosition()

               if (!isLoading && !isLastPage && lastVisible + 5 >= totalItemCount) {
                   loadItems()
               }
           }
       })
   }

   private fun loadItems() {
       isLoading = true
       lifecycleScope.launch {
           try {
               val response = RetrofitClient.api.getItems(currentPage, pageSize)
               if (response.isSuccessful) {
                   val itemResponse = response.body()
                   val items = itemResponse?.data ?: emptyList()

                   adapter.addItems(items)
                   currentPage++
                   isLastPage = items.size < pageSize
               } else {
                   Log.e("API_ERROR", "Failed: ${response.message()}")
               }
           } catch (e: Exception) {
               Log.e("API_ERROR", "Exception: ${e.message}")
           } finally {
               isLoading = false
           }
       }
   }
}

🚀 Final Words
With MVVM architecture, Dagger Hilt, and Room Database working together, this project is set up for performance, scalability, and maintainability. From clean code to powerful architecture, everything is in place.
Now it’s all ready to go —
This project is going to run like a charm! 💥
Let’s build something amazing. 😎

📱 Android Bottom Navigation Style Fragment Switching (Without Navigation Component)

Devika Android — Mon, 16 Mar 2026 10:08:31 +0000

✅ Advantages of This Approach
✔️ Single Activity Architecture
✔️ No Fragment Recreation
✔️ Fast UI Switching
✔️ Back Press Controlled
✔️ Clean & Scalable Code

class MainActivity : AppCompatActivity(), OnClickHandler {
   private lateinit var binding: ActivityMainBinding
   private lateinit var homeFragment: HomeFragment
   private lateinit var secondFragment: SecondFragment
   private lateinit var thirdFragment: ThirdFragment
   private lateinit var activeFragment: Fragment


   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       enableEdgeToEdge()
       binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
       ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
           val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
           v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
           insets
       }

       initView()
   }

   private fun initView() {
       binding.clickHandler = this

       homeFragment = HomeFragment()
       secondFragment = SecondFragment()
       thirdFragment = ThirdFragment()

       supportFragmentManager.beginTransaction().add(binding.llMainView.id, secondFragment)
           .hide(secondFragment)
           .add(binding.llMainView.id, thirdFragment).hide(thirdFragment)
           .add(binding.llMainView.id, homeFragment).commit()

       activeFragment = homeFragment
       handleBackPress()
   }

   private fun switchFragments(target: Fragment) {
       if (activeFragment == target) return
       supportFragmentManager.beginTransaction().hide(activeFragment).show(target).commit()
       activeFragment = target
   }

   private fun handleBackPress() {
       onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
           override fun handleOnBackPressed() {
               if (activeFragment !is HomeFragment) {
                   switchFragments(homeFragment)
               } else {
                   finish()
               }
           }

       })
   }

   override fun view(view: View) {
       when (view.id) {
           binding.llHome.id -> {
               switchFragments(homeFragment)
           }

           binding.llApiCalling.id -> {
               switchFragments(secondFragment)
           }

           binding.llDatabase.id -> {
               switchFragments(thirdFragment)
           }
       }
   }
}
<layout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools">

   <data>

       <variable
           name="clickHandler"
           type="com.example.androidbox.interfaces.OnClickHandler" />

   </data>

   <androidx.constraintlayout.widget.ConstraintLayout
       android:id="@+id/main"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       tools:context=".ui.activities.MainActivity">

       <LinearLayout
           android:id="@+id/ll_main_view"
           android:layout_width="match_parent"
           android:layout_height="0dp"
           android:orientation="vertical"
           app:layout_constraintBottom_toTopOf="@+id/ll_bottom_sheet"
           app:layout_constraintEnd_toEndOf="parent"
           app:layout_constraintStart_toStartOf="parent"
           app:layout_constraintTop_toTopOf="parent">

       </LinearLayout>

       <LinearLayout
           android:id="@+id/ll_bottom_sheet"
           android:layout_width="match_parent"
           android:layout_height="@dimen/_40sdp"
           android:gravity="center"
           android:orientation="horizontal"
           android:weightSum="3"
           app:layout_constraintBottom_toBottomOf="parent"
           app:layout_constraintEnd_toEndOf="parent"
           app:layout_constraintStart_toStartOf="parent"
           app:layout_constraintTop_toBottomOf="@+id/ll_main_view">

           <LinearLayout
               android:id="@+id/ll_home"
               android:layout_width="match_parent"
               android:layout_height="match_parent"
               android:layout_weight="1"
               android:onClick="@{(v) -> clickHandler.view(v)}"
               android:orientation="vertical">

               <TextView
                   android:layout_width="match_parent"
                   android:layout_height="match_parent"
                   android:gravity="center"
                   android:text="Home"
                   android:textColor="@color/black"
                   android:textStyle="bold" />

           </LinearLayout>

           <LinearLayout
               android:id="@+id/ll_api_calling"
               android:layout_width="match_parent"
               android:layout_height="match_parent"
               android:layout_weight="1"
               android:onClick="@{(v) -> clickHandler.view(v)}"
               android:orientation="vertical">

               <TextView
                   android:layout_width="match_parent"
                   android:layout_height="match_parent"
                   android:gravity="center"
                   android:text="Api Calling"
                   android:textColor="@color/black"
                   android:textStyle="bold" />

           </LinearLayout>

           <LinearLayout
               android:id="@+id/ll_database"
               android:layout_width="match_parent"
               android:layout_height="match_parent"
               android:layout_weight="1"
               android:onClick="@{(v) -> clickHandler.view(v)}"
               android:orientation="vertical">

               <TextView
                   android:layout_width="match_parent"
                   android:layout_height="match_parent"
                   android:gravity="center"
                   android:text="Database"
                   android:textColor="@color/black"
                   android:textStyle="bold" />

           </LinearLayout>


       </LinearLayout>

   </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

Agar aap Navigation Component ke bina ek lightweight, fast aur clean fragment system banana chahte ho, to ye approach production ready hai.
Pro Tip: Agar fragments heavy ho, to commitAllowingStateLoss() avoid karein aur state manually manage karein.

Filtered Adapter with MVVM Architere in Android Development

Devika Android — Mon, 16 Mar 2026 10:05:48 +0000

Implemented In-App Purchases (monthly & yearly subscription plans), integrated REST APIs, and built interactive maps and graph-based data visualizations to enhance user experience and functionality.

@AndroidEntryPoint
class ThirdFragment : Fragment() {
   lateinit var binding: FragmentThirdBinding

   private lateinit var viewModel: UserViewModel
   private lateinit var adapter: UserAdapter

   private var currentPage = 1
   private val limit = 10
   override fun onCreateView(
       inflater: LayoutInflater, container: ViewGroup?,
       savedInstanceState: Bundle?
   ): View {
       binding = FragmentThirdBinding.inflate(inflater, container, false)
       viewModel = ViewModelProvider(this)[UserViewModel::class.java]
       intiView()
       return binding.root
   }

   private fun intiView() {

       binding.etSearch.addTextChangedListener(object : TextWatcher {
           override fun afterTextChanged(s: Editable?) {
               adapter.filter(s.toString())
           }
           override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
           override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
       })


       binding.btnNext.setOnClickListener {
           currentPage++
           viewModel.loadPosts(currentPage, limit)
           Log.e("TAG", "intiView: $currentPage")
       }

       binding.btnPre.setOnClickListener {
           if (currentPage > 1) {
               currentPage--
               viewModel.loadPosts(currentPage, limit)
               Log.e("TAG", "intiView:iiii  $currentPage")
           }
       }

       adapter = UserAdapter()
       binding.rvData.adapter = adapter
       binding.rvData.layoutManager = LinearLayoutManager(requireActivity())

       observeData()
       viewModel.loadPosts(currentPage, limit)

   }


   private fun observeData() {

       viewModel.posts.observe(requireActivity()) {
           adapter.addAll(ArrayList(it))
       }
   }

}
class UserAdapter : RecyclerView.Adapter<UserAdapter.UserData>() {
   private var originalList: List<UserInfo> = emptyList()
   private var filteredList: MutableList<UserInfo> = mutableListOf()

   override fun onCreateViewHolder(
       parent: ViewGroup,
       viewType: Int
   ): UserData {
       val binding =
           UserListDesignBinding.inflate(LayoutInflater.from(parent.context), parent, false)
       return UserData(binding)
   }

   override fun onBindViewHolder(
       holder: UserData,
       position: Int
   ) {
       val itemData = filteredList[position]
       holder.setData(itemData)
   }

   override fun getItemCount(): Int {
       return filteredList.size
   }

   fun addAll(userList: ArrayList<UserInfo>) {
       this.originalList = ArrayList()
       this.filteredList = ArrayList()
       this.originalList = userList
       this.filteredList.addAll(userList)
       notifyDataSetChanged()
   }

   fun filter(query: String) {
       if (query.isEmpty()) {
           filteredList = originalList.toMutableList()
       } else {
           filteredList = originalList.filter {
               it.title.contains(query, ignoreCase = true)
           }.toMutableList()
       }
       notifyDataSetChanged()
   }

   class UserData(private val binding: UserListDesignBinding) :
       RecyclerView.ViewHolder(binding.root) {

       fun setData(data: UserInfo) {
           binding.tvTitle.text = data.title
           binding.tvDescription.text = data.body
           binding.tvId.text = "ID :- ${data.id}"
           binding.tvUserId.text = "UserID :- ${data.userId}"
       }

   }
}

using without Filter Function we can Filter all list in adapter.

Implementing All Ad Types in Android (Banner, Interstitial, Rewarded & Native)

Devika Android — Mon, 16 Mar 2026 09:59:55 +0000

In this blog, we will implement all major AdMob ad formats in an Android application:
Banner Ads
Interstitial Ads
Rewarded Ads
Native Ads

We will also understand how to properly control when and where ads should appear to avoid bad user experience and policy violations.

Create All Ad Units in AdMob

<string name="admob_app_id">ca-app-pub-3940256099942544~3347511713</string>
   <string name="banner_ad_unit_id">ca-app-pub-3940256099942544/6300978111</string>
   <string name="interstitial_ad_unit_id">ca-app-pub-3940256099942544/1033173712</string>
   <string name="reward_ad_unit_id">ca-app-pub-3940256099942544/5224354917</string>
   <string name="native_ad_unit_id">ca-app-pub-3940256099942544/2247696110</string>


    <meta-data
           android:name="com.google.android.gms.ads.APPLICATION_ID"
           android:value="@string/admob_app_id" />
   </application>

Implement Banner Ad

 <com.google.android.gms.ads.AdView
           android:id="@+id/adView"
           android:layout_width="match_parent"
           android:layout_height="wrap_content"
           ads:adSize="BANNER"
           ads:adUnitId="@string/banner_ad_unit_id" />
MobileAds.initialize(this)
       val adRequest = AdRequest.Builder().build()
       binding.adView.loadAd(adRequest)

       binding.adView.adListener = object : AdListener() {

           override fun onAdLoaded() {
               Log.d("Ads", "Banner Loaded")
           }

           override fun onAdFailedToLoad(error: LoadAdError) {
               Log.d("Ads", "Failed: ${error.message}")
           }
       }

Implement Interstitial, Rewarded & Native

object AdManager {

   private var interstitialAd: InterstitialAd? = null
   private var rewardedAd: RewardedAd? = null
   private var nativeAd: NativeAd? = null

   fun loadInterstitial(context: Context, adUnitId: String, onLoaded: () -> Unit) {

       val adRequest = AdRequest.Builder().build()

       InterstitialAd.load(
           context,
           adUnitId,
           adRequest,
           object : InterstitialAdLoadCallback() {

               override fun onAdLoaded(ad: InterstitialAd) {
                   interstitialAd = ad
                   onLoaded()
               }

               override fun onAdFailedToLoad(error: LoadAdError) {
                   interstitialAd = null
               }
           }
       )
   }

   fun showInterstitial(activity: Activity, onDismiss: () -> Unit) {

       interstitialAd?.let { ad ->

           ad.fullScreenContentCallback =
               object : FullScreenContentCallback() {

                   override fun onAdDismissedFullScreenContent() {
                       interstitialAd = null
                       onDismiss()
                   }
               }

           ad.show(activity)
       }
   }

   fun loadRewarded(
       context: Context,
       adUnitId: String,
       onLoaded: () -> Unit
   ) {

       val adRequest = AdRequest.Builder().build()

       RewardedAd.load(
           context,
           adUnitId,
           adRequest,
           object : RewardedAdLoadCallback() {

               override fun onAdLoaded(ad: RewardedAd) {
                   rewardedAd = ad
                   onLoaded()
               }

               override fun onAdFailedToLoad(error: LoadAdError) {
                   rewardedAd = null
               }
           }
       )
   }

   fun showRewarded(
       activity: Activity,
       onRewardEarned: (RewardItem) -> Unit,
       onDismiss: () -> Unit
   ) {

       rewardedAd?.let { ad ->

           ad.fullScreenContentCallback =
               object : FullScreenContentCallback() {

                   override fun onAdDismissedFullScreenContent() {
                       rewardedAd = null
                       onDismiss()
                   }

                   override fun onAdFailedToShowFullScreenContent(adError: AdError) {
                       rewardedAd = null
                       onDismiss()
                   }
               }

           ad.show(activity) { rewardItem ->
               onRewardEarned(rewardItem)
           }

       } ?: run {
           onDismiss()
       }
   }

   fun loadNativeAd(
       activity: Activity,
       adUnitId: String,
       container: ViewGroup
   ) {

       // Purana ad destroy karo
       nativeAd?.destroy()
       nativeAd = null

       val adLoader = AdLoader.Builder(activity, adUnitId)
           .forNativeAd { ad ->

               nativeAd = ad

               val binding = CustomeAdsDesignBinding.inflate(
                   LayoutInflater.from(activity),
                   container,
                   false
               )

               binding.nativeAdView.headlineView = binding.adHeadline
               binding.nativeAdView.bodyView = binding.adBody
               binding.nativeAdView.callToActionView = binding.adCallToAction
               binding.nativeAdView.iconView = binding.ivAds

               // Set Data
               binding.adHeadline.text = ad.headline
               binding.adBody.text = ad.body
               binding.adCallToAction.text = ad.callToAction

               ad.icon?.let {
                   binding.ivAds.setImageDrawable(it.drawable)
                   binding.ivAds.visibility = View.VISIBLE
               } ?: run {
                   binding.ivAds.visibility = View.GONE
               }

               // VERY IMPORTANT
               binding.nativeAdView.setNativeAd(ad)

               container.removeAllViews()
               container.addView(binding.root)
           }
           .withAdListener(object : AdListener() {
               override fun onAdFailedToLoad(error: LoadAdError) {
                   container.removeAllViews()
               }
           })
           .build()

       adLoader.loadAd(AdRequest.Builder().build())
   }

   fun destroyNative() {
       nativeAd?.destroy()
       nativeAd = null
   }

}

Create CustomeAdsDesignBinding

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto">

   <data>

   </data>

   <androidx.cardview.widget.CardView
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:layout_margin="@dimen/_5sdp"
       app:cardCornerRadius="@dimen/_10sdp"
       app:cardElevation="@dimen/_5sdp">

       <com.google.android.gms.ads.nativead.NativeAdView
           android:id="@+id/native_ad_view"
           android:layout_width="match_parent"
           android:layout_height="match_parent">

           <LinearLayout
               android:layout_width="match_parent"
               android:layout_height="wrap_content"
               android:layout_gravity="center"
               android:gravity="center"
               android:orientation="vertical">

               <ImageView
                   android:id="@+id/iv_ads"
                   android:layout_width="wrap_content"
                   android:layout_height="wrap_content"
                   android:scaleType="fitXY" />

               <TextView
                   android:id="@+id/adHeadline"
                   android:layout_width="wrap_content"
                   android:layout_height="wrap_content"
                   android:textColor="@android:color/black"
                   android:textSize="16sp"
                   android:textStyle="bold" />

               <TextView
                   android:id="@+id/adBody"
                   android:layout_width="wrap_content"
                   android:layout_height="wrap_content"
                   android:textColor="@android:color/darker_gray"
                   android:textSize="14sp" />

               <Button
                   android:id="@+id/adCallToAction"
                   android:layout_width="wrap_content"
                   android:layout_height="wrap_content"
                   android:text="Install" />

           </LinearLayout>


       </com.google.android.gms.ads.nativead.NativeAdView>

   </androidx.cardview.widget.CardView>


</layout>

Load All Ads in Activity

class AdsActivity : AppCompatActivity() {
   lateinit var binding: ActivityAdsBinding
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       enableEdgeToEdge()
       binding = DataBindingUtil.setContentView(this, R.layout.activity_ads)
       ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
           val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
           v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
           insets
       }
       initView()
   }

   private fun initView() {
       MobileAds.initialize(this)
       val adRequest = AdRequest.Builder().build()
       binding.adView.loadAd(adRequest)

       binding.adView.adListener = object : AdListener() {

           override fun onAdLoaded() {
               Log.d("Ads", "Banner Loaded")
           }

           override fun onAdFailedToLoad(error: LoadAdError) {
               Log.d("Ads", "Failed: ${error.message}")
           }
       }


       //**{Interstitial Ads}**\\

       binding.btnInterstitialLoadAds.isEnabled = false
       binding.btnInterstitialLoadAds.alpha = 0.5f

       // Load first time
       AdManager.loadInterstitial(
           this,
           getString(R.string.interstitial_ad_unit_id)
       ) {
           binding.btnInterstitialLoadAds.isEnabled = true
           binding.btnInterstitialLoadAds.alpha = 1f
       }

       binding.btnInterstitialLoadAds.setOnClickListener {

           binding.btnInterstitialLoadAds.isEnabled = false
           binding.btnInterstitialLoadAds.alpha = 0.5f

           AdManager.showInterstitial(this) {

               // After dismiss → preload next ad
               AdManager.loadInterstitial(
                   this,
                   getString(R.string.interstitial_ad_unit_id)
               ) {
                   binding.btnInterstitialLoadAds.isEnabled = true
                   binding.btnInterstitialLoadAds.alpha = 1f
               }
           }
       }

       //**{Reward Ads}**\\
       AdManager.loadRewarded(
           this,
           getString(R.string.reward_ad_unit_id)
       ) {
           binding.btnRewardedLoadAds.isEnabled = true
           binding.btnRewardedLoadAds.alpha = 1f
       }

       binding.btnRewardedLoadAds.setOnClickListener {

           binding.btnRewardedLoadAds.isEnabled = false
           binding.btnRewardedLoadAds.alpha = 0.5f

           AdManager.showRewarded(
               this,
               onRewardEarned = { rewardItem ->

                   val amount = rewardItem.amount
                   val type = rewardItem.type

                   Toast.makeText(this, "Earned $amount $type", Toast.LENGTH_SHORT).show()
               },
               onDismiss = {

                   // Preload next rewarded ad
                   AdManager.loadRewarded(
                       this,
                       getString(R.string.reward_ad_unit_id)
                   ) {
                       binding.btnRewardedLoadAds.isEnabled = true
                       binding.btnRewardedLoadAds.alpha = 1f
                   }
               }
           )
       }



       AdManager.loadNativeAd(
           this,
           getString(R.string.native_ad_unit_id),
           binding.flContainer
       )

   }

   override fun onResume() {
       super.onResume()
       AdManager.destroyNative()
   }
}

📌 Conclusion
Implementing all ad formats correctly helps maximize revenue while maintaining good UX. A well-structured ad strategy can significantly improve both user retention and earnings.