egorikftp/Lady-happy-Android

This is an Android application built with Kotlin and Clean Architecture, serving as a content and catalog management platform. It features a dynamic module architecture for on-demand loading of features like post creation and editing, alongside core user-facing screens for browsing, searching, and viewing detailed item information. The system handles user authentication, theme management, and analytics tracking, utilizing modern Android components like Jetpack Compose and Koin for dependency injection.

67 changes.

The project evolved from a basic scaffold into a fully-featured Android application, implementing a clean architecture with Koin dependency injection and a custom navigation system. This period saw the addition of core features including a product catalog, post creation, photo reports, and user settings, supported by a centralized build system and reusable UI components.

25 changes.

This period focused on modernizing the UI layer by migrating multiple features, including the post creator and admin console, to Jetpack Compose. The team also expanded the app's functionality by introducing deep links, a new photo report, and a detailed product view with paginated content. Underlying infrastructure was strengthened with new base adapters, MVI interfaces, and dynamic feature support.

Introduced a new debug-only Beagle debug menu that provides quick access to app information, developer options, and utility actions like clearing app data and dumping memory leaks. The debug menu is initialized via BeagleDebugMenuInitializer and BeagleLifecycleListener, which also integrates a 'Test accounts' list on the login screen to auto-fill credentials. Additionally, a LeakCanaryInitializer was added to configure LeakCanary's heap dump behavior in debug builds.

app/src/debug/java/com/egoriku/ladyhappy/beagle · high confidence

The compose-ui module now includes a new Material Dialog implementation built with Jetpack Compose, providing composable functions for titles, messages, input fields, and various list types (single-choice, multi-choice, and generic). The module also introduces a helper to render Compose content within a Fragment using MdcTheme, and adds a reusable NetworkImage composable for loading remote images with Coil.

sources/base/compose-ui · medium confidence

A new DetailEntity class has been added to the detail page's data layer, mapping fields for name, title, date, and a list of images. This entity serves as the data model for displaying detailed information about an item, including its associated images.

sources/feature/detailPage/src/main/kotlin/com/egoriku/ladyhappy/detailpage/data/entity · medium confidence

A new DetailPageScreen is introduced to handle the subcategory detail view. It configures the associated Fragment with MaterialFade and MaterialFadeThrough transitions and passes DetailPageParams (including categoryId, subCategoryId, productName, productLogoUrl, and productDescription) to the target screen.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/subcategory/presentation/screen · high confidence

A new ResultOf sealed class and associated helper functions (doIfFailure, doIfSuccess, successOr) and a wrapIntoResult utility are added to the network module. This provides a consistent way to handle success and failure states from network calls, allowing callers to easily handle outcomes without explicit try/catch blocks.

sources/base/network/src/main/kotlin/com/egoriku/ladyhappy/network · high confidence

The app now includes a new 'Used Libraries' section in the UI, featuring a list of third-party libraries and their licenses. Users can view the list of libraries and tap on individual items to read the full license text on a dedicated screen. This is implemented via the new LicenseFragment and UsedLibrariesFragment classes, which handle the display and navigation for this feature.

sources/feature/usedLibraries/src/main/kotlin/com/egoriku/ladyhappy/usedLibraries/presentation · high confidence

A new library, \glideTransformations\, was introduced containing a \GradientOverlayTransformation\ that applies a vertical linear gradient overlay to images loaded via Glide. The transformation accepts start, center, and end colors to create a smooth color transition across the image, supporting cache key generation and equality checks for proper Glide caching behavior.

sources/libraries/glideTransformations · high confidence

The application now includes new Kotlin utilities for formatting dates. A new \Formatter\ object provides lazy-initialized \SimpleDateFormat\ instances for 'dd MMM, yyyy' and 'dd MMM, yyyy, HH:mm' patterns using the default locale. Corresponding extension functions on \Date\ objects (\ddMMMyyyy\, \ddMMMyyyyHHmm\, and \year\) are added to the \dateformat\ package, enabling consistent date display and year extraction across the app.

sources/base/core/src/main/kotlin/com/egoriku/ladyhappy/core/dateformat · high confidence

The extensions library now provides empty-default implementations for common Android callbacks: SimpleActivityLifecycleCallbacks for Application.ActivityLifecycleCallbacks, SimpleAnimationListener for Animation.AnimationListener, and SimpleTextWatcher for TextWatcher. These allow developers to override only the methods they need, reducing boilerplate when integrating with Android lifecycle, animation, and text input events.

sources/libraries/extensions/src/main/kotlin/com/egoriku/ladyhappy/extensions/listeners · high confidence

The detail page now uses a new \DetailAdapter\ backed by AndroidX Paging 3 to display a list of items. This adapter handles item binding, image loading via Glide, and integrates a photo viewer overlay for image interaction. Additionally, a \LoadingStateFooterAdapter\ and its corresponding \LoadStateFooterViewHolder\ have been introduced to manage and display paging load states, including error handling with a retry mechanism.

sources/feature/detailPage/src/main/kotlin/com/egoriku/ladyhappy/detailpage/presentation/adapter · high confidence

The application now includes new data models for handling image metadata and subcategory details. ImageEntity stores image dimensions and URL, while SubCategoryEntity includes fields for category ID, name, popularity, description, and a lastEditTime timestamp. An ImageEntityMapper is also introduced to convert ImageEntity objects into MozaikItem instances, enabling the display of image-based content.

sources/base/core/src/main/kotlin/com/egoriku/ladyhappy/core/sharedmodel/entity · high confidence

The landing feature now fetches and displays about information, quotes, and team members from Firebase Firestore. This includes new data models (LandingEntity, QuotesEntity, SocialEntity, TeamMemberEntity) and a mapper to convert them to domain models. The UI uses a ParallaxScrollListener to create parallax effects on the quotes and team sections, with controllers for each content type (About, Quotes, Our Team) and a custom SocialView for displaying social media links with animations. The repository layer handles Firestore data retrieval, and the use case orchestrates the data flow from repository to presentation.

sources/feature/landing/src/main/kotlin · high confidence

Introduces a new on-demand dynamic feature module for editing subcategories. This includes the AndroidManifest configuration, data sources and repositories for loading and updating subcategory details from Firebase, domain use cases, and the UI layer (Fragment, ViewModel, and layout) that allows users to modify subcategory properties such as title, description, popularity status, and published count.

sources/dynamicFeature/edit · high confidence

The SubCategoryFragment is introduced to display a list of subcategories using a RecyclerView backed by a ListAdapter. The fragment observes the SubCategoriesViewModel to render success, error, and loading states. A long-press on a subcategory item triggers a fragment result that requests the Edit dynamic feature, but only if the current user has admin or demo mode permissions.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/subcategory/presentation/fragment · high confidence

The settings feature now includes domain use cases for managing the app's visual theme. Users can retrieve the currently selected theme, with a fallback to SYSTEM or BATTERY\_SAVER depending on the Android version, and persist new theme selections. The available themes are also exposed, offering LIGHT, DARK, and SYSTEM on Android Q and above, or BATTERY\_SAVER on older versions.

sources/feature/settings/src/main/kotlin/com/egoriku/ladyhappy/settings/domain/usecase/theme · medium confidence

Introduced a new FileUtil object in the postCreator module that provides a method to convert a content URI into a temporary local File. The utility handles reading the input stream, generating a temporary file, renaming it to the original filename, and cleaning up the temporary file on exit.

sources/dynamicFeature/postCreator/src/main/kotlin/com/egoriku/ladyhappy/postcreator/data/local/util · medium confidence

Introduced a new \FilterState\ sealed class in the detail page's presentation layer, initially defining a \None\ state to represent the absence of active filters. This change establishes the foundation for managing filter conditions within the detail page's UI state.

sources/feature/detailPage/src/main/kotlin/com/egoriku/ladyhappy/detailpage/presentation/state · medium confidence

A new screen component, LicenseFragmentScreen, has been added to the usedLibraries module. This component handles the presentation of library license information by instantiating a LicenseFragment and passing the license text via arguments, enabling users to view the licenses of used libraries within the application.

sources/feature/usedLibraries/src/main/kotlin/com/egoriku/ladyhappy/usedLibraries/presentation/screen · high confidence

The application now includes foundational interfaces for the Model-View-Intent architecture, specifically \UiState\, \UiEvent\, and \UiEffect\. These empty marker interfaces serve as the base contracts for managing UI state, user interactions, and side effects within the MVI pattern.

sources/base/core/src/main/kotlin/com/egoriku/ladyhappy/core/mvi · high confidence

A new domain-layer use case, TabUseCase, has been added to the catalog feature. It is responsible for loading and mapping tab data from the repository into a RootScreenModel, handling both success and error states for the UI.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/categories/domain · high confidence

The Used Libraries feature now includes a new adapter (LibrariesListAdapter) and a viewmodel (UsedLibrariesViewModel) to manage the display of third-party library licenses. The adapter handles the RecyclerView list of licenses, while the viewmodel fetches and exposes the license data via LiveData, allowing the UI to react to changes in the license list.

sources/feature/usedLibraries/src/main/kotlin/com/egoriku/ladyhappy/usedLibraries/presentation/adapter · high confidence

A new ViewHolderBalloonFactory class was added to the catalog module, implementing a custom Balloon.Factory that configures a popup-style view with specific styling (padding, arrow size, corner radius, alpha, font, colors, and animation). This factory is used to create and style balloon-style UI elements within the subcategory presentation layer.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/subcategory/presentation/controller/balloon · high confidence

Introduced new data structures and repository logic to fetch category tabs from Firebase Firestore. This includes a TabEntity for data mapping, a TabRepository to handle Firestore queries, and a Koin module to wire the repository, use case, and ViewModel, enabling the app to load and display category tabs.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/categories/data · high confidence

Users can now view a list of third-party libraries and their associated licenses within the app. This change introduces the domain layer for this feature, including a MetadataParser to read and parse license metadata files, a LicenseUseCase to orchestrate the retrieval of license data, and a Koin module to wire these components together.

sources/feature/usedLibraries/src/main/kotlin/com/egoriku/ladyhappy/usedLibraries/domain · high confidence

The app now includes a dedicated launch screen that displays a white background with the 'Lady Happy' logo. This is implemented via a new \LaunchActivity\ that immediately redirects to the main activity, using a custom \SplashTheme\ with transparent status and navigation bars.

sources/feature/launchScreen · medium confidence

Introduced the \mozaik\ module's strategy package, providing a \StrategyResolver\ that selects specific layout algorithms for 1 to 5 items. The implementation includes an \IStrategy\ interface and internal classes (\StrategyFor1\ through \StrategyFor5\) that calculate rectangular bounds for each item based on parent dimensions and dividers, enabling the UI to arrange multiple items in a mosaic grid.

sources/libraries/mozaik/src/main/kotlin/com/egoriku/ladyhappy/mozaik/strategy · high confidence

The app module was initialized with essential build configuration files. A .gitignore was added to exclude build artifacts and debug assets. An appcenter-pre-build.sh script was introduced to handle Google services and keystore setup during CI builds. ProGuard rules were added to preserve Android components and Glide classes. A version.properties file was created to manage build and sub-version numbers.

app · high confidence

The repository was initialized with a comprehensive README.md file that outlines the project's architecture, including the use of Kotlin, Clean Architecture, and various Android Jetpack components. The diff also introduces the Gradle wrapper scripts (gradlew, gradlew.bat) to facilitate building the project, and updates the .gitignore file to exclude specific local configuration files and unused text files.

(repo-wide) · high confidence

A new DetailUseCase has been added to the detail page domain layer. It implements FlowUseCase to fetch paginated data via the Paging 3 library, mapping repository results into a Flow of PagingData containing DetailModel objects with mapped images, descriptions, and formatted dates.

sources/feature/detailPage/src/main/kotlin/com/egoriku/ladyhappy/detailpage/domain · high confidence

A new Gradle plugin, HappyXPlugin, has been added to the buildSrc module. This plugin provides a centralized way to configure common Android build features, including BuildConfig generation, Kotlin parcelize, Jetpack Compose, and ViewBinding. The plugin automatically applies these configurations to application, library, and dynamic feature modules based on their respective extensions.

buildSrc/src/main/java/com/egoriku/plugin · high confidence

A new NavigateMe class has been added to the navigation library, providing a wrapper around a Router that exposes a navigatorHolder property to access the command buffer. This change introduces a new way to interact with the navigation system's routing and command buffering capabilities.

sources/libraries/navigation/src/main/kotlin/com/egoriku/ladyhappy/navigation · high confidence

A new UseCase, ObserveThemeModeUseCase, has been added to the main screen domain layer. This component observes the user's selected theme preference and maps it to a Theme model, defaulting to SYSTEM or BATTERY\_SAVER based on the device's Android version.

app/src/main/java/com/egoriku/ladyhappy/mainscreen/domain · high confidence

The photo report feature now includes a new domain layer, adding the PhotoReportUseCase which retrieves and maps photo report data from the repository, and a Koin module that wires the repository, use case, and ViewModel for dependency injection.

sources/feature/photoReport/src/main/kotlin/com/egoriku/ladyhappy/photoreport/domain · high confidence

The catalog feature now includes a new domain layer for subcategories, introducing a \CatalogUseCase\ that handles fetching and transforming subcategory data from a repository. This use case is wired into the application via a new Koin module (\CatalogModule\), which registers the data source, repository, use case, and the \SubCategoriesViewModel\ as scoped dependencies. This change establishes the backend logic and dependency injection structure required to display and manage subcategory information within the catalog.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/subcategory/domain · high confidence

The app now supports on-demand loading of the Post Creator and Edit features as dynamic modules, managed by a new DynamicFeatureViewModel that handles installation states and navigation. Additionally, an InAppUpdateViewModel has been added to manage application update flows, while a FeatureProvider centralizes fragment instantiation for the main screen.

navigation · high confidence

Added a new split install helper that enables on-demand installation of app modules. The change introduces an ISplitInstallHelper interface and a SplitInstallHelper implementation that manages the full lifecycle of a dynamic feature installation, including handling user confirmation prompts, tracking download progress, and reporting success or failure states to the caller.

sources/base/core/src/main/kotlin/com/egoriku/ladyhappy/core/splitinstall · high confidence

The app adds a set of new screen wrapper classes (CatalogScreen, EditScreen, LandingScreen, PhotoReportScreen, PostCreatorScreen, SearchScreen, and SettingsScreen) that map navigation requests to specific Android Fragments. This change introduces a new presentation layer for the main screen, allowing each screen to define its own fragment and transition animations (e.g., MaterialFade, MaterialSharedAxis).

app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/screen · high confidence

A new PhotoReportAdapter is added to the presentation layer, implementing a RecyclerView adapter for displaying photo report items. The adapter handles binding image data to the layout and integrates a Stfalcon image viewer overlay. This overlay displays a title and count, allows closing the viewer, and updates the title when the user swipes through images.

sources/feature/photoReport/src/main/kotlin/com/egoriku/ladyhappy/photoreport/presentation/adapter · high confidence

A new Detail Page is added, displaying a product's title, description, and image. The header background uses a blurred version of the product image with a gradient overlay, which fades as the user scrolls. The main content is a RecyclerView powered by the Paging 3 library, which handles loading states (loading, error, empty) and provides a footer for retrying failed loads. The header's MotionLayout progress and the placeholder container's vertical bias are updated based on the AppBarLayout's scroll offset, creating a synchronized scrolling effect.

sources/feature/detailPage/src/main/kotlin/com/egoriku/ladyhappy/detailpage/presentation · high confidence

A new Screen sealed class hierarchy is introduced to define navigation targets, separating Fragment-based and Activity-based screens. This provides a structured way to represent different types of screens within the application's navigation graph.

sources/libraries/navigation/src/main/kotlin/com/egoriku/ladyhappy/navigation/screen · high confidence

A new base class, ScopeDialogFragment, has been added to the settings feature. This class extends AppCompatDialogFragment and implements AndroidScopeComponent, providing a standard way for dialog fragments in the settings UI to access a Koin scope via fragmentScope().

sources/feature/settings/src/main/kotlin/com/egoriku/ladyhappy/settings/presentation/dialog · high confidence

The core module now defines a set of new interfaces that abstract application services and navigation, including IAnalytics, IAppPreferences, IDispatchers, IFeatureProvider, IFirebase, INavigationHolder, IRemoteConfig, IRouter, and IStringResource. Additionally, a Theme enum and helper functions are added to manage UI theme selection and night mode configuration.

sources/base/core/src/main/kotlin/com/egoriku/ladyhappy/core · high confidence

The post creator now includes a new CompressImageRepository to handle image resizing and conversion to byte arrays, enabling the upload of compressed images. Additionally, a new CreateFileRepository is added to manage file creation from URIs, supporting the simplified internal logic for the publish post feature.

sources/dynamicFeature/postCreator/src/main/kotlin/com/egoriku/ladyhappy/postcreator/data/local · medium confidence

The app now includes new internal classes in the tools package to handle analytics tracking, user preferences, and navigation routing. Specifically, Analytics.kt integrates with Firebase Analytics to log events and errors; AppPreferences.kt uses Android DataStore to persist settings like theme selection and launch counts; and AppRouter.kt wraps the custom navigation library to manage screen transitions. These changes provide the underlying infrastructure for tracking user behavior, remembering user choices, and managing app flow.

app/src/main/java/com/egoriku/ladyhappy/tools · high confidence

The detail page now loads content in pages of 10 items using the AndroidX Paging 3 library. A new data layer (DetailDataSource and DetailPaginateRepository) fetches items from Firebase, and Koin is configured to provide the repository and use-case dependencies for the existing ViewModel.

sources/feature/detailPage/src/main/kotlin/com/egoriku/ladyhappy/detailpage/data · high confidence

A new library module, datastoreDelegates, has been added to the project. It provides Kotlin extension functions and a ReadWriteProperty delegate for the AndroidX DataStore library. This allows developers to read and write preferences using simple property accessors rather than explicit DataStore calls, streamlining the process of storing and retrieving key-value pairs.

sources/libraries/datastoreDelegates · high confidence

The network module introduces new Kotlin extension functions for Firebase Firestore, enabling asynchronous retrieval of documents and query results. Specifically, the diff adds helper functions in Document.kt, Query.kt, and Task.kt that wrap Firestore's synchronous Task-based API into suspend functions, allowing callers to await document and query results using Kotlin coroutines. Additionally, new exception classes (FirestoreNetworkException, FirestoreParseException, NoSuchDocumentException) are added to the network package to handle specific error states during Firestore operations.

sources/base/network/src/main/kotlin/com/egoriku/ladyhappy/network/firestore · high confidence

Added new Kotlin extension functions in the buildSrc module to simplify Android Gradle Plugin (AGP) configuration. These include helpers for managing Android source sets, APK signing configurations (debug/release), build types, and dependency declarations, as well as a utility for reading integer properties. These changes streamline the build script syntax for common Android build tasks.

buildSrc/src/main/java/com/egoriku/ext · medium confidence

The UI layer now includes three new RecyclerView item decoration classes: DividerItemDecoration for adding dividers between items, EmptySpaceItemDecoration for adding top spacing to the first item, and VerticalMarginItemDecoration for adding top and right margins. These utilities allow for more consistent and flexible spacing in list-based views.

sources/base/ui/src/main/kotlin/com/egoriku/ladyhappy/ui/decorator · medium confidence

The UI module introduces three new components: a reusable HatsProgressView for displaying an animated vector drawable loading state, a PhotoOverlayActions view for displaying title and close actions in a photo gallery, and a NoDataController for handling empty states with a retry action.

sources/base/ui/src/main/kotlin/com/egoriku/ladyhappy/ui/view · high confidence

The network module introduces three new abstract base classes to standardize business logic execution: UseCase for synchronous/asynchronous operations returning a ResultOf wrapper, FlowUseCase for cold flows, and FlowResultUseCase for cold flows that also handles exceptions by emitting a Failure state. These classes enforce a consistent pattern for executing code on a specified CoroutineDispatcher, with UseCase wrapping results in ResultOf and FlowResultUseCase adding automatic exception-to-Failure mapping.

sources/base/network/src/main/kotlin/com/egoriku/ladyhappy/network/usecase · high confidence

Added a new Firebase Cloud Function (index.js) that handles user creation by syncing auth data to Firestore and initializing default user permissions, as well as functions to increment or decrement published counts in subcategories when list items are created or deleted. Additionally, new ProGuard rules were added for the adminConsole, edit, and postCreator dynamic features to preserve specific Android Fragments from obfuscation.

sources · high confidence

Users will now see an in-app review prompt after five app launches, with a seven-day cooldown between requests. Additionally, the app introduces new facade classes for dynamic feature management, specifically for editing and post-creation features, which likely improves how these features are installed and managed.

app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/components · medium confidence

The navigation library introduces a new command-based routing system. A new \Command\ sealed class defines \Replace\ and \Add\ operations, each supporting a \NavigationType\ (DEFAULT or FULLSCREEN). A \BaseRouter\ provides a \CommandBuffer\ to queue and execute these commands. The concrete \Router\ class exposes methods \replaceScreen\, \addScreen\, and \addScreenFullscreen\ to trigger these navigation commands, enabling structured screen transitions with optional shared elements and fullscreen modes.

sources/libraries/navigation/src/main/kotlin/com/egoriku/ladyhappy/navigation/router · high confidence

Added new remote data layer components for the post creator feature. The PublishPostRepository handles saving post data to Firestore, while the UploadImageRepository manages image uploads to Firebase Storage. These new classes encapsulate the logic for interacting with the backend services, supporting the post creation workflow.

sources/dynamicFeature/postCreator/src/main/kotlin/com/egoriku/ladyhappy/postcreator/data/remote · high confidence

The app now includes a new SearchFragment that accepts a search query via arguments and pre-fills the search input field. Additionally, a Constants object has been introduced to centralize tracking fragment names for landing, photo report, settings, catalog, and search screens.

app/src/main/java/com/egoriku/ladyhappy/mainscreen/common, app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/search · high confidence

The settings feature now includes new presentation components to render the settings interface. This adds \AvailableFeaturesSectionAdapter\ and \FeatureAdapter\ to display a horizontal list of available features, \LoginSectionAdapter\ to show the user's login state (anonymous or logged in), and \SettingItemAdapter\ to render individual settings items and headers. A \MarginItemDecoration\ helper is also introduced to manage spacing between items in these lists.

sources/feature/settings/src/main/kotlin/com/egoriku/ladyhappy/settings/presentation/adapter · high confidence

The extensions library now includes a comprehensive set of Kotlin extension functions and utility classes to simplify common Android tasks. This adds helpers for managing view visibility and styling, accessing system services (such as connectivity, alarm, and notification managers), and handling UI interactions like toasts and snackbars. It also introduces an \Event\ wrapper for lifecycle-aware single-use events and provides convenient access to activity and fragment arguments. These additions streamline development by reducing boilerplate for standard Android APIs.

sources/libraries/extensions/src/main/kotlin/com/egoriku/ladyhappy/extensions · high confidence

Users can now use Google Assistant to open specific sections of the app, such as the catalog, about, news, or settings, via voice commands or assistant actions. This is enabled by new deep link parsing logic that maps assistant intents to the corresponding in-app screens.

app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/deeplink · medium confidence

A change to existing behaviour in assets/Google Play — 1 commit, 4 files.

assets/Google Play · medium confidence · unverified

A new Kotlin file, VersionCodeFormatter.kt, has been added to the buildSrc module. This introduces logic to dynamically calculate the app's version code and name by reading from a version.properties file, replacing any previous static or manually managed versioning approach.

buildSrc/src/main/java/com/egoriku/application · high confidence

The settings module now includes dedicated UI components for the login and used libraries sections. The LoginScreen implements slide transitions (bottom and top) for fragment entry and exit, while the UsedLibrariesScreen applies Material Shared Axis Z transitions. Both screens are registered as FragmentScreen implementations, enabling users to access these settings pages with defined visual navigation effects.

sources/feature/settings/src/main/kotlin/com/egoriku/ladyhappy/settings/presentation/screen · medium confidence

The admin console feature has been refactored to use Jetpack Compose for its user interface. This change introduces a new AndroidManifest configuration for the dynamic feature and replaces the previous implementation with a Compose-based navigation graph. The main AdminConsoleFragment now renders a Compose hierarchy, including a console screen that provides access to publish news, publish products, and manage users, all styled with Compose Material components.

sources/dynamicFeature/adminConsole · medium confidence

The Application class has been updated to initialize Koin dependency injection, fetch remote configuration, and apply the user's preferred theme (light, dark, or system) on startup. It also tracks the app launch count.

app/src/main/java/com/egoriku/ladyhappy · high confidence

The settings feature now uses a dedicated Koin module to manage dependency injection for its components. This change consolidates the wiring of ViewModels (SettingsViewModel, ThemeViewModel) and use cases (Authentication, Sections, Theme) into a single, centralized configuration file, improving modularity and maintainability of the settings screen.

sources/feature/settings/src/main/kotlin/com/egoriku/ladyhappy/settings/koin · high confidence

The app now uses a dedicated \key\ package to centralize string constants for argument passing, document fields, and dynamic features. This includes \ArgumentKey\ for fragment extras, \DocumentField\ for database keys, \DynamicFeature\ for feature flags, and \Constants\ for UI values like crossfade duration. This change supports the extraction of the Edit module as a dynamic feature and improves consistency in how data is passed between components.

sources/base/core/src/main/kotlin/com/egoriku/ladyhappy/core/sharedmodel/key · high confidence

The PostCreatorModule now registers the necessary repositories (CreateFile, CompressImage, UploadImage, PublishPost) and use cases (UploadImages, PublishPost) within a scoped Koin module. This wiring enables the PostViewModel to access image compression, upload, and post-publishing capabilities, supporting the new functionality for uploading compressed images and managing post creation.

sources/dynamicFeature/postCreator/src/main/kotlin/com/egoriku/ladyhappy/postcreator/koin · high confidence

The debug build now initializes a new DebugApplication class that enables Android StrictMode for detecting performance issues, integrates Koin for dependency injection, and configures diagnostic tools including LeakCanary and Beagle's debug menu. Additionally, Firebase Crashlytics collection is explicitly disabled in the debug variant to prevent debug builds from sending crash reports.

app/src/debug/java/com/egoriku/ladyhappy · high confidence

The predefined data for the post creator has been restructured to include a comprehensive list of hat colors and categories. Users can now choose from 11 specific hat colors (such as Milk, Black, Orange, Yellow, Red, Purple, Pink, Blue, Green, Brown, and Gray) and select from multiple hat categories including Felt Accessories, Felt Hats, Sinamay, Regiline, and Veils, each with their respective subcategories.

sources/dynamicFeature/postCreator/src/main/kotlin/com/egoriku/ladyhappy/postcreator/domain/predefined · medium confidence

The core adapter logic for RecyclerViews has been extracted into new base classes: BaseListAdapter and BaseViewHolder. These provide a generic, abstracted foundation for list adapters and their corresponding view holders, simplifying the implementation of list-based UIs by handling common DiffUtil and binding patterns.

sources/base/core/src/main/kotlin/com/egoriku/ladyhappy/core/adapter · high confidence

Added two new Koin modules in the debug build variant: a \DebugKoinModule\ that registers an \AccountProvider\ as a singleton, and the \AccountProvider\ class itself, which loads account data from a \koin.properties\ file in the app's assets. This change replaces the previous Dagger-based dependency injection setup with Koin for debug builds, enabling easier configuration of test accounts during development.

app/src/debug/java/com/egoriku/ladyhappy/koin · high confidence

The login feature now uses a new Koin-based module to provide the LoginViewModel, and the presentation layer has been refactored to use the modern \repeatOnLifecycle\ API for observing state changes. The login screen now validates email and password inputs using dedicated utility functions, and handles Google Sign-In and One Tap authentication via the new activity result APIs.

sources/feature/login/src/main/kotlin · high confidence

The catalog feature now includes a new data layer for subcategories, introducing a data source that fetches subcategories from Firebase by categoryId, a repository that handles IO threading and error wrapping, and a presentation state class to manage loading, success, and error UI states for subcategory lists.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/subcategory/data · high confidence

The app now uses a dedicated permission module to manage user roles and access levels. This includes a sealed class defining specific permissions (such as admin, demo, and general user), a repository that fetches and transforms user data from Firebase, and a service that updates the current user's active permissions based on their login state. This change replaces the previous approach with a more structured, modular system for handling user permissions.

sources/base/auth · high confidence

The build plugin now provides internal extension properties (e.g., \libs\, \libraryExtension\, \applicationExtension\, \dynamicFeatureExtension\) to access Gradle DSL objects and the central \LibrariesForLibs\ instance. This change supports the migration to AGP 7.0 and the new DSL classes, enabling the plugin to interact with the updated Android Gradle Plugin APIs and the consolidated version catalog.

buildSrc/src/main/java/com/egoriku/plugin/internal · high confidence

The application's dependency injection framework has been migrated from Dagger to Koin. This change introduces new Koin module definitions (ApplicationModule.kt, KoinStarter.kt) that replace the previous Dagger-based setup, centralizing the initialization of core services like analytics, preferences, and navigation routers within the Koin container.

app/src/main/java/com/egoriku/ladyhappy/koin · high confidence

The photo report fragment now uses the \repeatOnLifecycle\ API to collect UI state changes, ensuring that the coroutine collecting the \uiState\ flow is automatically started and stopped based on the fragment's lifecycle. This replaces the previous approach, aligning the component with modern lifecycle-aware coroutine practices to prevent memory leaks and ensure proper state updates during lifecycle transitions.

sources/feature/photoReport/src/main/kotlin/com/egoriku/ladyhappy/photoreport/presentation · high confidence

The CategoriesFragment now uses the lifecycle-aware repeatOnLifecycle API to collect from the ViewModel's Flow, ensuring that flow collection is automatically paused and resumed with the fragment's lifecycle state. This change prevents potential memory leaks and crashes that could occur from collecting flows while the fragment is not active.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/categories/presentation/fragment · high confidence

The MozaikLayout component now exposes two new configuration options: isMozaikClickable, which allows developers to disable the default click handling on items, and placeholderColor, which sets a background color for image views before they are loaded. These changes enable more flexible interaction patterns and visual customization for the mosaic layout.

sources/libraries/mozaik/src/main/kotlin/com/egoriku/ladyhappy/mozaik · high confidence

The photo report feature now includes a new repository class, PhotoReportRepository, which fetches news data from a Firebase Firestore collection named 'news\_v2'. The implementation queries the 'date' field in descending order and returns a list of PhotoReportEntity objects. This change introduces the data access layer for the photo report feature, handling both successful retrieval and failure scenarios via the ResultOf wrapper.

sources/feature/photoReport/src/main/kotlin/com/egoriku/ladyhappy/photoreport/data/repository · high confidence

The settings feature now includes new domain use cases: AuthenticationUseCase handles login state collection and logout, while SectionsUseCase manages loading settings, about, and feature sections, including a delay for feature availability checks based on user permissions.

sources/feature/settings/src/main/kotlin/com/egoriku/ladyhappy/settings/domain/usecase · medium confidence

The catalog's tabbed navigation now updates more efficiently. When the list of categories changes, the adapter uses DiffUtil to calculate only the necessary updates. Additionally, if a specific tab's content changes, the system triggers a targeted refresh of that fragment rather than reloading the entire view, which improves performance and responsiveness.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/categories/presentation/adapter · high confidence

The post creation screen has been rewritten using Jetpack Compose, replacing the previous XML-based implementation. This change introduces a modern, declarative UI for composing posts, including image selection, category and color picking, and scheduling. The new interface provides immediate visual feedback and smoother transitions between states like loading, uploading, and success/error effects.

sources/dynamicFeature/postCreator/src/main/kotlin/com/egoriku/ladyhappy/postcreator/presentation · high confidence

The main screen's presentation layer has been restructured to use Koin for dependency injection, introducing a new MainScreenDependency module that wires up ViewModels and managers. A new ThemedActivityDelegate interface and implementation have been added to centralize theme observation, and the MainActivity now explicitly manages in-app updates, dynamic feature delivery, and Google Assistant deep links through this new structure.

app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation · high confidence

The navigation library has been restructured to use a command-buffer pattern for managing navigation actions. A new \CommandBuffer\ class now queues navigation commands and executes them once a \Navigator\ is available, ensuring that navigation commands are not lost if issued before the navigator is ready. This is supported by new \INavigator\ and \NavigatorHolder\ interfaces, and an \ActivityScopeNavigator\ implementation that processes \Add\ and \Replace\ commands against \FragmentScreen\ and \ActivityScreen\ types. Additionally, extension functions for \FragmentTransaction\ have been added to handle back-stack and shared-element transitions.

sources/libraries/navigation/src/main/kotlin/com/egoriku/ladyhappy/navigation/navigator · medium confidence

The Android plugin configuration logic has been refactored into dedicated, modular sections for different build types. App modules now have a dedicated configuration for application settings, build features (including ViewBinding, BuildConfig, and Compose), and dynamic features. Library modules have their own configuration for library-specific settings. This change improves maintainability and clarity of the build script by separating concerns for each module type.

buildSrc/src/main/java/com/egoriku/plugin/configure · high confidence

The settings screen now uses a dedicated LoginView component to display user status (logged in vs anonymous) and handle login/logout interactions. This change introduces a new view class that manages the profile image, username, and login button state, replacing the previous implementation within the settings fragment. Users will see a more distinct and reusable login section in the settings menu.

sources/feature/settings/src/main/kotlin/com/egoriku/ladyhappy/settings/presentation · high confidence

The internal logic for publishing posts and uploading images has been rewritten to be simpler and more efficient. The new implementation allows users to upload images with automatic compression and resizing, ensuring that only the necessary image sizes are processed. This change streamlines the user experience by handling image optimization and upload in a more streamlined way, reducing unnecessary processing steps.

sources/dynamicFeature/postCreator/src/main/kotlin/com/egoriku/ladyhappy/postcreator/domain/usecase · medium confidence

The subcategory list now uses a ListAdapter with a DiffCallback to manage item updates, replacing the previous adapter implementation. This change improves performance and correctness by automatically calculating minimal updates to the RecyclerView, ensuring the UI stays in sync with the underlying data model (SubCategoryModel) without manual notify calls.

sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/subcategory/presentation/controller · high confidence

A new data entity, PhotoReportEntity, has been introduced to map Firestore document fields (date, description, images) to Kotlin properties, enabling the photo report feature to correctly parse and store image report data from the backend.

sources/feature/photoReport/src/main/kotlin/com/egoriku/ladyhappy/photoreport/data/entity · medium confidence

The project's build system has been migrated from Groovy to Kotlin DSL (build.gradle.kts), and all dependencies are now managed via a central version catalog (gradle/libs.versions.toml). This change introduces a \libs\ catalog that defines versions for libraries like Koin (3.1.5), Compose (1.1.0-rc03), and Firebase BOM (29.0.4), replacing individual version declarations in each module's build script. The \settings.gradle.kts\ and \build.gradle.kts\ files now use type-safe project accessors and version catalogs, improving build script type safety and maintainability.

(dependencies) · high confidence

The Gradle wrapper has been updated to use Gradle 7.3.3, ensuring the project uses a consistent and modern build tool version for all developers and CI environments.

gradle · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 55 → 51 (-4.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 100 (-0.0)
• Architecture 98 → 93 (-4.5)
• Maturity 54 → 54 (+0.0)
• Readiness 41 → 32 (-8.8)
• Security 59 → 61 (+2.6)
• Domain Modelling 100 → 100 (+0.0)

• Boundary-crossing change coupling: MainActivity.kt ↔ PhotoReportFragment.kt (app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/MainActivity.kt)
• Boundary-crossing change coupling: MainActivity.kt ↔ ThemeSettingDialogFragment.kt (app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/MainActivity.kt)
• Boundary-crossing change coupling: MainActivity.kt ↔ UsedLibrariesFragment.kt (app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/MainActivity.kt)
• Change coupling clique: LandingScreen.kt, PhotoReportScreen.kt, SettingsScreen.kt (app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/screen/LandingScreen.kt)
• Change coupling: CategoryModel.kt ↔ PostCreatorFragment.kt (sources/dynamicFeature/postCreator/src/main/kotlin/com/egoriku/ladyhappy/postcreator/domain/predefined/CategoryModel.kt)
• Change coupling: SettingFragment.kt ↔ UsedLibrariesFragment.kt (sources/feature/settings/src/main/kotlin/com/egoriku/ladyhappy/settings/presentation/SettingFragment.kt)
• Change coupling: SubcategoryRepository.kt ↔ SubCategoriesViewModel.kt (sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/subcategory/data/repository/SubcategoryRepository.kt)
• Change coupling: TabRepository.kt ↔ SubcategoryRepository.kt (sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/categories/data/repository/TabRepository.kt)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (14 lines × 2) (sources/libraries/mozaik/src/main/kotlin/com/egoriku/ladyhappy/mozaik/strategy/internal/StrategyFor2.kt)
• Duplicated block (14 lines × 2) (sources/libraries/mozaik/src/main/kotlin/com/egoriku/ladyhappy/mozaik/strategy/internal/StrategyFor4.kt)
• Duplicated block (17 lines × 2) (app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/components/dynamicDelivery/DynamicFeatureViewModel.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Scanner failed to run — not a clean result
• The document begins outlining Integration with Google Assistance but is cut mid-sentence before completing the section; no visible guidance on how to invoke commands or what commands are supported. (README.md)
• The project characteristics section lists only one technology (Kotlin) and omits architecture patterns such as Clean Architecture, Multi-Module setup, MVVM, and dependency injection framework (Koin). (README.md)
• …and 1 more

• Boundary-crossing change coupling: MainActivity.kt ↔ SettingFragment.kt (app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/MainActivity.kt)
• Change coupling: CategoriesFragment.kt ↔ SubCategoryFragment.kt (sources/feature/catalog/src/main/kotlin/com/egoriku/ladyhappy/catalog/categories/presentation/fragment/CategoriesFragment.kt)
• Change coupling: PredefinedData.kt ↔ ColorDialog.kt (sources/dynamicFeature/postCreator/src/main/kotlin/com/egoriku/ladyhappy/postcreator/domain/predefined/PredefinedData.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (16 lines × 2) (sources/libraries/mozaik/src/main/kotlin/com/egoriku/ladyhappy/mozaik/strategy/internal/StrategyFor4.kt)
• Duplicated block (17 lines × 2) (sources/libraries/mozaik/src/main/kotlin/com/egoriku/ladyhappy/mozaik/strategy/internal/StrategyFor2.kt)
• Duplicated block (32 lines × 2) (app/src/main/java/com/egoriku/ladyhappy/mainscreen/presentation/components/dynamicDelivery/DynamicFeatureViewModel.kt)
• High secret: WD-SECRET-0004 (app/debug.keystore)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Leaked secret: private-key-store (app/debug.keystore)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No ADRs found
• …and 8 more

• Containers 0 added · 0 removed · contexts 14 added · 1 removed · edges 21 added · 0 removed

• app
• auth
• catalog
• core
• detailPage
• edit
• landing
• login
• mozaik
• photoReport
• postCreator
• settings
• ui
• usedLibraries

• navigation

• app → core (coupling)
• app → settings
• auth → core
• catalog → auth
• catalog → core (coupling)
• core → mozaik (coupling)
• detailPage → core (coupling)
• detailPage → mozaik (coupling)
• edit → auth
• edit → core (coupling)
• landing → core
• landing → ui
• login → auth
• photoReport → core
• photoReport → mozaik (coupling)
• postCreator → auth
• postCreator → core
• postCreator → ui
• settings → auth
• settings → core
• …and 1 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

egorikftp/Lady-happy-Android was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.