How su92-bscsm-f25-196-droid/innoviast- works
1. This repository is an Android app in Kotlin, not a Flutter app as the README text suggests. The code tree shows a single app module built with Gradle, using Android UI, local persistence, and one explicit external API integration.
2. The app’s entry point is MainActivity, which likely hosts the top-level Compose UI and screen navigation. AndroidManifest.xml defines the Android app wiring, while build.gradle.kts and the version catalog control dependencies and build setup.
3. The presentation layer is organized under ui/ and is split into reusable UI pieces, screens, view models, and theme. ui/components contains shared widgets, ui/screens contains feature pages, and ui/theme defines the Material styling, colors, and typography.
4. The screen set reflects the product’s LMS/ERP shape: login, dashboards, academic modules, chat modules, and report modules. These are the user-facing boundaries that would map to architecture diagram boxes for role-based areas and functional modules.
5. State management is handled by ViewModels in ui/viewmodel: AuthViewModel, LmsViewModel, and AiAssistantViewModel. This creates the main UI-to-data boundary: screens observe view-model state and invoke actions, rather than talking directly to data sources.
6. The data layer centers on LmsRepository, which is the main orchestration point for app data access. This repository likely abstracts remote calls, local persistence, and business-oriented data shaping so the UI layer stays thin.
7. Local storage is present through data/local/AppDatabase and the entity definitions in data/model/Entities.kt. That indicates an offline-capable or cache-backed architecture, where structured app data is persisted locally rather than relying only on live network access.
8. Remote/external integration is explicit in data/api/GeminiApi.kt. This is the clearest non-UI external dependency in the tree and likely powers the AI assistant feature described in the README. The assets/.aistudio and .env.example files suggest configuration or credential handling for that integration.
9. The main data flow is: user action in a screen -> ViewModel state/event handling -> repository logic -> local database and/or Gemini API -> updated state back to the UI. That flow is repeated across login, LMS screens, and AI assistant interactions.
10. The README describes a much broader enterprise LMS with admin, HOD, teacher, and student roles, but the current code tree only shows the mobile client structure for those experiences. There is no visible backend service in this repo, so any server, authentication provider, or file/storage infrastructure should be drawn only if sourced from external systems not present here.
11. Testing is split between unit tests and Android instrumentation tests under app/src/test and app/src/androidTest. That suggests standard Android verification around UI and logic, but not a separate test service or backend pipeline.
12. Overall, the architecture is a layered mobile client: Android/Compose UI at the top, ViewModels in the middle, a repository/data layer beneath, and local Room-like persistence plus a Gemini-powered AI endpoint as the main technical integrations.
Main entry points: LmsRepository.kt LMS repository · screens Screens · ui UI layer · build.gradle.kts App build
Components 20
Build & Config
Gradle, manifest, and repo-level configuration that wire the Android app.
- Root build · Top-level Gradle build and project settings.
build.gradle.kts - App build · Module-level Android/Kotlin build configuration.
app/build.gradle.kts - Versions · Central dependency and plugin version catalog.
gradle/libs.versions.toml - Manifest · Declares the Android app entry points and app-level wiring.
app/src/main/AndroidManifest.xml
Android App
Main app module with UI, state, data, and resources.
- MainActivity · Application entry point and likely Compose host/navigation root.
app/src/main/java/com/example/MainActivity.kt - UI layer · Reusable UI, screens, view models, and theme resources.
app/src/main/java/com/example/ui - Components · Common reusable UI building blocks.
app/src/main/java/com/example/ui/components/CommonComponents.kt - Screens · User-facing LMS pages for login, dashboards, academic, chat, and reports.
app/src/main/java/com/example/ui/screens - Theme · Colors, typography, and app theme definitions.
app/src/main/java/com/example/ui/theme - Auth VM · Login and authentication-related UI state and actions.
app/src/main/java/com/example/ui/viewmodel/AuthViewModel.kt - LMS VM · Core LMS screen state and user interactions.
app/src/main/java/com/example/ui/viewmodel/LmsViewModel.kt - AI VM · Assistant feature state and request handling.
app/src/main/java/com/example/ui/viewmodel/AiAssistantViewModel.kt - LMS repository · Primary data access and business-facing coordination layer.
app/src/main/java/com/example/data/repository/LmsRepository.kt - App database · Local persistence boundary for cached/offline app data.
app/src/main/java/com/example/data/local/AppDatabase.kt - Entities · Structured local records used by persistence and app logic.
app/src/main/java/com/example/data/model/Entities.kt - Gemini API · External AI integration used by the assistant feature.
app/src/main/java/com/example/data/api/GeminiApi.kt - AI config · Local AI Studio and environment configuration hints.
assets/.aistudio
Tests
Unit and instrumentation verification for the mobile client.
- Unit tests · Local logic verification for app code.
app/src/test/java/com/example - Android tests · On-device/instrumented UI and integration verification.
app/src/androidTest/java/com/example
Other components
- Repository · Kotlin Android client for LMS/ERP-style workflows with AI integration.
Connections 23
- Repository → Root build: configured by · Repository-level Gradle setup governs the project.
- Repository → App build: contains · Android app module is the core deliverable.
- Repository → Manifest: wired by · Android entry wiring is declared in the manifest.
- Root build → Versions: uses · Root build consumes the version catalog.
- App build → Versions: uses · Module dependencies and plugins are versioned centrally.
- Manifest → MainActivity: launches · Manifest points to the app entry activity.
- MainActivity → UI layer: hosts · Activity likely hosts the top-level Compose UI and navigation.
- UI layer → Components: reuses · Shared widgets support multiple screens.
- UI layer → Screens: contains · Feature screens make up the visible product surface.
- UI layer → Theme: styles · Theme defines the visual system for the UI.
- Screens → Auth VM: observes · Login flow binds to authentication state.
- Screens → LMS VM: observes · Core LMS pages bind to LMS state.
- Screens → AI VM: observes · Chat/assistant screens bind to assistant state.
- Auth VM → LMS repository: calls · Authentication actions flow through the repository boundary.
- LMS VM → LMS repository: calls · LMS data and actions are coordinated through the repository.
- AI VM → LMS repository: calls · Assistant workflows route through the repository as needed.
- LMS repository → App database: reads/writes · Repository manages local persistence.
- LMS repository → Entities: maps · Repository operates on local structured models.
- LMS repository → Gemini API: integrates · Repository reaches the external AI endpoint for assistant features.
- Gemini API → AI config: configured by · AI access is guided by local configuration/credential files.
- LMS repository → Screens: feeds · Data updates propagate back to UI state through view models.
- Unit tests → App build: verifies · JVM tests validate application logic.
- Android tests → MainActivity: verifies · Instrumentation tests cover the Android entry/UI path.