<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Mubashshir Khan on Medium]]></title>
        <description><![CDATA[Stories by Mubashshir Khan on Medium]]></description>
        <link>https://medium.com/@khanmubashshir08?source=rss-3f4cd0cd7d3e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*h6t34z3xELesBSJH8ubytQ.jpeg</url>
            <title>Stories by Mubashshir Khan on Medium</title>
            <link>https://medium.com/@khanmubashshir08?source=rss-3f4cd0cd7d3e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 00:44:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@khanmubashshir08/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How We Slashed Our Android App Size by 40% (25MB to 15MB) in 2026]]></title>
            <link>https://medium.com/@khanmubashshir08/how-we-slashed-our-android-app-size-by-40-25mb-to-15mb-in-2026-f2369551665e?source=rss-3f4cd0cd7d3e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f2369551665e</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[app-performance]]></category>
            <category><![CDATA[apklance]]></category>
            <category><![CDATA[mobile-development]]></category>
            <category><![CDATA[anroid-app-development]]></category>
            <dc:creator><![CDATA[Mubashshir Khan]]></dc:creator>
            <pubDate>Sun, 30 Aug 2026 18:20:26 GMT</pubDate>
            <atom:updated>2026-08-30T18:20:26.604Z</atom:updated>
            <content:encoded><![CDATA[<p>In modern Android development, shipping a bloated APK or App Bundle is a silent killer for user acquisition. Users on data-restricted plans or limited storage devices abandon heavy applications before they even finish downloading. Recently, we optimized our production Android app, shrinking our bundle size from a hefty <strong>25MB down to 15MB — a clean 40% reduction</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*_dSHauLlHMJ0MmyCkk0d5w.png" /></figure><h3>Real-World Proof</h3><p>Here is the exact milestone we shared with the developer community after shipping the update to the Google Play Store:</p><blockquote><strong><em>LinkedIn Announcement:</em></strong><em> </em>“Just dropped our Android app size on the Google Play Store by 40% (25MB down to 15MB) using R8 code shrinking and optimization!”</blockquote><blockquote><em>— </em><a href="https://www.linkedin.com/feed/update/urn:li:activity:7498235287928643584/"><strong>View my Linkedin post</strong></a></blockquote><p><strong>Before vs. After Optimization Metrics:</strong></p><ul><li><strong>Before:</strong> 25 MB <em>(Google Play Store download bundle / heavier initial footprint)</em></li><li><strong>After:</strong> 15 MB (<strong>40% reduction</strong> / lean production release)</li></ul><p>Here is the exact step-by-step playbook we used to achieve this milestone using modern tooling, asset strategies, and R8 optimization.</p><h3>1. Ditch Vector Drawables for Centralized Icon Dependencies</h3><p>Historically, storing dozens of individual XML vector drawables in res/drawable bloats your compilation index and directory metadata. In modern Android development, it&#39;s far more efficient to use a curated vector icon library dependency (such as Compose Material Icons Extended or specialized icon packs) or a single shared symbol font/dependency.</p><p>Even better, avoid injecting raw XML files directly into the project hierarchy. Instead, pull icons through version-controlled dependencies where only the symbols you explicitly call are packaged.</p><h3>2. Initialize All Icons Globally in a Central Registry</h3><p>To prevent duplicate object initializations, scattered references, and messy code, we created a single centralized singleton/object registry inside our design system module. Instead of invoking scattered drawable resource IDs (R.drawable.ic_...) across hundreds of UI files, all icons are mapped cleanly in one place:</p><pre>object AppIcons {<br>    val Home = Icons.Rounded.Home<br>    val Settings = Icons.Rounded.Settings<br>    val Profile = Icons.Rounded.Person<br>    val Notification = Icons.Rounded.Notifications<br>}</pre><p>By routing all icon components through this global lookup layer, we maintain a single source of truth, enforce consistency across screens, and dramatically simplify refactoring.</p><h3>3. Pre-compress and Resize PNG/JPG Assets</h3><p>Bitmaps remain a major source of unnecessary weight. Before adding any raster assets (PNG/JPEG) into res/drawable or res/mipmap:</p><ul><li>Run images through advanced compression tools (e.g., WebP conversion or tools like TinyPNG/Guetzli).</li><li>Provide correct densities (xxhdpi, xxxhdpi) and leverage modern WebP lossless formats where transparency is required.</li><li>Never embed raw 4K marketing mockups or oversized assets into client bundles.</li></ul><h3>4. Enable R8 Code Shrinking, Resource Shrinking, &amp; Obfuscation</h3><p>The single most impactful architectural lever for saving bytes is turning on <strong>R8</strong> with full shrinking and obfuscation enabled in your module-level build.gradle.kts file:</p><pre>android {<br>    buildTypes {<br>        release {<br>            isMinifyEnabled = true<br>            isShrinkResources = true<br>            proguardFiles(<br>                getDefaultProguardFile(&quot;proguard-android-optimize.txt&quot;),<br>                &quot;proguard-rules.pro&quot;<br>            )<br>        }<br>    }<br>}</pre><p>R8 strips out dead code, unused library methods, unreferenced color tokens, and metadata remnants from third-party SDKs, compounding the storage savings instantly.</p><blockquote><strong><em>Key Takeaway:</em></strong><em> Combining asset hygiene (switching to dependency icons &amp; compressed formats) with aggressive R8 bytecode optimization creates a compounding reduction effect, dropping our final production footprint down by 10 full megabytes.</em></blockquote><h3>Conclusion</h3><p>App size reduction isn’t a one-time chore; it’s a discipline. By centralizing icons, auditing raw graphic files, and fully utilizing R8 compiler optimization, you protect user data limits and boost installation conversion rates on Google Play.</p><p>#AndroidDev #MobileDevelopment #Kotlin #AppPerformance #SoftwareEngineering #TechOptimization #GoogleR8</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f2369551665e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Enum Classes, Sealed Classes, and Sealed Interfaces in Kotlin]]></title>
            <link>https://medium.com/@khanmubashshir08/understanding-enum-classes-sealed-classes-and-sealed-interfaces-in-kotlin-457527c76269?source=rss-3f4cd0cd7d3e------2</link>
            <guid isPermaLink="false">https://medium.com/p/457527c76269</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[kotlin-features]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Mubashshir Khan]]></dc:creator>
            <pubDate>Tue, 11 Nov 2025 09:13:32 GMT</pubDate>
            <atom:updated>2025-11-11T09:32:21.015Z</atom:updated>
            <content:encoded><![CDATA[<p>Kotlin provides several powerful ways to model fixed sets of types or states in your applications. Among the most commonly used are <strong>enum classes</strong>, <strong>sealed classes</strong>, and <strong>sealed interfaces</strong>. Each serves a different purpose, depending on the level of flexibility and data modeling you need.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*thiEXcRYNlKARzF-5f9aZw.png" /></figure><h3>1. Enum Classes</h3><h3>What They Are</h3><p>An <strong>enum class</strong> in Kotlin defines a fixed set of constants that represent distinct values of the same type.<br> Each constant in an enum class is a singleton object — meaning there’s only one instance of each constant.<br> Enums are ideal when you want to represent a small, fixed number of options such as directions, colors, or status codes.</p><h3>Example</h3><pre>enum class Direction {<br>    NORTH, SOUTH, EAST, WEST<br>}</pre><h3>Usage</h3><p>You can use the enum values directly in code:</p><pre>val dir = Direction.NORTH<br><br>when (dir) {<br>    Direction.NORTH -&gt; println(&quot;Going up&quot;)<br>    Direction.SOUTH -&gt; println(&quot;Going down&quot;)<br>    Direction.EAST  -&gt; println(&quot;Going right&quot;)<br>    Direction.WEST  -&gt; println(&quot;Going left&quot;)<br>}</pre><h3>When to Use</h3><p>Use an <strong>enum class</strong> when:</p><ul><li>You have a <strong>small, fixed set of constants</strong>.</li><li>Each value represents a <strong>distinct state</strong>.</li><li>You do not need to store additional data or behavior per constant.</li></ul><h3>Adding Properties and Methods</h3><p>Enum constants can also have associated properties and methods:</p><pre>enum class Direction(val degrees: Int) {<br>    NORTH(0), EAST(90), SOUTH(180), WEST(270);<br><br>    fun turnRight() = values()[(ordinal + 1) % values().size]<br>}</pre><p>This allows enums to be more expressive when needed while keeping them lightweight.</p><h3>2. Sealed Classes</h3><h3>What They Are</h3><p>A <strong>sealed class</strong> defines a restricted class hierarchy — meaning only a fixed number of subclasses can exist, and they must be defined within the same file.<br> Sealed classes are more flexible than enums because each subclass can hold different data and behavior.</p><h3>Example</h3><pre>sealed class Result {<br>    data class Success(val data: String) : Result()<br>    data class Error(val message: String) : Result()<br>    object Loading : Result()<br>}</pre><h3>Usage</h3><p>Sealed classes are typically used with when expressions:</p><pre>fun handleResult(result: Result) = when (result) {<br>    is Result.Success -&gt; println(&quot;Data: ${result.data}&quot;)<br>    is Result.Error   -&gt; println(&quot;Error: ${result.message}&quot;)<br>    Result.Loading    -&gt; println(&quot;Loading...&quot;)<br>}</pre><p>Kotlin ensures that all possible subclasses are handled, making your when expressions exhaustive and type-safe.</p><h3>When to Use</h3><p>Use a <strong>sealed class</strong> when:</p><ul><li>You have a <strong>fixed number of types</strong>, but they <strong>carry different data</strong>.</li><li>You want <strong>type safety</strong> when using when expressions.</li><li>You’re modeling <strong>states</strong> such as network responses or UI states.</li></ul><h3>Example Use Case</h3><p>Sealed classes are perfect for modeling network or UI states:</p><pre>sealed class NetworkState {<br>    object Loading : NetworkState()<br>    data class Success(val data: List&lt;String&gt;) : NetworkState()<br>    data class Error(val exception: Exception) : NetworkState()<br>}</pre><h3>3. Sealed Interfaces</h3><h3>What They Are</h3><p>Introduced in Kotlin 1.5, a <strong>sealed interface</strong> works similarly to a sealed class but allows <strong>multiple inheritance</strong>.<br> This is useful when you want a restricted type hierarchy but need the flexibility of interfaces.</p><h3>Example</h3><pre>sealed interface Shape<br><br>data class Circle(val radius: Double) : Shape<br>data class Rectangle(val width: Double, val height: Double) : Shape<br>object NoShape : Shape</pre><h3>Usage</h3><pre>fun describeShape(shape: Shape) = when (shape) {<br>    is Circle -&gt; &quot;Circle with radius ${shape.radius}&quot;<br>    is Rectangle -&gt; &quot;Rectangle of ${shape.width}x${shape.height}&quot;<br>    NoShape -&gt; &quot;No shape&quot;<br>}</pre><h3>When to Use</h3><p>Use a <strong>sealed interface</strong> when:</p><ul><li>You want a <strong>restricted hierarchy</strong> with flexible implementation.</li><li>You need <strong>multiple inheritance</strong> (a class can implement multiple interfaces but extend only one class).</li><li>You are defining <strong>contracts or behaviors</strong>, not base implementations.</li></ul><h3>Conclusion</h3><ul><li>Use <strong>enum classes</strong> for simple, fixed sets of constants.</li><li>Use <strong>sealed classes</strong> for representing states or results with varying data.</li><li>Use <strong>sealed interfaces</strong> when you need a flexible, restricted hierarchy that supports multiple inheritance.</li></ul><p>By understanding when and how to use each, you can write cleaner, safer, and more maintainable Kotlin code.</p><h3>Check more blogs —</h3><h4><a href="https://medium.com/@khanmubashshir08/kotlin-multiplatform-setup-in-android-studio-windows-f8d238210fb0">Kotlin Multiplatform Setup in Android Studio (Windows)</a></h4><h4><a href="https://medium.com/@khanmubashshir08/a-beginners-guide-to-understanding-mvvm-architecture-in-android-f023e6f2ab15">Guide to Understanding MVVM Architecture in Android</a></h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=457527c76269" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Guide to Understanding MVVM Architecture in Android]]></title>
            <link>https://medium.com/@khanmubashshir08/a-beginners-guide-to-understanding-mvvm-architecture-in-android-f023e6f2ab15?source=rss-3f4cd0cd7d3e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f023e6f2ab15</guid>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[mvvm]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Mubashshir Khan]]></dc:creator>
            <pubDate>Tue, 04 Nov 2025 12:39:59 GMT</pubDate>
            <atom:updated>2025-11-11T10:59:47.943Z</atom:updated>
            <content:encoded><![CDATA[<p>When most beginners start Android development, they usually write UI code, UI logic, and business logic inside the same Activity or Fragment. It feels simple at first, but as the project grows, the code quickly becomes:</p><ul><li>Hard to read</li><li>Hard to maintain</li><li>Hard to debug</li><li>Hard to test</li><li>Completely tied to the Activity lifecycle</li></ul><p>This is why understanding <strong>MVVM (Model–View–ViewModel)</strong> matters. Not because it is a trend, but because it solves real problems in real apps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C2IOubZW-jRMvAklV3q54Q.png" /></figure><h3>Why Writing Everything Inside an Activity Is a Problem</h3><p>An Activity is a <strong>UI controller</strong>, not a data holder or business-logic layer. It is destroyed and recreated frequently due to:</p><ul><li>Screen rotation</li><li>App going to background</li><li>System killing it due to memory</li><li>Configuration changes</li></ul><p>So if you put your logic inside an Activity, you will eventually face issues like:</p><h3>Common Problems When Putting All Logic Inside an Activity</h3><ol><li>When the screen is rotated, the data is lost.</li><li>When the app is killed and recreated by the system, the state resets.</li><li>Reusing the business logic in another screen becomes almost impossible because it is tightly coupled with the UI.</li><li>Writing unit tests becomes very difficult or nearly impossible because the logic depends on Android framework classes.</li></ol><p>To understand why this happens, the first step is learning the <strong>Activity lifecycle</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/513/0*Nxh3dtE2qUXGCHU7.png" /><figcaption><a href="https://developer.android.com/guide/components/activities/activity-lifecycle#alc"><strong>Activity-lifecycle concepts.</strong></a></figcaption></figure><h3>Official Documentation</h3><p><a href="https://developer.android.com/guide/components/activities/activity-lifecycle">https://developer.android.com/guide/components/activities/activity-lifecycle</a></p><h3>ViewModel: The Core of MVVM</h3><p>The ViewModel exists to solve the biggest problem of Activity: <strong>lifecycle dependency</strong>.</p><p>A ViewModel:</p><ul><li>Survives configuration changes</li><li>Holds the UI state safely</li><li>Eliminates putting logic inside UI classes</li><li>Makes code testable and reusable</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/522/0*QLmzZ-6BfW-WVpkX.png" /><figcaption><a href="https://developer.android.com/topic/libraries/architecture/viewmodel#lifecycle"><strong>The lifecycle of a ViewModel</strong></a></figcaption></figure><h3>Learn ViewModel with Hands-on Codelab</h3><p><a href="https://developer.android.com/codelabs/basic-android-kotlin-compose-viewmodel-and-state#0">https://developer.android.com/codelabs/basic-android-kotlin-compose-viewmodel-and-state#0</a></p><h3>ViewModel Lifecycle Explained</h3><p><a href="https://developer.android.com/topic/libraries/architecture/viewmodel">https://developer.android.com/topic/libraries/architecture/viewmodel</a></p><h3>Understanding the UI Layer in Android Architecture</h3><p>Once you understand Activity, ViewModel, and how UI state is managed properly, you have mastered the <strong>UI Layer</strong> of MVVM.</p><h3>UI Layer Architecture (Official Docs)</h3><p><a href="https://developer.android.com/topic/architecture/ui-layer">https://developer.android.com/topic/architecture/ui-layer</a></p><h3>What Comes After the UI Layer?</h3><p>Once you are comfortable with Activity + ViewModel + State, the next steps in MVVM are:</p><ul><li>Repository pattern</li><li>Local storage (Room, DataStore)</li><li>Network layer (Retrofit, Ktor, etc.)</li><li>Dependency injection (Hilt/Koin)</li><li>Clean architecture concepts</li></ul><h3>Full Android Architecture Learning Path</h3><p><a href="https://developer.android.com/courses/pathways/android-architecture">https://developer.android.com/courses/pathways/android-architecture</a></p><h3>Recommended Learning Order (Step-by-Step)</h3><ol><li><strong>Activity Lifecycle</strong><br> Learn how an Activity is created, destroyed, and recreated.<br> Official docs: <a href="https://developer.android.com/guide/components/activities/activity-lifecycle">https://developer.android.com/guide/components/activities/activity-lifecycle</a></li><li><strong>ViewModel &amp; UI State Basics</strong><br> Understand why ViewModel exists and how it manages UI data.<br> Codelab: <a href="https://developer.android.com/codelabs/basic-android-kotlin-compose-viewmodel-and-state#0">https://developer.android.com/codelabs/basic-android-kotlin-compose-viewmodel-and-state#0</a></li><li><strong>ViewModel Lifecycle &amp; Use Cases</strong><br> Learn how ViewModel survives configuration changes like rotation.<br> Docs: <a href="https://developer.android.com/topic/libraries/architecture/viewmodel">https://developer.android.com/topic/libraries/architecture/viewmodel</a></li><li><strong>UI Layer Architecture</strong><br> Understand how UI, ViewModel, and state flow are structured in MVVM.<br> Docs: <a href="https://developer.android.com/topic/architecture/ui-layer">https://developer.android.com/topic/architecture/ui-layer</a></li><li><strong>Full Android Architecture Pathway</strong><br> Once UI layer is clear, move toward Repository, Data Layer, DI, etc.<br> Pathway: <a href="https://developer.android.com/courses/pathways/android-architecture">https://developer.android.com/courses/pathways/android-architecture</a></li></ol><h3>Why This Article Focuses Only on the UI Layer</h3><p>This is intentional.</p><p>One of the biggest reasons beginners get confused with MVVM is trying to learn <strong>ViewModel + Repository + Coroutines + Flow + Hilt + Room</strong> all at once.</p><p>Master the <strong>UI layer first</strong>.<br>Then move to the <strong>data layer</strong>.<br>Finally, learn <strong>dependency injection</strong>.</p><h3>Practical Advice for Beginners</h3><ul><li>Do not copy code without understanding the lifecycle behind it</li><li>Build very small apps first (notes app, counter app, BMI calculator, etc.)</li><li>Treat ViewModel as your logic holder and Activity as just a UI renderer</li><li>Prefer official documentation over random tutorials</li><li>Keep UI classes dumb and ViewModel smart</li></ul><blockquote><em>MVVM is not difficult. It only becomes difficult when you skip the basics.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f023e6f2ab15" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin Multiplatform Setup in Android Studio (Windows)]]></title>
            <link>https://medium.com/@khanmubashshir08/kotlin-multiplatform-setup-in-android-studio-windows-f8d238210fb0?source=rss-3f4cd0cd7d3e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8d238210fb0</guid>
            <category><![CDATA[kotlin-multiplatform]]></category>
            <category><![CDATA[android-studio]]></category>
            <category><![CDATA[android-studio-plugins]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Mubashshir Khan]]></dc:creator>
            <pubDate>Fri, 11 Jul 2025 19:31:27 GMT</pubDate>
            <atom:updated>2025-07-11T19:36:30.724Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’re trying to get started with <strong>Kotlin Multiplatform (KMP)</strong> on <strong>Windows</strong>, you might face this message when installing the <strong>Kotlin Multiplatform plugin</strong>:</p><p>“The plugin is not available for Windows”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4aTeM523VVqoEvRp" /></figure><p>This plugin is officially supported on <strong>macOS</strong>, which is why the JetBrains documentation may not fully help Windows users.</p><p>I personally faced this issue and spent hours finding a proper fix. Here’s the step-by-step solution that worked for me and will help you set up Kotlin Multiplatform on Windows.</p><h3>Step-by-Step Guide to Set Up KMP on Windows</h3><h3>1. Install Android SDK Command-Line Tools</h3><p>KMP projects require CLI tools to work correctly.</p><p><strong>Steps:</strong></p><ul><li>Open <strong>Android Studio</strong></li><li>Go to Settings &gt; Languages &amp; Frameworks &gt; Android SDK &gt; SDK Tools</li><li>Check Android SDK Command-line Tools (latest)</li><li>Click <strong>Apply</strong>, then <strong>OK</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NAbNolqjQ5NC0aBT" /></figure><h3>2. Use Kotlin Multiplatform Wizard</h3><p>Since the plugin is unavailable on Windows, use the<a href="https://kmp.jetbrains.com/templates/"> KMP Project Wizard</a> to download a starter template.</p><p><strong>Steps:</strong></p><ul><li>Visit:<a href="https://kmp.jetbrains.com/templates/"> https://kmp.jetbrains.com/templates/</a></li><li>Choose a project template or create a custom project</li><li>Download the .zip file</li><li>Extract the project folder</li><li>Open the folder in <strong>Android Studio</strong></li></ul><p>If the project opens and builds successfully, your setup is complete.</p><h3>Common Issue and How to Fix It</h3><h3>Error:</h3><p>Execution failed for task ‘:composeApp:commonizeNativeDistribution’</p><p>&gt; java.nio.file.FileAlreadyExistsException: C:\Users\91906\.konan\kotlin-native-prebuilt-windows-x86_64–2.2.0\bin\cinterop</p><h3>Solution:</h3><p>To resolve this, clear the Kotlin/Native cache and let Gradle redownload all required tools.</p><h4>Steps:</h4><ol><li>Close Android Studio.</li><li>Delete the .konan directory:</li></ol><ul><li>Go to C:\Users\91906\</li><li>Delete the .konan folder. It will be recreated automatically.</li></ul><p>3. (Optional but recommended) Delete Gradle caches:</p><ul><li>Go to C:\Users\91906\</li><li>Delete the .gradle folder, or at least the caches subdirectory.</li></ul><p>4. Reopen Android Studio and rebuild the project:</p><ul><li>Wait for Gradle to sync and download tools.</li><li>Go to Build &gt; Clean Project, then Build &gt; Rebuild Project.</li></ul><p>This should resolve the error and complete the setup successfully.</p><p><strong>Additional Tip: </strong>This setup relies on <strong>Gradle + Kotlin DSL</strong>, so ensure you’re using the latest version of Android Studio and Kotlin.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8d238210fb0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>