chore: sync content to repo (#10175)

Co-authored-by: nilbuild <4921183+nilbuild@users.noreply.github.com>
2026-09-24 15:00:31 +08:00 · 2026-07-24 11:29:37 +02:00
parent 9f9eafe0a1
commit 1e263c12e9
68 changed files with 198 additions and 209 deletions
@@ -1,6 +1,6 @@
-# Activity Lifecycle
-
-The **Activity Lifecycle** in Android represents a series of states or events that an activity can go through from its creation to its destruction. The primary states or events are `onCreate()`, `onStart()`, `onResume()`, `onPause()`, `onStop()`, `onDestroy()`, and `onRestart()`. The method `onCreate()` is called when the activity is first created, followed by `onStart()` when the activity becomes visible to the user. The `onResume()` method executes when the user starts interacting with the application. `onPause()` and `onStop()` methods are invoked when the application is no longer in the foreground or visible to the user. The `onDestroy()` method is used when the activity is being completely removed from the memory. The `onRestart()` method is called after the system stops the activity and is about to start it again. The proper handling of these states ensures the efficient use of resources and a smooth user experience.
+# Activity LifeCycle
+ 
+The Activity lifecycle is a set of states and callbacks that an Activity goes through from creation to destruction. Key callbacks include onCreate, onStart, onResume, onPause, onStop, and onDestroy. Properly implementing these callbacks ensures the app handles interruptions like phone calls or screen rotations without data loss.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Activity
-
-`Activity` in Android is a crucial component that represents a single screen with a user interface. It is just like a window in a desktop application. Android apps are typically made up of one or more activities, each having its interface which allows user interaction. When an app is launched, an instance of `Activity` is created, starting the lifecycle of that app. Every activity has its own lifecycle (create, start, resume, pause, stop, destroy) that keeps the state of a user's progress, and Android manages these states automatically. Activities can also have `Intent`, which allows them to interact with other components, such as starting another activity or getting a result from that activity.
+ 
+An Activity represents a single screen in an Android app with a user interface. Apps are typically made up of multiple activities that users navigate between. Activities have a lifecycle managed by the operating system, and handling that lifecycle correctly is essential for building stable apps.

 Visit the following resources to learn more:

@@ -0,0 +1,8 @@
+# Animations
+
+Animations, in a broad sense, are visual effects that give the impression of movement by rapidly displaying a sequence of images or frames.  In the context of user interfaces, animations enhance the user experience by providing visual feedback, guiding the user's attention, and making the interface feel more responsive and engaging. They help communicate changes in state, indicate loading progress, and add polish to an application's overall look and feel.
+
+Visit the following resources to learn more:
+
+- [@official@Animations in Compose](https://developer.android.com/develop/ui/compose/animation/introduction)
+- [@official@Quick guide to Animations in Compose  |  Jetpack Compose  |  Android Developers](https://developer.android.com/develop/ui/compose/animation/quick-guide)
@@ -1,6 +1,6 @@
 # Apollo-Android
-
-**Apollo Android** is a set of tools for using GraphQL with Android, made by the Apollo community developers. It's fully written in Kotlin and it was designed to seamlessly integrate with any Android app, making fetching data across network and handling data in the client-side a breeze. Apollo Android runs your queries and mutations and returns results as generated Kotlin types. It also normalizes your data and caches your results for further speed enhancements. It operates both on Android and Kotlin/JVM backend environment. It's also coroutines-first making handling concurrency easy and effective. To use Apollo Android, you'll set up the plugin, point it at your GraphQL schema, and write GraphQL queries.
+ 
+Apollo Android is a GraphQL client for Android and Kotlin that generates type-safe Kotlin models from a GraphQL schema and query files. It handles query execution, caching, and subscriptions, and integrates with Kotlin coroutines. Apollo-Android allows working with GraphQL APIs in a structured, compile-time-safe way.

 Visit the following resources to learn more:

@@ -1,16 +1,6 @@
 # App Components
-
-Android apps are primarily made up of five different types of components:
-
-1.  **Activities**: These are individual screens that a user can interact with. Any UI action like touching a button or swiping a screen will usually take place within an activity.
-    
-2.  **Services**: Unlike activities, services run in the background and don't have a user interface. They’re used for repetitive or long running operations, like playing music or pulling in a feed of data from a server.
-    
-3.  **Broadcast Receivers**: These are event listeners. The Android operating system uses them to respond to system-wide events.
-    
-4.  **Content Providers**: They manage and share app data with other apps installed on the device. For security, data is not generally shared across apps.
-    
-5.  **Intents**: These serve as messages or commands to the Android system. They're used to signal to the Android system that certain events have occurred.
+ 
+App components are the building blocks of an Android application. The four main types are Activities, Services, Broadcast Receivers, and Content Providers. Each serves a different purpose and has its own lifecycle managed by the Android system.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Asynchronism
-
-Asynchronism in Android is a practice that defines operations, which can run independently from the main operation without following the program's linear flow. The Android system uses threads to handle asynchronous processes. These threads function independently, ensuring that complex or time-consuming operations do not interfere with the user interface or other essential parts of the application. Android provides various tools for carrying out asynchronous tasks, such as `Handler`, `ThreadPoolExecutor`, `IntentService`, `AsyncTask`, and `Loader` etc. These tools provide ways to execute tasks on different threads and communicate the results back to the main thread.
+ 
+Asynchronism in Android refers to running operations outside the main thread to prevent blocking the UI. Android provides several tools for this: Kotlin Coroutines as the modern recommended approach, Threads for low-level concurrency, RxJava and RxKotlin for reactive streams, and WorkManager for deferred background tasks.

 Visit the following resources to learn more:

@@ -1,10 +1,6 @@
 # Authentication
-
-Firebase Authentication in Android provides backend services, easy-to-use SDKs, and ready-made UI libraries to authenticate users to your app. It supports authentication using passwords, popular federated identity providers like Google, Facebook and Twitter, and more. Firebase also facilitates integration of functionality to sign in, sign up, and reset password. Moreover, it can be used to secure your database by implementing role-based access to data and to provide personalized experience according to the user's unique identity.
-
-Firebase Authentication offers two methods to authenticate. These are using an `email/password` login provided by Firebase Authentication or a `federated identity provider` like Google or Facebook. It also covers token-based authentication by creating custom tokens or verifying ID tokens. In addition to this, Firebase Authentication works with Firebase's client SDKs for practical use and works for long-running server processes for some of your users.
-
-Firebase Authentication provides a full suite of capabilities even beyond authentication to make your life easier, which includes Security Rules for Cloud Storage and Cloud Firestore, Firebase Dynamic Links, and Firebase Invites.
+ 
+Firebase Authentication provides backend services for authenticating users with email and password, phone numbers, or federated identity providers like Google, Facebook, and Apple. It manages tokens and session state securely. On Android, it integrates with the Firebase SDK to handle sign-in flows with minimal boilerplate.

 Visit the following resources to learn more:

@@ -4,5 +4,6 @@ Kotlin is a concise, multi-platform, and fun language developed by JetBrains. Le

 Visit the following resources to learn more:

+- [@roadmap@Visit the Dedicaated Kotlin Roadmap](https://roadmap.sh/kotlin)
 - [@official@Kotlin](https://kotlinlang.org/)
 - [@official@Kotlin Docs](https://kotlinlang.org/docs/getting-started.html)
@@ -1,8 +1,6 @@
-# Basics of OOP
-
-Understanding the `Basics of Object-Oriented Programming (OOP)` is crucial. OOP is a programming paradigm that uses "Objects" - entities that contain both data and functions that manipulate the data.
-
-Key concepts include `Classes`, which are blueprints from which objects are created; `Objects`, instances of a class; `Inheritance`, where one class acquires properties from another; `Polymorphism`, the ability of an object to take many forms; `Abstraction`, showing only necessary details and hiding implementation from the user; and `Encapsulation`, the concept of wrapping data and the methods that work on data within one unit.
+# Basics of Kotlin
+ 
+The basics of Kotlin cover the syntax and core concepts needed to write Kotlin programs. This includes variables, data types, control flow, functions, lambdas, classes, and Kotlin-specific features like null safety and extension functions. A solid grasp of these fundamentals is required before working with Android-specific APIs.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
-# BitBucket
-
-Bitbucket is a web-based hosting service that is owned by Atlassian. Bitbucket uses either Mercurial or Git revision control systems, allowing users to manage and maintain their code. This platform is mainly used for code and code review. Bitbucket provides both commercial plans and free accounts. It offers free accounts with an unlimited number of private repositories (which can have up to five users in the case of free accounts) as of September 2010. It originally offered only Mercurial support. Bitbucket integrates with other Atlassian software like JIRA, HipChat, Confluence and Bamboo.
+# Bitbucket
+ 
+Bitbucket is a Git repository hosting service by Atlassian. It integrates with other Atlassian tools like Jira and Confluence, making it a common choice for teams already using Atlassian products. Bitbucket supports pull requests, branch permissions, and CI/CD pipelines through Bitbucket Pipelines.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Broadcast Receiver
-
-**Broadcast Receivers** in Android are components that respond to system-wide broadcast announcements. They can be registered to respond to a specific type of broadcasts or implement a user-defined broadcast. While you can initiate a broadcast from your app, they are generally used for receiving system notifications or communicating with other applications. However, keep in mind that they cannot display a user interface, but they can start activities if necessary, which do have a user interface. A `BroadcastReceiver` class must override the `onReceive()` method where each message is received as an `Intent` object parameter.
+ 
+A Broadcast Receiver is a component that listens for system-wide broadcast announcements. Common broadcasts include events like device boot, network connectivity changes, or battery status updates. Receivers can also facilitate communication between different parts of the same app.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Chucker
-
-`Chucker` is an open-source debugging library created for Android applications. It has been designed to be easy to use and convenient for developers. This library intercepts and records all HTTP requests and responses inside your application, which helps to visualize and share this information in an understandable and easy-to-read format. Using Chucker's distinct features, you can inspect all the HTTP and HTTPS traffic going in and out of your app directly. In addition, it provides other nifty features such as a user-friendly interface to view the server's raw response. It's like having a built-in network inspector in your debugging tool, enabling you to solve network-related issues more efficiently.
+ 
+Chucker is an in-app HTTP inspector for Android. It intercepts OkHttp network requests and responses and displays them in a dedicated UI within the app during development. Chucker helps developers inspect API calls, headers, payloads, and response times without needing an external proxy tool.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Cloud Messaging
-
-Firebase Cloud Messaging (FCM) is a powerful, battery-efficient messaging service that enables you to send messages reliably and securely to your Android applications. It enables you to send two types of messages: "notification messages" and "data messages". Notification messages are primarily meant for user notifications and will only be delivered when the application is in the foreground. On the other hand, data messages can handle even when the app is in the background or killed and can be used to send custom key-value pairs. FCM also supports various additional features, such as topic messaging to send messages to multiple devices subscribed to a common topic, device group messaging for sending messages to groups of user devices, and upstream messaging for sending messages from the client application to the FCM server.
+ 
+Firebase Cloud Messaging (FCM) is a cross-platform messaging service for delivering push notifications and data messages to Android apps. Notifications can target individual devices, device groups, or topics that users subscribe to. FCM supports both foreground and background message delivery and is free to use.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Common Services
-
-Common Services are functional units or components provided by the Android system for use by developers. These services include things such as Location Services (used to determine the device's geographical location), Notification Services (handles the display and management of user notifications), and Sensor Services (interacts with hardware sensors). Other common services are Network and Connectivity Services, Account Manager, and Data Storage Services among others. They simplify the development process by handling complex functionalities behind the scenes, allowing developers to focus on the application's specific needs.
+ 
+Common Services covers widely used Google and third-party platform services that Android apps integrate with. These include Google Maps for location and mapping, Google Play Services for platform features, AdMob for advertising, and Firebase for a range of backend services.

 Visit the following resources to learn more:

@@ -0,0 +1,8 @@
+# ConstraintLayout
+
+ConstraintLayout is a flexible and powerful layout manager for Android that allows you to position and size views using constraints relative to other views, the parent layout, or guidelines. It gives you fine-grained control over the placement of UI elements and helps create complex layouts without nesting multiple layout groups. It's designed to be a flat layout, which can help improve performance compared to deeply nested layouts.
+
+Visit the following resources to learn more:
+
+- [@official@ConstraintLayout](https://developer.android.com/develop/ui/compose/layouts/constraintlayout)
+- [@article@Constraint Layout — Jetpack Compose](https://medium.com/@jayeshseth/constraint-layout-jetpack-compose-a3545f3dee00)
@@ -1,6 +1,6 @@
 # Content Provider
-
-A **Content Provider** in Android is a key component that allows applications to securely share data with other applications. They act as a layer between databases and applications to enhance data security. Content providers manage access to a structured set of data by handling data transactions, implementing data security, and maintaining isolation between applications. They provide an abstracted interface which is used to access data, while the underlying storage method (Like SQLite database, web, or any other method) remains hidden. This mechanism aids in retrieving data from a non-relational source in a structured way. They're used primarily when data needs to be shared between multiple applications, not just within a single application.
+ 
+A Content Provider manages access to a structured set of data and provides a standard interface for sharing data between apps. Platform apps like Contacts, Calendar, and Media Store expose their data through content providers. Custom content providers are used to share data with other apps or between processes within the same app.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Coroutines
-
-`Coroutines` refer to a concurrency design pattern that you can use on Android to simplify code that executes asynchronously. `Coroutines` provide a way to write asynchronous, non-blocking code in a natural, sequential manner. The fundamental building blocks of `coroutines` are `suspend` functions which are simply functions that can be paused and resumed at later times. They are the key to writing non-blocking asynchronous code and represent a single unit of asynchronous computation. This aspect of `coroutines` makes them useful for managing long-running tasks that might otherwise block the main thread and cause your application to become unresponsive.
+ 
+Kotlin Coroutines are a concurrency framework that allows writing asynchronous code in a sequential, readable style. They are lightweight, support structured concurrency, and integrate with Android Jetpack through lifecycle-aware CoroutineScopes. Coroutines replaced older patterns like AsyncTask and are now the preferred approach for async work in Android.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
-# Create a Hello World App
-
-The "Hello World" app is a simple project that you can build when you're getting started with Android development. It's often the first program that beginners learn to build in a new system. It's usually considered the simplest form of program that displays a message to the user - "Hello, World!" In Android, this involves creating a new project from the Android Studio and setting up the main activity. The main activity file is primarily written in Java or Kotlin where you can code for the display message, while the layout design view can be created in the XML file.
+# Create a Basic Hello World App
+ 
+Creating a Hello World app is the starting point for hands-on Android development. It involves setting up a new project in Android Studio, writing a simple activity, and running it on an emulator or physical device. The exercise introduces the project structure, the Gradle build process, and how the UI connects to code.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Dagger
-
-Dagger is a fully static, compile-time dependency injection framework for both Java and Android. It is an adaptation of an earlier version created by Square that's focused on simplicity and speed. Dagger's primary focus is on compile-time analysis of dependencies, code simplicity, and clarity. It uses annotations to define dependencies, thus aiding in easy readability and understanding of the code. Dagger also eliminates the use of reflection to inject dependencies, thus boosting performance. It offers custom scopes to control the lifespan of instances and ensures that dependencies are Singleton across the entire lifespan of certain scopes.
+ 
+Dagger is a compile-time dependency injection framework for Java and Kotlin. It generates efficient DI code based on annotations, avoiding reflection at runtime. Dagger has a steep learning curve but is widely used in large Android codebases for its performance and reliability.

 Visit the following resources to learn more:

@@ -1,8 +1,6 @@
-# DataStructures and Algorithms
-
-**Data Structures** are primarily used to collect, organize and perform operations on the stored data more effectively. They are essential for designing advanced-level Android applications. Examples include Array, Linked List, Stack, Queue, Hash Map, and Tree.
-
-**Algorithms** are a sequence of instructions or rules for performing a particular task. In Android, algorithms can be used for data searching, sorting, or performing complex business logic. Some commonly used algorithms are Binary Search, Bubble Sort, Selection Sort, etc. A deep understanding of data structures and algorithms is crucial in optimizing the performance and the memory consumption of the Android applications.
+# Data Structures and Algorithms
+ 
+Data structures and algorithms cover how data is organized and processed efficiently in code. Common structures include lists, maps, sets, stacks, and queues; common algorithmic topics include sorting, searching, and recursion. Understanding these is necessary for writing performant apps and for technical interviews.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # DataStore
-
-`DataStore` is a new and improved data storage solution by Android, meant to supersede `SharedPreferences`. It is important to understand that it comes in two different implementations: `Preferences DataStore` and `Proto DataStore`. `Preferences DataStore` uses key-value pairs similar to `SharedPreferences`, but it's more robust and handles runtime exceptions more efficiently. On the other hand, `Proto DataStore` uses custom data types to provide type safety. It lets you leverage the power of Protocol Buffers, a language-neutral, platform-neutral mechanism for serializing structured data, as the data storage format. Operating on data in `DataStore` is transactional, meaning that if an error occurs during an operation, all changes are rolled back, so the data remains in a consistent state.
+ 
+DataStore is Jetpack's modern replacement for Shared Preferences. It provides two implementations: Preferences DataStore for key-value storage and Proto DataStore for typed, schema-based storage using Protocol Buffers. DataStore uses Kotlin coroutines and Flow, making it asynchronous and safer to use than Shared Preferences.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Debugging
-
-Debugging is a critical step in the app development process. In Android development, it includes identifying and fixing errors, or bugs, in your code. You can debug Android apps using several tools and techniques. For example, Android Studio, the primary integrated development environment (IDE) for Android, comes with a built-in debugging tool, the Android Debug Bridge (ADB). This command-line tool allows you to communicate your device and perform various actions like installing and debugging apps. Android Studio also supports step-by-step debugging, where you can set breakpoints in your code and inspect the application state at those points.
+ 
+Debugging in Android involves identifying and fixing issues in app behavior, performance, and memory usage. Android Studio provides a built-in debugger, and specialized tools like Jetpack Benchmark, Chucker, LeakCanary, and Timber address specific categories of issues.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Dependency Injection
-
-`Dependency Injection` is a technique where an object does not need to create its own dependencies; instead, dependencies are provided (or injected) at runtime. This technique is highly beneficial in Android Development. It helps in creating loosely coupled and easily testable code. For example, the `Retrofit` instance that your application requires to make network calls can be created somewhere else and can be injected whenever required using libraries like `Dagger`, `Koin` or `Hilt`. The `ViewModel` instances can also be injected rather than being created in the required classes directly. Through dependency injection, plugins ensure the code becomes easier to change, understand, and maintain, hence, improving the quality of the code.
+ 
+Dependency Injection (DI) is a technique where objects receive their dependencies from an external source rather than creating them internally. In Android, DI frameworks manage the creation and lifecycle of dependencies across the app, improving testability and reducing coupling. Common solutions include Dagger, Hilt, and Koin.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Detekt
-
-`Detekt` is a static code analysis tool for the Kotlin programming language. It operates on the abstract syntax tree provided by the Kotlin compiler and can run in the command line or as a task in your Gradle build script. Detekt provides complexity reports that can be used to identify overly complex code and help simplify it. It also checks for a variety of potential bugs and code smells, including issues with formatting, naming conventions, exception handling, and more. Moreover, Detekt is highly configurable, allowing you to enable, disable, or modify the behavior of its checks to suit your project's needs.
+ 
+Detekt is a static code analysis tool for Kotlin that identifies code smells, complexity issues, potential bugs, and style violations. It is more configurable than Ktlint and covers a broader range of quality checks. Detekt reports can be integrated into CI pipelines to prevent problematic code from being merged.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Development IDE
-
-Development IDE refers to the Development Integrated Development Environment that is vital for Android App development. For Android, the primary IDE is **Android Studio**. This official IDE from Google includes everything you need to build an Android app, such as a code editor, code analysis tools, emulators for all of Android's supported OS versions and hardware configurations, and more. Other popular IDEs include **Eclipse** (with an Android Developer Tools plugin), **NetBeans**, and **IntelliJ IDEA**. Each of these IDEs tends to have its own set of specialized features, but all are designed to provide the tools and services needed for Android development. The choice of an IDE often depends on the specific needs and preferences of the developer or development team.
+ 
+Android Studio is the official integrated development environment for Android development. It is built on IntelliJ IDEA and provides tools for code editing, debugging, performance profiling, and device emulation. It also integrates directly with the Gradle build system and the Android SDK.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Distribution
-
-Distribution in Android refers to the methods and channels you can use to get your Android application into the hands of users. You can choose to distribute your app on the Google Play Store, which is the official app store for the Android operating system. This platform makes your app available to users in various countries around the world. Additionally, you can also opt to distribute your app through other third-party app stores or even your own website. Furthermore, Google provides a range of distribution options such as country targeting, device targeting, and staged roll-outs, which can be customized according to your distribution strategy. Remember, when you submit your application for distribution, you must adhere to the respective app store's policy and content guidelines.
+ 
+Distribution covers how Android apps are packaged and delivered to users. This includes generating a signed APK or AAB for release, and publishing through channels like the Google Play Store or Firebase App Distribution for internal testing and staged rollouts.

 Visit the following resources to learn more:

@@ -0,0 +1,8 @@
+# Drawer
+
+A Drawer is a panel that slides in from the edge of the screen to display navigation options and app content. Typically, it's triggered by a "hamburger" menu icon and provides a hierarchical way to access different sections within the application, offering a space-saving alternative to tabs or a navigation bar. It improves the user experience by organizing and hiding away secondary options, making the main screen less cluttered.
+
+Visit the following resources to learn more:
+
+- [@official@Navigation drawer  |  Jetpack Compose  |  Android Developers](https://developer.android.com/develop/ui/compose/components/drawer)
+- [@article@Crafting an Elegant Navigation Drawer in Jetpack Compose | by Abhishek Pathak | Medium](https://medium.com/@myofficework000/crafting-an-elegant-navigation-drawer-in-jetpack-compose-49fac924e30f)
@@ -1,37 +1,6 @@
 # Factory Pattern
-
-The **Factory Pattern** is part of the Creational Design Patterns. This pattern provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. It introduces an abstraction layer between the client code and the concrete objects. Normally, this is achieved by using a factory method to create objects instead of using constructors. The instance of the class is usually created by a method, referred to as a `factory method`, which is either specified in an interface and implemented in implementing classes or implemented in a base class which may be optionally overridden by derived classes. The Factory Method is used when we want to provide users with a way to create an instance of a class from one of several possible classes that share a common super class.
-
-Here is a basic example of the Factory Pattern:
-
-    public abstract class Animal {
-        public abstract String makeSound();
-    }
-    
-    public class Dog extends Animal {
-        @override
-        public String makeSound() {
-            return "Woof";
-        }
-    }
-    
-    public class Cat extends Animal {
-        @override
-        public String makeSound() {
-            return "Meow";
-        }
-    }
-    
-    public class AnimalFactory {
-        public Animal createAnimal(String type) {
-            if ("Dog".equals(type)) {
-                return new Dog();
-            } else if ("Cat".equals(type)) {
-                return new Cat();
-            }
-            return null;
-        }
-    }
+ 
+The Factory pattern provides an interface for creating objects without specifying their exact class. It centralizes object creation logic, making it easier to swap implementations without modifying calling code. In Android, factory patterns appear in ViewModelProvider.Factory for creating ViewModels with custom constructor arguments.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # File System
-
-The Android operating system uses a specific File System structure to store and manage files. It’s primarily based on the Linux File system, with some specific Android features. The File System includes several key directories that are used for specific purposes. For instance, directories such as `/system` hold system apps and firmware, while `/data` contains user data, settings and installed applications, and `/sdcard` usually represents an internal or external SD card for additional storage. It's worth mentioning directories like `/proc`, `/dev`, and `/sys` which are virtual file systems and house important system files. As an Android developer, understanding these directories can help you interact with Android's file system more effectively. Note that access to some of these directories may be restricted depending on system permissions.
+ 
+The Android file system allows apps to read and write files to internal storage, external storage, and cache directories. Internal storage is private to the app, while shared storage is accessible to other apps through proper permissions and scoped storage APIs. File system access is used for raw files, media, and documents.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # FireStore
-
-Firestore, often referred to as Firebase Firestore or Cloud Firestore, is a flexible, scalable database for mobile, web, and server development from Firebase and Google Cloud. Firestore comes with features like expressive querying, real-time updates, and automatic multi-region data replication. It is designed to offer seamless integration with other Firebase and Google Cloud products. It provides a cloud-based NoSQL database, which means the data is stored as collections of documents. Each document, in turn, contains a set of key-value pairs. Firestore ensures durable networking, so data syncs across client apps in real-time, even when the device is offline, making it easier for you to work with distributed data that can be kept in sync across various clients.
+ 
+Firestore is Firebase's scalable, flexible NoSQL cloud database. It stores data as collections of documents and supports real-time listeners that push updates to connected clients instantly. Firestore provides offline support through local caching and automatically syncs data when connectivity is restored.

 Visit the following resources to learn more:

@@ -4,7 +4,7 @@

 Visit the following resources to learn more:

- [@roadmap@Git and GitHub Roadmap](https://roadmap.sh/git-github)
+- [@roadmap@Visit the Dedicated Git and GitHub Roadmap](https://roadmap.sh/git-github)
+- [@course@Why use Git? (Interactive Lesson)](https://inter-git.com/lessons/introduction)
 - [@article@Git by Example - Learn Version Control with Bite-sized Lessons](https://antonz.org/git-by-example/)
- [@video@Git & GitHub Crash Course For Beginners](https://www.youtube.com/watch?v=vA5TTz6BXhY)
- [@course@Why use Git? (Interactive Lesson)](https://inter-git.com/lessons/introduction)
+- [@video@Git & GitHub Crash Course For Beginners](https://www.youtube.com/watch?v=vA5TTz6BXhY)
@@ -1,6 +1,6 @@
 # GitLab
-
-`GitLab` is a web-based DevOps lifecycle tool which provides a Git-repository manager, along with continuous integration and deployment pipeline features, using an open-source license, developed by GitLab Inc. Users can manage and create their software projects and repositories, and collaborate on these projects with other members. `GitLab` also allows users to view analytics and open issues of their project. It stands next to other version control tools like `GitHub` and `Bitbucket`, but comes with its own set of additional features and nuances. For Android development, `GitLab` can be particularly useful owing to its continuous integration and deployment system which can automate large parts of the app testing and deployment.
+ 
+GitLab is a DevOps platform that includes Git repository hosting, CI/CD pipelines, issue tracking, and a container registry in a single product. It can be used as a cloud service or self-hosted on private infrastructure. GitLab CI/CD is particularly useful for automating Android build and testing workflows.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Google Maps
-
-Google Maps is a crucial service on Android, offering powerful, user-friendly mapping technology and local business information. Google Maps features include street maps, satellite imagery, 360° panoramic views of streets (Street View), real-time traffic conditions (Google Traffic), and route planning for traveling by foot, car, bicycle and air, or public transportation. The service's interface includes a function to overlay various layers such as traffic density, public transit lines, and cycling paths. Google Maps for Android also provides an API, which allows developers to interface with and control certain aspects of the Google Maps service in their applications. This capability subjects to certain usage limits and requirements set by Google.
+ 
+The Google Maps SDK for Android allows apps to embed interactive maps, display markers, draw routes, and access geolocation data. It is used in apps that require navigation, location search, or geographic visualization. The SDK integrates with the Fused Location Provider for efficient and battery-aware location access.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Google Play Services
-
-_Google Play Services_ is a proprietary background service and API package for Android devices from Google. Operated by Google, the service provides core functionalities like authentication for Google services, synchronized contacts, access to all the latest user privacy settings, and higher quality, lower-powered location-based services. It also speeds up offline searches, provides more immersive maps, and improves gaming experiences. Google Play Services play a crucial role in the operation of various other applications, including those not developed by Google. Moreover, it improves the overall Android experience by speeding up offline searches, providing more detailed maps, enhancing gaming experiences, and more.
+ 
+Google Play Services is a background service that provides core Google APIs to Android apps, including authentication, location, maps, and in-app payments. It is automatically updated on compatible devices and required for many Android platform features. Most apps that use Google APIs depend on Play Services being installed on the device.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Google Playstore
-
-**Google Play Store** is the official distribution channel for Android apps and other digital media content. It is a global online software store developed and operated by Google. Developers submit their applications to Google Play through the Play Console where Google Play's automated systems scan for potentially malicious code and content violations, before they are published on the Play Store. Users can then browse, download, and use these applications on their Android devices or via the web. Purchases, downloads, and user feedback can be tracked via the Google Play Console. Owners of Android devices can also configure automatic updates for the applications they have installed from the store. This platform supports multiple languages and multiple forms of payment methods, making it accessible and customer-friendly.
+ 
+The Google Play Store is the official marketplace for distributing Android apps to users worldwide. Publishing an app requires a Google Play developer account, a signed AAB or APK, and compliance with Google's developer policies. The Play Console provides tools for staged rollouts, A/B testing, crash monitoring, and user review management.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Intent Filters
-
-`Intent Filters` in Android are essential components of the Android system where you can declare the capabilities of your activities, services, and broadcast receivers. An intent filter is an expression found in your app's manifest file, defined in the `<intent-filter>` XML element. Android uses these filters to determine the appropriate components for incoming intents, which can be either explicit or implicit. Your app's ability to respond to intents depends on the filters you define. The filters are set of conditions comprised of `action`, `category`, and `data` which your activity or service is able to perform. If the incoming `Intent` matches with defined `Intent Filters`, Android system will permit that `Intent` to your Component (Activity, Service, or Broadcast Receiver).
+ 
+Intent filters declare what types of intents a component can receive. They are defined in the AndroidManifest.xml file and describe the actions, data types, and categories a component supports. The system uses intent filters to determine which activities or services can respond to a given implicit intent.

 Visit the following resources to learn more:

@@ -1,9 +1,9 @@
 # Java
-
-Java is a popular programming language used for Android development due to its robustness and ease of use. Its object-oriented structure allows developers to create modular programs and reusable code. The language was built with the philosophy of "write once, run anywhere" (WORA), meaning compiled Java code can run on all platforms without the need for recompilation. Android’s API and core libraries are primarily written in Java, therefore understanding Java is fundamental in creating diverse and powerful Android apps.
+ 
+Java was the original language for Android development and remains supported on the Android platform. It is a statically typed, object-oriented language that runs on the JVM. Many existing Android codebases and libraries are written in Java, so familiarity with it is still valuable even for developers working primarily in Kotlin.

 Visit the following resources to learn more:

- [@roadmap@Java Roadmap](https://roadmap.sh/java)
+- [@roadmap@Visit the dedicated Java Roadmap](https://roadmap.sh/java)
 - [@official@Java](https://www.oracle.com/java/technologies/javase-jdk11-downloads.html)
 - [@official@Java Documentation](https://docs.oracle.com/en/java/javase/11/docs/api/)
@@ -1,6 +1,6 @@
 # JUnit
-
-JUnit is a popular testing framework for Java programming. It forms the basis for many other testing libraries and tools in the Android ecosystem, making it important for any Android developer to become familiar with. The basic use of JUnit involves annotations such as `@Test`, indicating methods that represent a single test case. Other useful features include `@Before` and `@After` which allow for setup and teardown processes to be defined clearly. Another powerful feature in JUnit is the ability to create parameterized tests, effectively running the same test multiple times with different inputs.
+ 
+JUnit is the standard testing framework for unit testing Java and Kotlin code on Android. Unit tests run on the local JVM without needing a device or emulator, making them fast to execute. JUnit is used to verify the logic of ViewModels, Repositories, and other non-UI components.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Kotlin
-
-`Kotlin` is a cross-platform, statically typed general-purpose programming language with type inference. Developed by JetBrains, the makers of the world’s leading IDEs, Kotlin has a syntax, which is more expressive and concise. This allows for more readable and maintainable code. It is fully interoperable with Java and comes with no limitations. It can be used almost everywhere Java is used today, for server-side development, Android apps, and much more. Kotlin introduces several improvements for programmers over Java, which makes it a preferred choice for many developers. With more concise code base and modern programming concept support - it's certainly a future of Android app development.
+ 
+Kotlin is a statically typed programming language developed by JetBrains and officially endorsed by Google for Android development. It runs on the JVM and is fully interoperable with Java. Kotlin features concise syntax, null safety, coroutines for asynchronous programming, and extension functions that reduce boilerplate.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Ktlint
-
-`ktlint` is a static code analysis tool. It enforces a highly consistent style and adheres extensively to the official Kotlin coding conventions. `ktlint` does not have any configuration options (by design). The only exceptions are disabling specific rule(s) and specifying indentation size. `ktlint` can check, as well as automatically fix your code. Its main goal is to bring unified code style to your project. It works on the command line as well, so it can be hooked up into your continuous integration pipeline. It also has Ant, Gradle and Maven wrappers. You can use Ktlint on any Android/Kotlin project, as long as you have Gradle or Maven installed.
+ 
+Ktlint is a Kotlin linter and formatter that enforces the official Kotlin coding style. It can run manually, as part of a Gradle build, or as a pre-commit hook. Ktlint has minimal configuration by design and focuses on formatting rules like indentation, spacing, and import ordering.

 Visit the following resources to learn more:

@@ -0,0 +1,10 @@
+# Lazy Column and Row
+
+LazyColumn and LazyRow are composable functions in Jetpack Compose that efficiently display a large number of items in a scrollable list. Instead of composing all items at once, they only compose and render the items that are currently visible on the screen. This approach significantly improves performance and reduces memory consumption, especially when dealing with extensive datasets or dynamically changing content. They are similar to RecyclerView in the traditional Android View system, but with Compose's declarative and concise syntax.
+
+Visit the following resources to learn more:
+
+- [@official@Lazy Column](https://developer.android.com/reference/kotlin/androidx/compose/foundation/lazy/LazyColumn.composable)
+- [@official@Lazy Row](https://developer.android.com/reference/kotlin/androidx/compose/foundation/lazy/LazyRow.composable)
+- [@official@Lists and grids](https://developer.android.com/develop/ui/compose/lists)
+- [@video@Lazy layouts in Compose](https://www.youtube.com/watch?v=1ANt65eoNhQ)
@@ -1,6 +1,6 @@
 # Leak Canary
-
-LeakCanary is a powerful open-source memory leak detection library for Android and Java. It is integrated into your app, and once you run your app, LeakCanary immediately starts watching for memory leaks and captures a memory dump if it detects one. After investigation, it will present a full stack trace to help you pinpoint the exact location of the memory leak. With the LeakCanary's user-friendly interface, you can then analyze the memory leak right in your app. The most recent version of LeakCanary also includes other improvements like automatic detection of leaks in Activity, Fragment, View, ViewModel, LiveData, etc.
+ 
+LeakCanary is an open-source memory leak detection library for Android. It automatically monitors objects that should be garbage collected and reports leaks with a detailed analysis showing the reference chain causing the problem. LeakCanary is typically included only in debug builds.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # LiveData
-
-`LiveData` is a data holder class that can be observed within a given lifecycle. This means that an `Observer` can be added in a pair with a `LifecycleOwner`, and this observer will be notified about modifications of the `LiveData` object only if the associated `LifecycleOwner` is in active state. `LiveData` respects the lifecycle state of app components, such as activities, fragments, or services, and it only updates app-component observers that are in an active lifecycle state. Furthermore, `LiveData` automatically removes the observers when their associated `LifecycleOwner` moves to the `Destroyed` state. This combination of `LiveData` and `LifecycleOwner` helps you to manage appropriate and efficient updates because `LiveData` takes into consideration the lifecycle state of your app components.
+ 
+LiveData is a lifecycle-aware observable data holder from Android Jetpack. It delivers updates to UI observers only when they are in an active lifecycle state, preventing crashes from updates sent to stopped components. LiveData is commonly used to expose ViewModel state to the UI layer.

 Visit the following resources to learn more:

@@ -1,13 +1,6 @@
-# MVC or Model View Controller
-
-MVC or `Model View Controller` is a software design pattern commonly used for developing user interfaces that divides the related program logic into three interconnected components.
-
-Components:
-----------
-
-*   `Model`: The internal representations of information. This can often be an Interactor or UseCase
-*   `View`: The interface that presents information to and accepts it from the user
-*   `Controller`: The controller contains logic that updates the model and/or view in response to input from the users of the app.
+# MVC
+ 
+MVC (Model-View-Controller) is an architectural pattern that divides an application into three components: the Model holds data and business logic, the View renders the UI, and the Controller handles user input. Android does not map cleanly to traditional MVC, as Activities and Fragments often act as both View and Controller simultaneously.

 Visit the following resources to learn more:

@@ -1,10 +1,6 @@
 # MVI
-
-The **MVI** `Model-View-Intent` pattern is a reactive architectural pattern, similar to **MVVM** and **MVP**, focusing on immutability and handling states in unidirectional cycles. The data flow is unidirectional: Intents update the Model's state through the `ViewModel`, and then the View reacts to the new state. This ensures a clear and predictable cycle between logic and the interface.
-
-*   Model: Represents the UI state. It is immutable and contains all the necessary information to represent a screen.
-*   View: Displays the UI state and receives the user's intentions.
-*   Intent: The user's intentions trigger state updates, managed by the `ViewModel`.
+ 
+MVI (Model-View-Intent) is an architectural pattern where user actions are modeled as Intents that flow into the Model, which produces a new immutable State rendered by the View. It enforces strict unidirectional data flow and makes application state predictable and easy to test. MVI pairs well with Kotlin coroutines and Jetpack Compose.

 Visit the following resources to learn more:

@@ -1,12 +1,6 @@
-# MVP or Model View Presenter
-
-The MVP `Model View Presenter` pattern is a derivative of the well-known MVC `Model View Controller` pattern and is one of the most popular patterns for organizing the presentation layer in Android applications.
-
-MVP is divided into three components:
-
-*   `Model`: Responsible for managing the data input to the app. This can often be an Interactor or UseCase, handling the business logic and data operations.
-*   `View`: Takes care of updating the graphical part of the application. It acts as a passive view, only receiving data and requesting actions to be performed.
-*   `Presenter`: Handles all the logic related to the graphical interface that the View requests. It provides the View with the data it needs to display on the screen.
+# MVP
+ 
+MVP (Model-View-Presenter) is an architectural pattern where the Presenter acts as a mediator between the View and the Model. The View delegates user actions to the Presenter, which processes them and updates the View through an interface contract. MVP was widely used before MVVM and ViewModel became the recommended approach.

 Visit the following resources to learn more:

@@ -1,12 +1,6 @@
 # MVVM
-
-The `Model-View-ViewModel` (MVVM) pattern is a software architectural pattern commonly used in UI development. It is designed to separate the concerns of an application, making the code more modular, testable, and maintainable.
-
-Components:
-
-*   `Model`: Refers either to a domain model, which represents real state content (an object-oriented approach), or to the data access layer, which represents content.
-*   `View`: The view is the structure, layout, and appearance of what a user sees on the screen.
-*   `View model`: The view model is an abstraction of the view exposing public properties and commands. The view model has been described as a state of the data in the model.
+ 
+MVVM (Model-View-ViewModel) is an architectural pattern that separates the UI layer (View) from the business logic and state layer (ViewModel). The ViewModel exposes state and events, and the View observes and renders them reactively. Google recommends MVVM for Android apps and provides official support through ViewModel, LiveData, and StateFlow.

 Visit the following resources to learn more:

@@ -0,0 +1,8 @@
+# NavHost
+
+A NavHost is a special Android UI component, typically a Fragment, within your app that serves as a central point for navigating between different destinations. It's like the container that displays different parts of your app's user interface as the user moves from one screen to another. The NavHost works together with a NavController to manage the navigation flow based on a navigation graph.
+
+Visit the following resources to learn more:
+
+- [@official@Navigation with Compose  |  Jetpack Compose  |  Android Developers](https://developer.android.com/develop/ui/compose/navigation)
+- [@article@Navigation in Jetpack Compose. | by Chase | Medium](https://medium.com/@jpmtech/navigation-in-jetpack-compose-c9e1fcfd2cdd)
@@ -1,6 +1,6 @@
 # Observer Pattern
-
-The **Observer Pattern** is a software design pattern in which an object, known as the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes. This is usually done by calling one of their methods. It's mainly used for implementing distributed event handling systems and is viewed as a good practice to follow, making your design more robust, flexible, and scalable. The subject to be observed triggers events and observers react to the change or the event that they are listening to. In Android, observable libraries like `LiveData`, `RxJava`, `Flow`, and other reactive streams allow the implementation of observer pattern.
+ 
+The Observer pattern defines a one-to-many dependency where multiple observers are notified automatically when a subject changes state. In Android, this pattern is the foundation of reactive data streams implemented through LiveData, Kotlin Flow, RxJava, and RxKotlin.

 Visit the following resources to learn more:

@@ -1,8 +1,6 @@
 # Pick a Language
-
-When developing for Android, one crucial step is picking a programming language to use. There are multiple languages you can choose from, but the three most popular ones are Java, Kotlin, and C++.
-
-Java is the original language used for Android development and is widely used, making it a good choice for beginners due to the wealth of resources and developer communities. Kotlin is a newer option that is fully supported by Google and Android Studio, and addressing many of the drawbacks of Java which makes it a popular choice for many developers.
+ 
+Android development primarily uses Kotlin and Java. Kotlin is Google's officially preferred language since 2019, but Java remains fully supported and is still present in many existing codebases and libraries.

 Visit the following resources to learn more:

@@ -0,0 +1,8 @@
+# remember / State
+ 
+remember is a Compose function that retains a value across recompositions within a composable. Combined with mutableStateOf, it creates a state holder that triggers recomposition when its value changes. Local state managed with remember is suitable for UI-only state that does not need to survive configuration changes.
+
+Visit the following resources to learn more:
+
+- [@official@State and Jetpack Compose](https://developer.android.com/develop/ui/compose/state)
+- [@article@Understanding remember in Jetpack Compose: A Deep Dive from First Principles](https://medium.com/@sandeepkella23/understanding-remember-in-jetpack-compose-a-deep-dive-from-first-principles-2587b2098323)
@@ -1,6 +1,6 @@
 # Remote Config
-
-Firebase Remote Config is a cloud service offered by Firebase. It lets you change the behavior and appearance of your app without requiring a new app release. By using Firebase Remote config, you can customize your app for different user segments, manage the core aspects of your app by modifying parameters externally, and conduct A/B tests to improve your app. It works efficiently by using default values that control the behavior and appearance of your app. When your app needs configuration information, it makes a request to the Firebase Remote Config server. If the server has updated values, these values replace the default ones, hence modifying the app's behavior or appearance according to your needs.
+ 
+Firebase Remote Config allows developers to change the behavior and appearance of an Android app without publishing an app update. Configuration values are stored in the cloud and fetched at runtime. It is commonly used for A/B testing, feature flags, and gradual feature rollouts.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Room Database
-
-"Room" is a persistence library introduced by Google that provides an abstraction layer over SQLite to help with robust database access while harnessing the full power of SQLite. Room supports the creation of databases and defines queries in compile-time-checked SQL strings. These databases belong to the data classes that you create representing your app's data. Room comprises three main components: **Database**, a container that holds your app's data tables; **Entity**, representing a table within the database; and **DAO (Data Access Object)**, containing SQL query methods to interact with the database.
+ 
+Room is an Android Jetpack library that provides an abstraction layer over SQLite. It uses annotations to define database entities, Data Access Objects (DAOs), and queries, and it verifies SQL at compile time. Room integrates with coroutines and Flow for reactive, asynchronous database access.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # RxKotlin
-
-`RxKotlin` is a lightweight language extension to Java for Android development, enabling Android apps to be built using Kotlin with Reactivex. It brings the power of reactive programming paradigm to Kotlin, extending its capabilities for processing asynchronous streams of data. It allows you to express static (e.g., already known) or dynamic (e.g., future unknown) data streams, and perform various operations on them easily. Key concepts of `RxKotlin` include Observables, Observers and Schedulers. Observables represent the data streams, Observers interact with the data stream, and Schedulers determine on which thread operations are performed. RxKotlin helps manage background tasks, handle asynchronous data streams, and implement complex UIs, among others.
+ 
+RxKotlin is a lightweight Kotlin extension library for RxJava. It adds idiomatic Kotlin extension functions and DSL-style utilities for working with RxJava observables. Developers use RxKotlin to write more natural Kotlin code when building reactive streams in Android.

 Visit the following resources to learn more:

@@ -7,7 +7,4 @@ Visit the following resources to learn more:
 - [@official@Security checklist](https://developer.android.com/privacy-and-security/security-tips)
 - [@official@Improve your app's security](https://developer.android.com/privacy-and-security/security-best-practices)
 - [@official@Cryptography](https://developer.android.com/privacy-and-security/cryptography)
- [@official@Android Keystore system](https://developer.android.com/privacy-and-security/keystore)
- [@article@18 Android security settings that will strengthen your protection](https://www.computerworld.com/article/1718177/android-settings-security.html)
- [@video@Top 4 Security Best Practices for Your Android App](https://www.youtube.com/watch?v=VQvfvXD3ec4)
- [@video@1 Full Free Android Application Security Course](https://www.youtube.com/watch?v=io2lCB5Tc6A&list=PLwOCu7hSL9MqBeEZUgV5-6n3z4Xw-yaMr)
+- [@official@Android Keystore system](https://developer.android.com/privacy-and-security/keystore)
@@ -1,6 +1,6 @@
 # Services
-
-**Services**: A service in Android is an app component that performs operations in the background without a user interface. It can be started by an application component, like an activity, and it will continue to run in the background even if the user switches to another application. There are two types of services in Android, namely, `Started Service` and `Bound Service`. A `Started Service` is used to perform a single operation, such as downloading a large file. On the other hand, a `Bound Service` offers a client-server interface that allows components to interact with the service, send requests, receive results, and even perform interprocess communication (IPC).
+ 
+A Service is an app component that performs long-running operations in the background without a user interface. Services handle tasks like playing music, downloading files, or processing data while the user interacts with other apps. Android provides foreground services, background services, and bound services depending on the use case.

 Visit the following resources to learn more:

@@ -0,0 +1,8 @@
+# Side Effects
+
+In Jetpack Compose, side effects are actions that occur outside the composable function itself, such as updating a database, making a network request, or using shared mutable state. Compose recomposes when its inputs change and to avoid unpredictable behaviour, any code that interacts with the outside world needs to be carefully controlled, so Side Effects is a way for doing it in a predictable and testable manner. They should be isolated and handled in a controlled way to maintain the predictability and reliability of your UI.
+
+Visit the following resources to learn more:
+
+- [@official@Side-effects in Compose  |  Jetpack Compose  |  Android Developers](https://developer.android.com/develop/ui/compose/side-effects)
+- [@article@Complete Guide to Side Effects in Jetpack Compose](https://proandroiddev.com/complete-guide-to-side-effects-in-jetpack-compose-5be32b09514a)
@@ -1,6 +1,6 @@
 # Signed APK
-
-A **Signed APK** is a version of your app that you prepare for distribution in the Play Store or other Android markets. When you sign your app using a private key, you authenticate your identity as the developer of the app. It is a required step by the Android system that ensures only updates to the APK that are from the original developer will be accepted. The Android system refuses to install an app if it's not signed appropriately, thereby protecting users from potential security risks.
+ 
+A signed APK is an Android application package that has been digitally signed with a developer's certificate. Signing is required before an app can be published to the Google Play Store. The signing process verifies the app's authorship and ensures that future updates come from the same developer.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # State Changes
-
-"Activity" is a crucial component that represents a single screen with a user interface. One or more active activities make up an Application. These activities can go through different states in their lifecycle, often due to user interaction or system interruption. The primary states of an Activity include `Created`, `Started`, `Resumed`, `Paused`, `Stopped`, `Restarted`, and `Destroyed`. The "Created" state occurs when an activity instance is being created. The "Started" state is when the activity is visible to the user, while "Resumed" is when the activity is interacting with the user. An activity is "Paused" when it loses focus but is partly visible, "Stopped" when it's not visible, "Restarted" when the activity is about to be started, and "Destroyed" when the activity is finished or the system is temporarily destroying it.
+ 
+State changes occur when an Activity transitions between lifecycle states due to user actions or system events. Common triggers include pressing the Home button, rotating the device, or receiving a phone call. Android developers must save and restore UI state during these transitions to prevent data loss.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
-# Tasks and Backstack
-
-The **tasks backstack** in Android refers to the way Android manages and arranges tasks in a stack-like structure. Every task has a stack of activities, which is referred to as the task's back stack. The activities are placed in the order they are opened. When a new activity is started, it is placed at the top of the stack and becomes the running activity, while the previous activity is paused and put into the back stack. When you press the back button, the current activity is destroyed and the activity at the top of the back stack becomes active again. Android defines how to navigate between tasks and activities using this back stack concept.
+# Tasks & Backstack
+ 
+A task is a collection of activities that the user interacts with to accomplish a goal, and the back stack keeps track of the order in which those activities were opened. When the user presses Back, activities are popped off the stack in reverse order. Understanding task and back stack behavior is important for building predictable navigation flows.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Testing
-
-**Testing** is a crucial part of the app development process. It involves validating the functionality, performance, usability, and consistency of your app before deploying it to the Play Store. There are two types of testing methods notably used: **Unit testing** and **Instrumentation Testing**. Unit testing, as the name suggests, tests each unit or segment of your code separately. It doesn't require Android dependencies and hence, runs faster. Instrumentation testing, on another hand, requires Android dependencies and is slower. Instrumentation testing tests the UIs, simulates user interactions and validates the navigation between different parts of your app. Android provides built-in testing frameworks like `JUnit` for unit testing and `Espresso` for Instrumentation testing.
+ 
+Testing in Android ensures that app code behaves correctly and that UI interactions work as expected. JUnit is used for unit testing business logic, while Espresso handles UI testing by simulating user interactions on a device or emulator.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # The Fundamentals
-
-"The Fundamentals" of Android primarily concentrate on 5 components; Activities, Services, Broadcast Receivers, Content Providers, and Intents. **Activities** are essentially what you see on your screen; each screen in an app is a separate activity. **Services** run in the background to perform long-running operations or to perform work for remote processes. They do not provide a user interface. **Broadcast Receivers** respond to broadcast messages from other applications or from the system itself. These messages are often in the form of Intents. **Content Providers** manage a shared set of app data that other apps can query or modify, through a structured interface. Finally, **Intents** are messaging objects which facilitate the communication between the aforementioned components. Understanding these five core concepts is key to mastering Android fundamentals.
+ 
+The fundamentals cover the core programming and tooling concepts needed before building Android apps. This includes understanding Kotlin or Java basics, object-oriented programming principles, data structures and algorithms, Gradle as the build system, and how to set up a working development environment.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Threads
-
-In Android, a `Thread` is a concurrent unit of execution. It has its own call stack, but can share its state with other threads in the same process, i.e., they can share the same memory area. They're primarily used in Android to perform operations in the background. One important aspect to note is that Android UI operations are not thread-safe, meaning they should always be done on the UI thread. Operations on `Threads` are typically managed through `Handler`, `Looper` and `MessageQueue` classes. Android also provides high-level constructs like `AsyncTask` and `Loader` for managing threads in relation to the UI.
+ 
+Threads are the basic unit of concurrency in the JVM. Android runs UI operations on the main thread and requires network, database, and other slow operations to run on background threads. Developers use Thread, Handler, Executors, or HandlerThread to manage background work at the thread level.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Timber
-
-`Timber` is a logging utility tool that has been specifically extended from the `Log` class of Android. It has been built to simplify the logging process while aiming to reduce the amount of boilerplate code the developer has to write. It was designed and is maintained by Jake Wharton, a renowned contributor in the Android Developer community. In Timber, each log message is directed to the next available logger, reducing the redundancy of manually assigning log tags. The simplicity of Timber is highlighted by its ability to log without defining any tag. Most importantly, Timber only logs messages in debug builds by default, avoiding potential data leaks in your production application.
+ 
+Timber is a logging utility library for Android built on top of the standard android.util.Log API. It provides a cleaner logging interface, automatically includes class names in log tags, and makes it easy to control logging behavior per build variant. In release builds, logging can be suppressed or redirected to a crash reporting service.

 Visit the following resources to learn more:

@@ -1,9 +1,9 @@
-# Version Control Systems
-
-_Version Control_ is a system that records changes to a file or set of files over time so that you can recall specific versions later. An essential tool for software development, it helps to track changes, enhance collaboration, and manage different versions of a project. Two common types of version control systems are Centralized Version Control System (CVCS) and Distributed Version Control System (DVCS). CVCS uses a central server to store all versions of a project, with users getting snapshots from that server. Examples include SVN and Perforce. On the other hand, DVCS allows multiple developers to work on a single project simultaneously. Each user has a complete backup of all versions of the work. Examples include Git and Mercurial.
+# Version Control
+ 
+Version control systems track changes to code over time and enable collaboration among developers. In Android development, Git is the standard version control tool, and platforms like GitHub, GitLab, and Bitbucket are used to host and manage repositories.

 Visit the following resources to learn more:

- [@video@What is Git? Explained in 2 minutes](https://www.youtube.com/watch?v=2ReR1YJrNOM)
+- [@course@What is Git? (Interactive Lesson)](https://inter-git.com/lessons/introduction)
 - [@article@Version Control Systems](https://en.wikipedia.org/wiki/Version_control)
- [@course@What is Git? (Interactive Lesson)](https://inter-git.com/lessons/introduction)
+- [@video@What is Git? Explained in 2 minutes](https://www.youtube.com/watch?v=2ReR1YJrNOM)
@@ -0,0 +1,8 @@
+# ViewModel State
+
+ViewModel state refers to the data held within a ViewModel class that persists across configuration changes, such as screen rotations. It allows your UI data to survive these changes, preventing the need to re-fetch or re-create it every time the activity or fragment is recreated. This data is typically observed by the UI, which updates itself automatically whenever the state changes, ensuring a consistent user experience.
+
+Visit the following resources to learn more:
+
+- [@official@ViewModel and State in Compose](https://developer.android.com/codelabs/basic-android-kotlin-compose-viewmodel-and-state#0)
+- [@article@Compose State vs ViewModel: Complete Android Developer Guide 2025](https://www.brahimoubbad.com/2025/05/compose-state-vs-viewmodel-complete.html)
@@ -1,11 +1,10 @@
 # What is and how to use Gradle?
-
-Gradle is a powerful build system used in Android development that allows you to define your project and dependencies, and distinguish between different build types and flavors. Gradle uses a domain-specific language (DSL) which gives developers almost complete control over the build process. When you trigger a build in Android Studio, Gradle is the tool working behind the scenes to compile and package your app. It looks at the dependencies you declared in your build.gradle files and create a build script accordingly. Using Gradle in Android development requires continuous editing of the build.gradle files to manage app dependencies, build variants, signing configurations, and other essential aspects related to building your app.
+ 
+Gradle is the build system used in Android projects to compile code, manage dependencies, and package applications. It uses Groovy or Kotlin DSL scripts to define project configuration. Android Studio generates Gradle files automatically, but understanding how to modify them is needed for adding libraries, setting build variants, and configuring app signing.

 Visit the following resources to learn more:

 - [@official@Gradle Build Tool](https://docs.gradle.org/current/userguide/userguide.html)
 - [@official@Gradle Documentation](https://docs.gradle.org/current/userguide/getting_started_eng.html)
 - [@video@Gradle Course for Beginners - 55minutes](https://www.youtube.com/watch?v=R6Z-Sxb837I)
- [@video@Introduction to Gradle for Complete Beginners - 25minutes](https://youtu.be/-dtcEMLNmn0?si=NuIP-3wNpUrxfTxA)
- [@feed@Explore top posts about Gradle](https://app.daily.dev/tags/gradle?ref=roadmapsh)
+- [@video@Introduction to Gradle for Complete Beginners - 25minutes](https://youtu.be/-dtcEMLNmn0?si=NuIP-3wNpUrxfTxA)
@@ -1,6 +1,6 @@
 # WorkManager
-
-`WorkManager` is an Android library introduced by Google to execute tasks in a predictable and reliable manner. It's designed for tasks that require guaranteed execution, even if the app has been closed or the device restarts. It is backwards compatible up to API 14 and uses JobScheduler for API 23 and above, whilst using a combination of BroadcastReceiver + AlarmManager for APIs 14 and up. Regardless of the device API level, WorkManager works for all Android devices. Three types of work are supported by WorkManager - OneTimeWorkRequest, PeriodicWorkRequest, and DelayedWorkRequest.
+ 
+WorkManager is a Jetpack library for scheduling deferrable, guaranteed background work. It supports constraints like requiring network connectivity or charging, survives app restarts and device reboots, and allows chaining multiple tasks together. WorkManager is the recommended solution for background work that must run reliably regardless of app lifecycle.

 Visit the following resources to learn more: