/FetchAPI

This Android app, built with Jetpack Compose and MVVM architecture, showcases efficient network communication using Retrofit and Kotlin Coroutines. It demonstrates state-of-the-art practices for fetching and displaying data, including handling images and API responses.

Primary LanguageKotlinMIT LicenseMIT

Android Jetpack Compose App with Retrofit

Overview

This repository contains a simple Android application developed using Jetpack Compose. The app demonstrates how to fetch and display data from a REST API using Retrofit, handle states with Kotlin Coroutines, and display images from URLs using the Coil library.

Features

  • Jetpack Compose UI: Modern UI design with the latest Compose toolkit.
  • Retrofit for Network Calls: Utilizes Retrofit for making API calls.
  • Kotlin Coroutines: Leverages Coroutines for asynchronous operations and state management.
  • Coil for Image Loading: Uses Coil to load and display images from the web.
  • State Handling: Implements state handling using mutable states in ViewModels.
  • Error Handling: Robust error handling during network operations.

Libraries Used

  • androidx.*: Core AndroidX libraries and Compose UI toolkit.
  • com.squareup.retrofit2:retrofit: For network operations.
  • com.jakewharton.retrofit:retrofit2-kotlinx-serialization-converter: Converter for serialization with Retrofit.
  • com.squareup.okhttp3:logging-interceptor: For logging network requests.
  • org.jetbrains.kotlinx:kotlinx-coroutines-android: For managing background tasks with Kotlin Coroutines.
  • io.coil-kt:coil-compose: For image loading in Compose.
  • com.github.skydoves:retrofit-adapters-*: Custom adapters for Retrofit responses.

Architecture

This application is built using the Model-View-ViewModel (MVVM) architecture, integrated with modern Android development tools and practices. The architecture is designed to provide a clear separation of concerns, promote a scalable and maintainable codebase, and enhance the developer and user experience.

Key Components

  • ViewModel (MainViewModel):

    • Manages the UI-related data and state in a lifecycle-aware manner.
    • Handles business logic, such as fetching data from the repository.
    • Communicates with the View through observable state (mutableStateOf).

  • View (MainActivity, UserContent Composable):

    • Responsible for rendering the UI and reacting to state changes.
    • Interacts with the ViewModel to send user actions and display data.
    • Built using Jetpack Compose, a modern, declarative UI toolkit.

  • Model (GitHubUser):

    • Represents the data structure for user profiles fetched from the API.

  • Repository (GitHubRepository, GitHubRepositoryImpl):

    • Abstracts the data source from the ViewModel.
    • Handles data fetching operations, providing a clean API to the ViewModel.
    • Uses Retrofit for efficient network communication.

  • Network Layer (RetrofitBuilder, GitHubService):

    • Configures Retrofit for network operations.
    • Defines the API endpoints.

Design Patterns and Practices

  • Repository Pattern:

    • Encapsulates the logic for data retrieval and provides a clean separation between the data layer and the ViewModel.

  • State Management:

    • Uses mutableStateOf for reactive UI updates, ensuring the UI is consistent with the app's state.

  • Error and Loading State Management:

    • Manages loading and error states to enhance user experience.

  • Kotlin Coroutines:

    • Handles asynchronous operations, providing a more readable and efficient way to manage background tasks.

Best Practices

  • Lifecycle Awareness: ViewModel's lifecycle-aware nature prevents memory leaks and efficiently manages UI-related data.
  • Testing: Each component is designed to be easily testable, promoting reliable and maintainable code.
  • Dependency Injection: (If used) Utilizes Dagger-Hilt for managing dependencies, enhancing scalability and maintainability.
  • Modularization: (If applicable) The project structure supports modularization, making it easier to manage and scale the application.

Setup

To run this project:

  1. Clone this repository.
  2. Open the project in Android Studio.
  3. Run the project using an emulator or a physical device.

Usage

The main functionality of the app is to fetch user data from a given API endpoint. The app uses Retrofit to make network requests, Coroutines for asynchronous operations, and Coil to load images.

  1. Enter a username to fetch data for.
  2. Press the "Fetch User Data" button.
  3. View the displayed user information and image.

Contribution

Contributions are welcome. Please feel free to submit a pull request or open issues to improve the app or suggest enhancements.