Android Application with API Integration

I'll help you create an Android application using traditional XML layouts with MVVM architecture and Hilt for dependency injection. Let's break down the implementation step by step.

Project Structure

Let's start by setting up a well-organized project structure following clean architecture principles:

Implementation Details

1. Architecture Overview

This Android application follows the MVVM (Model-View-ViewModel) architecture pattern with clean architecture principles:

• UI Layer: Activities and Fragments with ViewModels
• Domain Layer: Repositories that coordinate data from different sources
• Data Layer: API services and data models

2. Key Components

Login Flow

• The app tries all three authentication endpoints (footscray/auth, sydney/auth, ort/auth) until one succeeds
• Upon successful login, the keypass is stored and used for subsequent API calls
• Error handling is implemented for failed login attempts

Dashboard

• Uses RecyclerView with a custom adapter to display entities
• Implements click listeners to navigate to the details screen
• Shows entity count and handles loading states

Details Screen

• Displays all information about the selected entity in a clean layout
• Properly formats the description for readability

3. Dependency Injection

Hilt is used for dependency injection throughout the application:

• Network module provides Retrofit, OkHttp, and Moshi instances
• Repositories are injected into ViewModels
• ViewModels are injected into Fragments

4. Testing

The project includes unit tests for ViewModels to ensure business logic works correctly:

• Tests for successful and failed login attempts
• Tests for dashboard data fetching
• Uses MockitoKotlin for mocking dependencies

How to Run the Project

1. Clone the repository to your local machine
2. Open the project in Android Studio
3. Sync Gradle files and build the project
4. Run the app on an emulator or physical device

To log in, use your first name as the username and your student ID (format: s12345678) as the password.

Next Steps

To further enhance this project, you could:

1. Add more comprehensive error handling
2. Implement data caching for offline support
3. Add UI animations for better user experience
4. Expand test coverage with UI tests using Espresso
5. Implement a more robust state management system

This implementation satisfies all the requirements specified in the project brief, including dependency injection, clean code principles, and unit testing.

Gradle Configuration for Android Project

I'll create both the project-level and module-level Gradle files needed for an Android application.

Project-Level Gradle Files

Explanation of Gradle Configuration

Project-Level Configuration

1. settings.gradle

   • Configures repository sources (Google, Maven Central)
   • Sets the project name and includes the app module

2. build.gradle (Project)

   • Defines common version variables for dependencies
   • Sets up build script dependencies including Kotlin, Hilt, and Navigation
   • Configures clean task

Module-Level Configuration

3. build.gradle (App)

   • Applies necessary plugins (Android, Kotlin, Kapt, Parcelize, Hilt, Navigation)

   • Configures Android build settings:

     • SDK versions (compile, min, target)
     • Application ID and version info
     • Build types with environment-specific configurations
     • Java compatibility settings
     • View binding
     • Test options

4. Dependencies

   • Core Android libraries
   • Architecture Components (ViewModel, LiveData)
   • Navigation Components
   • Dependency Injection with Hilt
   • Networking with Retrofit and OkHttp
   • JSON parsing with Moshi
   • Image loading with Glide
   • Local storage with Room
   • Preferences with DataStore
   • Logging with Timber
   • Testing libraries (JUnit, Mockito, Espresso)

5. gradle.properties

   • Performance optimizations (parallel builds, daemon, caching)
   • AndroidX configuration
   • Kotlin code style settings
   • R8 and Kapt optimizations

6. proguard-rules.pro

   • Rules to properly shrink and obfuscate code
   • Specific rules for libraries like Retrofit, Moshi, Glide, etc.

Gradle Wrapper

7. gradle-wrapper.properties

   • Specifies the Gradle version to use (7.5)
   • Ensures consistent builds across different environments

This configuration provides a solid foundation for a modern Android application with all the necessary tools for development, testing, and optimization.