TaskVault 🗂️

"Productivity is never an accident; it is always the result of intelligent effort." — John Ruskin

TaskVault is a modular Android productivity app built with Kotlin, Jetpack Compose, and Firebase. The codebase is proudly co-created by Anthropic Claude Code and GitHub Copilot 🤝, while weaving in my personal suite of 40 cloud-native skills that live across complementary repositories in this ecosystem.

🤖 AI Co-Creation & Cloud Expertise

• 🤝 Dual AI pairing: Claude Code crafts architectural scaffolding while Copilot accelerates idiomatic Kotlin + Compose implementations.
• ☁️ 40 specialized cloud skills: Messaging, observability, identity, networking, data pipelines, and DevSecOps recipes referenced from sister repos plug directly into TaskVault.
• 🔐 Federated knowledge base: Shared IaC templates, Terraform modules, and policy packs flow into this project via Git submodules and Gradle convention plugins.

⚙️ Overview

TaskVault blends an offline-friendly task engine with real-time sync, proactive widgets, and an on-demand camera feature for capturing visual context. The experience spans Compose screens, background jobs, and app widgets that stay perfectly in sync with repository updates.

✨ Skills & Technology Highlights

• 🧩 Kotlin + Jetpack Compose for declarative UI, adaptive layouts, and Material 3 components.
• 🧱 Clean multi-module architecture (core + feature modules) for clear separation of concerns.
• 🧪 Koin for dependency injection across app, background work, and dynamic features.
• 💾 Room + DataStore + Paging 3 deliver offline-first persistence, token storage, and infinite scrolling lists.
• 🌐 Ktor client enables API access with serialization via kotlinx.serialization.
• 🔥 Firebase suite (Analytics, Crashlytics, FCM, Remote Config) wired through the BOM and Gradle plugins.
• 🔁 WorkManager + App Startup power scheduled sync, notifications, and widget refresh orchestration.
• 📸 Play Feature Delivery & CameraX load the camera module on demand while reusing Compose UI.
• 🪟 App Widget framework uses a repository decorator that refreshes widgets after every task mutation.
• 🛠️ CI-ready Gradle setup with shared version catalog (gradle/libs.versions.toml) and build-logic module for conventions.

🏗️ Architecture Overview

+-----------------------------+            +----------------------+ 
| Feature UI (Compose)       |  actions   | WidgetUpdateManager  |
| app + feature/* modules    +------------> keeps widgets synced |
+--------------+--------------+            +----------+-----------+
               | ViewModels use Koin                   |
               v                                       v
        +------+-------------------+       +----------+-----------+
        | core:domain (use cases) |<-----> | core:data (Room +   |
        +------+-------------------+       | Ktor + DataStore)    |
               |                                |        |
               v                                |        v
        +------+---------------------+          |   Background sync
        | core:common (models, utils)|          |   via WorkManager
        +----------------------------+          |        |
                                                v        v
                                         Local DB    Remote APIs

• 🎨 UI layer: app hosts navigation, theming, and host-level DI; feature modules (feature/auth, feature/tasklist, feature/taskdetail, feature/premium, feature/settings, feature/camera) own screens and logic.
• 🧠 Domain layer: core/domain provides use cases, paging flows, and business rules shared across UI, widgets, and background tasks.
• 📡 Data layer: core/data coordinates Room, DataStore, Ktor, Play Services location, and WorkManager to expose Flow + PagingData streams.
• 🧰 Shared utilities: core/common and core/ui centralize design tokens, result wrappers, and reusable Compose components.

📁 Project Structure

TaskVault/
├── app/                     # Android application module (navigation, DI, widgets, startup)
├── build-logic/             # Convention plugins & Gradle helpers
├── core/
│   ├── common/              # Shared models, result wrappers, utilities
│   ├── data/                # Repository implementations, Room, Ktor, DataStore
│   ├── domain/              # Use cases, paging contracts, business rules
│   └── ui/                  # Design system, reusable Compose components
├── feature/
│   ├── auth/                # Authentication flows
│   ├── camera/              # Play Feature Delivery dynamic module with CameraX
│   ├── premium/             # Subscription upsell & feature gating
│   ├── settings/            # Preferences, remote config toggles
│   ├── taskdetail/          # Task details, comments, reminders
│   └── tasklist/            # Inbox, filters, bulk actions
├── screens/                 # Exported app screenshots referenced by this README
├── gradle/                  # Version catalog + wrapper configuration
└── settings.gradle.kts      # Module wiring

🔧 Key Modules

Module	Responsibility
app	Hosts the Compose navigation graph, DI entry points, widget provider, Firebase setup, and WorkManager initializers.
core:data	Implements repositories with Room, Ktor, Security Crypto, and Paging integrations.
core:domain	Defines entities, use cases, and paging utilities consumed by UI and background layers.
core:common	Provides shared result types, error modeling, and extensions.
core:ui	Collects theming, typography, animations, and reusable Compose atoms/molecules.
feature:*	Each module encapsulates feature-specific screens, ViewModels, and navigation destinations; feature:camera ships as a dynamic feature loaded via Play Core.

🚀 Getting Started

1. Prerequisites: Android Studio Ladybug+ (AGP 8.3+), JDK 11, latest Android SDK/NDK components, Firebase project configured with both release and debug application IDs.
2. Clone & Sync:

   git clone <repo-url>
   cd TaskVault
   ./gradlew tasks

3. Run the app:

   ./gradlew :app:installDebug
   adb shell am start -n "com.shekhar.taskvault.debug/com.shekhar.taskvault.MainActivity"

4. Dynamic feature install (Camera): Use the in-app camera entry point or trigger via Play Core test request; module pulls dependencies only when requested.

✅ Testing & Quality Gates

• 🧪 Unit/UI tests: ./gradlew testDebugUnitTest and ./gradlew :app:connectedDebugAndroidTest.
• 🩺 Static checks: leverage the Gradle-managed check task plus KSP-generated Room schemas.
• ☁️ Crashlytics & Remote Config: ensure both com.shekhar.taskvault and com.shekhar.taskvault.debug clients exist in Firebase so :app:processDebugGoogleServices succeeds.

🖼️ Screens

Task overview	Task detail

Premium hub	Camera capture

Settings	Authentication

🔮 Further Enhancements

• 🧵 Add CI (GitHub Actions) pipelines invoking ./gradlew lint ktlintCheck testDebugUnitTest assembleRelease.
• 📌 Expand widgets with glanceable actions (quick complete, pin filters).
• 📣 Ship rich notifications using NotificationCompat.MessagingStyle backed by WorkManager.