MVVM Architecture and Package Structure with Jetpack Compose

Hello everyone! In this article, we will discuss how to organize the package structure for projects created using Jetpack Compose following the MVVM (Model-View-ViewModel) architecture. Let’s assume the integration of popular libraries such as Hilt, Room, and Retrofit. By doing so, we’ll establish a proper project structure to make development more manageable.

MVVM Architecture

MVVM architecture enables better code readability and easier maintenance by separating concerns between data, user interface, and business logic.

Project Package Structure

When creating the project package structure, it is essential to achieve an organized and sustainable codebase. Below, you can find an example of a package structure:

data Package

This package encompasses the data layer of the application. It handles database operations, preferences, and data sources.

• local Package: Manages local database operations.
• database Package: Provides access to the application database.
• dao Package: Contains Data Access Object (DAO) classes that perform database operations.
• UserDao.kt: DAO class for user data.
• entity Package: Defines entity classes representing data in the database.
• UserEntity.kt: Entity class representing user data.
• pref Package: Manages application preferences.
• AppPreferences.kt: Class holding application preferences.
• repository Package: Contains repository classes managing local database operations.
• LocalRepository.kt: Main repository class managing local database operations.
• remote Package: Manages interaction with remote servers.
• api Package: Defines the API service for communication with the remote server.
• ApiService.kt: API service for remote server communication.
• model Package: Contains classes representing data received from the remote server.
• UserApiResponse.kt: Class representing user data received from the remote server.
• repository Package: Contains repository classes managing remote server operations.
• RemoteDataRepository.kt: The main repository class managing remote server operations. (If the technology or library used is compatible with sync processes, a more specific expression can be used under this title, such as “Remote Repository.”)
• NetworkBoundResource.kt: Helper class managing network-bound resource handling.
• repository Package: Manages general data operations for the application.
• DataRepository.kt: Main repository class combining access to local and remote data sources.

di Package

This package manages dependency injection using Dagger Hilt. Module classes provide dependencies used throughout the application.

• AppModule.kt: Provides general dependencies at the application level.
• DatabaseModule.kt: Manages database dependencies.
• NetworkModule.kt: Provides dependencies for network connectivity.

ui Package

This package is responsible for the user interface components of the application. It has been updated to include three new sub-packages: main, detail, and userProfile.

• main Package: Manages the main screen of the application.
• MainScreen.kt: Class managing the main screen's logic and appearance.
• MainViewModel.kt: ViewModel class for the main screen.
• detail Package: Manages the detail screen of the application.
• DetailScreen.kt: Class managing the detail screen's logic and appearance.
• DetailViewModel.kt: ViewModel class for the detail screen.
• userprofile Package: Manages the user profile screen of the application.
• UserProfileScreen.kt: Class managing the user profile screen's logic and appearance.
• UserProfileViewModel.kt: ViewModel class for the user profile screen.

util Package

This package contains utility classes used throughout the application.

• DateUtil.kt: Utility class for date and time operations.

model Package

This package contains data models used throughout the application.

• User.kt: Base user data model.
• UserProfile.kt: User profile data model.

This package structure organizes project files based on functionality and layers. It supports a sustainable codebase as the project grows by adding screens and features. Using tools like Dagger Hilt for managing dependencies across the application ensures the application architecture is modular and testable, making maintenance and extension easier.

This article aims to guide developers new to Android app development with Jetpack Compose and MVVM architecture. Happy coding!

Stackademic

Thank you for reading until the end. Before you go:

• Please consider clapping and following the writer! 👏
• Follow us on Twitter(X), LinkedIn, and YouTube.
• Visit Stackademic.com to find out more about how we are democratizing free programming education around the world.