Team-Hankki/hankki-android

This is an Android application designed for university students to discover, report, and curate local dining stores. It enables users to browse stores via a map filtered by university, submit detailed reports with menu and pricing information, and manage personalized or shared collections of favorite locations known as 'Jogbo'. The system handles user authentication, profile management, and store interactions through a structured multi-module architecture.

Two new UI components have been introduced for the MyPage feature: ArrowIconButton, which displays a text label alongside a right-pointing arrow icon in a clickable row layout, and IconButton, which presents a centered icon with a text label below it in a clickable column layout. These components provide reusable building blocks for navigation and action items within the user's profile section.

feature/my/src/main/java/com/hankki/feature/my/mypage/component · high confidence

A new composable component, HankkiChipWithIcon, has been added to the design system. It renders a selectable chip featuring an asynchronous image icon and a text title, with visual states for selected and unselected modes using specific theme colors and typography styles.

core/designsystem/src/main/java/com/hankki/core/designsystem/component/chip · high confidence

Introduces a new bottom sheet UI component that displays a list of store jogbo items with support for adding new entries. The component features a custom drag handle, a button to add new jogbo items, and a scrollable list of existing items. Each item displays an image based on its type, a title, and associated tags. The implementation includes a soft hide delay before dismissing the sheet and performing the add action, ensuring a smoother user experience when interacting with the bottom sheet.

core/designsystem/src/main/java/com/hankki/core/designsystem/component/bottomsheet · high confidence

Introduces the navigation structure for the Home feature by defining the Home route (implementing MainTabRoute) and a corresponding NavGraphBuilder extension. This setup allows the Home screen to be integrated into the main tab navigation, passing necessary parameters like padding values and navigation callbacks for actions such as viewing store details, selecting a university, or adding new items.

feature/home/src/main/java/com/hankki/feature/home/navigation · high confidence

The My Store feature is now available, allowing users to view lists of stores they have liked or reported. The new MyStoreRoute composable displays these items in a scrollable list, supporting navigation to individual store details and toggling the like status of a store. The screen includes a loading state, an empty state for when no items are found, and a top bar that adapts its title based on whether the user is viewing liked or reported stores.

feature/my/src/main/java/com/hankki/feature/my/mystore · high confidence

A new MyStoreItem Composable component has been added to the 'My' feature, wrapping the existing StoreItem to display store details (name, price, category, image) and a conditional heart icon. The icon's appearance (filled vs. empty) is controlled by the isIconSelected parameter, and it triggers an editSelected callback when clicked, supporting both click and long-click interactions for store items.

feature/my/src/main/java/com/hankki/feature/my/component · high confidence

Introduces the StoreDetailService interface, defining the network contract for store detail operations. This includes endpoints for retrieving store details, managing store favorites (hearts), viewing user nicknames, and handling store menus (adding, updating, and deleting).

data/storedetail/src/main/java/com/hankki/data/storedetail/service · high confidence

Introduced new Kotlin data classes and interfaces in the home domain layer to represent response payloads for the home screen features. This includes CategoryEntity (with CategoriesEntity and CategoryResponseEntity) for category data, JogboResponseEntity for jogbo list items, StoreEntity for store details, StorePinEntity for map pin locations, and UniversityResponseEntity for university information. These entities define the structure of data returned by the API for these specific features.

domain/home/src/main/java/com/hankki/domain/home/entity · high confidence

The store detail module now includes a new 'DeleteSuccessLastRoute' screen that appears after a menu is successfully deleted. This screen displays a confirmation message personalized with the user's nickname and provides a single 'Done' button to return to the store detail view. It is accompanied by a ViewModel that fetches the user's nickname and handles navigation or error display via side effects, distinct from the previous success route which offered an option to edit more menus.

feature/storedetail/src/main/java/com/hankki/feature/storedetail/editbottomsheet/edit/delete · high confidence

A new bottom sheet dialog has been added to the store detail feature, allowing users to choose between adding a new menu item or modifying/deleting an existing one. The sheet presents two distinct action cards with specific icons and background images, and triggers the appropriate callback upon selection.

feature/storedetail/src/main/java/com/hankki/feature/storedetail/editbottomsheet · high confidence

Introduced LocationModel and MenuModel classes to represent location coordinates and menu items within the report feature. These models include conversion functions to map between the domain entities (LocationEntity, MenuEntity) and the presentation layer, ensuring data is correctly formatted as strings for UI consumption.

feature/report/src/main/java/com/hankki/feature/report/model · high confidence

Introduced new data classes for the report domain, including CategoryEntity (with name, tag, and imageUrl), CountEntity (with a count field), LocationEntity (with latitude, longitude, name, and address), and MenuEntity (with name and price). These entities provide the foundational data structures for reporting features.

domain/report/src/main/java/com/hankki/domain/report/entity · high confidence

Introduces the navigation structure for the new Report feature, defining three screens: the main report entry (Report), a store search interface (SearchStore), and a completion summary (ReportFinish). The diff adds the \reportNavGraph\ builder which wires these screens together, along with extension functions on \NavController\ to navigate between them, passing parameters such as location coordinates, store details, and submission counts.

feature/report/src/main/java/com/hankki/feature/report/navigation · high confidence

The app now displays a splash screen upon launch that shows the logo and waits for 1.2 seconds. During this time, the system UI (status and navigation bars) is styled with transparent backgrounds and dark icons. After the delay, the app checks for an existing access token; if a token is present, the user is automatically navigated to the home screen, otherwise they are sent to the login screen.

feature/main/src/main/java/com/hankki/feature/main/splash · high confidence

Users now see a dedicated success screen after adding a menu, which displays their nickname and the number of menus submitted. This screen provides two options: 'Add another menu' to return to the input form, or 'Complete' to navigate back to the store detail page.

feature/storedetail/src/main/java/com/hankki/feature/storedetail/editbottomsheet/add/addsuccess · high confidence

New Dagger Hilt modules have been introduced in the StoreDetail data layer to manage dependency injection. DataSourceModule binds the StoreDetailDataSource implementation, RepositoryModule binds the StoreDetailRepository implementation, and ServiceModule provides the StoreDetailService instance using a Retrofit client annotated with @JWT. These changes enable automatic injection of data-layer dependencies throughout the application.

data/storedetail/src/main/java/com/hankki/data/storedetail/di · high confidence

The LoginRepositoryImpl class has been added to the data login module, implementing the LoginRepository interface. This implementation handles the postLogin operation by delegating to the LoginDataSource, converting request entities to DTOs and response data back to entities, and wrapping the result in a Result type for error handling.

data/login/src/main/java/com/hankki/data/login/repositoryImpl · high confidence

New Retrofit service interfaces have been introduced to handle user profile data, jogbo (favorite list) operations, and store interactions. MyService provides endpoints for retrieving user information, managing jogbo items (create, read, delete, batch delete), liking/unliking stores, and handling account actions like logout and withdrawal. It also includes shared jogbo functionality for checking ownership and creating shared jogbos. NoTokenMyService adds a public endpoint to retrieve shared jogbo details without requiring authentication.

data/my/src/main/java/com/hankki/data/my/service · high confidence

The domain/token module now includes a new TokenRepository interface that defines the contract for managing authentication tokens. This interface provides methods to retrieve the current access and refresh tokens, set new token pairs, and clear stored token information, establishing the foundation for token persistence within the application's domain layer.

domain/token · high confidence

The app now includes a dedicated \baselineprofile\ module containing a \BaselineProfileGenerator\ to create startup-optimized profiles and \StartupBenchmarks\ to measure cold-start performance improvements. This enables users to verify that baseline profiles are effectively reducing startup times by comparing compilation modes.

baselineprofile · high confidence

The search store feature now includes a new UI for selecting store locations. This change introduces three new Compose components: EmptyLocationView, which displays a message when no search results are found; LocationItem, a selectable row displaying the location name and address with visual feedback for the selected state; and LocationList, which renders a scrollable list of these items. These components enable users to browse and select specific store locations within the report feature.

feature/report/src/main/java/com/hankki/feature/report/searchstore/component · high confidence

Introduced the LoginService interface in the data login module to handle user authentication. This service defines a POST endpoint at api/v1/auth/login, accepting a LoginRequestDto in the request body and an accessToken via the Authorization header, returning a standardized BaseResponse containing LoginResponseDto.

data/login/src/main/java/com/hankki/data/login/service · high confidence

Introduced new data transfer objects for the login flow: LoginRequestDto, which carries the platform identifier, and LoginResponseDto, which includes the access token, refresh token, and registration status. These classes provide serialization support and conversion methods to map between the data layer and the domain entities.

data/login/src/main/java/com/hankki/data/login/dto · high confidence

The University Selection feature is now accessible via a dedicated navigation route. This change introduces the \UniversitySelectionNavigation\ component, which defines the \UniversitySelection\ route and provides the necessary navigation graph setup to display the \UniversitySelectionRoute\ UI, including a callback to navigate back to the home screen.

feature/universityselection/src/main/java/com/hankki/feature/universityselection/navigation · high confidence

New data transfer objects, MenuUpdateRequestDto and StoreDetailAddMenuRequestDto, have been introduced in the data layer to support API interactions for updating and adding store menus. These classes define the request structure (name and price) and include mapping functions to convert from their corresponding domain entities, enabling the backend to handle menu modification and addition requests.

data/storedetail/src/main/java/com/hankki/data/storedetail/request · high confidence

New data transfer objects have been introduced to handle specific store-related API requests: ReportStoreRequestDto for submitting store details including menus, ValidateStoreRequestDto for verifying store information via location and name, and ReportOtherSchoolStoreRequestDto for reporting stores associated with other universities. These DTOs include serialization annotations and mapping functions to convert from their corresponding domain entities.

data/report/src/main/java/com/hankki/data/report/dto/request · high confidence

New data classes have been introduced in the report domain to model response payloads from connected external services. These include UserInfoResponseEntity for user nickname data, UniversityResponseEntity for university location details, StoreValidateResponseEntity for store registration status, GeneratedStoreResponseEntity for store identifiers, and JogboResponseEntity for Jogbo-specific content such as titles, images, and details. These entities support the backend's integration with Jogbo APIs and university-related features.

domain/report/src/main/java/com/hankki/domain/report/entity/response · high confidence

The report feature now includes a new \SelectedImageController\ composable that displays a cropped, rounded-corner preview of a selected image. Users can interact with this preview to either delete the image or replace it with a new one via dedicated action buttons, providing a clear interface for managing image selections within the report workflow.

feature/report/src/main/java/com/hankki/feature/report/main/component · high confidence

The app now initializes core services at startup, including Timber for debug logging and the Kakao SDK using the native app key. This change also integrates Hilt for dependency injection via the HiltAndroidApp annotation.

app/src/main/java · high confidence

The MyDataSourceImpl class has been introduced to implement the MyDataSource interface, providing the concrete data-fetching logic for the 'My' section of the app. This implementation delegates API calls to MyService and NoTokenMyService, enabling features such as retrieving user information, managing jogbo lists (creating, viewing details, deleting), handling liked and reported stores, and managing shared jogbo details. It also supports account actions like logout and withdrawal, as well as checking jogbo ownership.

data/my/src/main/java/com/hankki/data/my/datasourceimpl · high confidence

The ReportRepositoryImpl is introduced to handle data operations for the report feature, bridging the domain layer with the data source. It provides methods to retrieve store locations, report counts, categories, and user information, as well as to validate stores and submit new reports including image uploads. Additionally, it supports university-specific store interactions and manages user favorites (Jogbo) by fetching and adding stores.

data/report/src/main/java/com/hankki/data/report/repositoryimpl · high confidence

Added the StoreDetailDataSourceImpl class, which implements the StoreDetailDataSource interface to handle store detail operations. This implementation provides methods for retrieving store details, managing store favorites (hearts), interacting with the 'jogbo' feature, managing store nicknames, deleting stores, and performing menu operations such as adding, updating, and deleting menu items.

data/storedetail/src/main/java/com/hankki/data/storedetail/datasourceImpl · high confidence

Added ReportDataSourceImpl, which implements the ReportDataSource interface to provide the concrete data-fetching logic for the report feature. This class exposes methods for retrieving store locations, report counts, categories, and user information, as well as submitting reports (including image uploads), validating stores, managing university stores, and handling 'jogbo' (favorites) operations by delegating to the underlying ReportService.

data/report/src/main/java/com/hankki/data/report/datasourceimpl · high confidence

This change introduces the foundational data layer for the report feature, adding the \ReportDataSource\ interface and the \ReportService\ Retrofit interface. These files define the network contracts for retrieving store locations, categories, and report counts, as well as submitting store validations, reports (including image uploads), and university-specific store data. It also establishes the endpoints for fetching user information, university details, and managing 'jogbo' favorites.

data/report/src/main/java/com/hankki/data/report/datasource, data/report/src/main/java/com/hankki/data/report/service · high confidence

The repository has been initialized with the core infrastructure required to build the Android application. This includes the Gradle wrapper scripts (gradlew and gradlew.bat) to ensure consistent builds, a comprehensive .gitignore file tailored for Android Studio, macOS, Windows, and Kotlin development, and an updated README.md that documents the project's purpose, tech stack (including Kotlin 2.0 and Jetpack Compose), and team structure.

(repo-wide) · high confidence

This change adds the navigation structure for the new 'My' tab, defining routes for the user's profile (MyRoute), their jogbo list (MyJogboRoute), store views (MyStoreRoute), jogbo details (MyJogboDetailRoute), and new jogbo creation (NewJogboRoute). It includes a deep link configuration for KakaoTalk that allows users to open a specific jogbo detail directly from an external link, and provides helper functions to navigate between these screens while passing necessary parameters like favorite IDs and deep-link states.

feature/my/src/main/java/com/hankki/feature/my/navigation · high confidence

The core design system now includes a new theme structure in \core/designsystem/theme\. This introduces a comprehensive color palette (including specific shades like Red500, Gray350, and WarnRed) and a detailed \HankkiTypography\ class supporting multiple font families (Pretendard, Suite) and numerous text styles (H1-H3, Body1-8, Caption1-5, etc.). The \HankkijogboTheme\ composable provides the root theme configuration, handling dark/light mode selection and configuring status/navigation bar appearance.

core/designsystem/src/main/java/com/hankki/core/designsystem/theme · high confidence

The login feature now includes a complete Kakao login implementation using the Kakao SDK, supporting both KakaoTalk and web login fallbacks, with a ViewModel managing the authentication state and side effects. Additionally, a new four-step onboarding flow has been added, featuring Lottie animations, horizontal slide transitions, and a skip option, which users are directed to after a successful login if they are not yet registered.

feature/login/src/main/java/com/hankki/feature/login · high confidence

Users can now view the details of a specific Jogbo (a curated list of stores) via a new screen that supports both personal and shared Jogbos. The feature fetches store lists, displays them in a scrollable layout, and allows owners to delete stores. For shared Jogbos, the app checks login status and ownership, showing appropriate dialogs or navigation actions. Additionally, users can share their Jogbo via KakaoTalk or a web link, with tracking events integrated for analytics.

feature/my/src/main/java/com/hankki/feature/my/myjogbodetail · high confidence

The My Jogbo screen now displays a grid of user jogbos, allowing users to enter an edit mode to select multiple items and delete them in bulk. The feature includes a confirmation dialog for deletions, a loading state, and navigation handling for back presses and deep links.

feature/my/src/main/java/com/hankki/feature/my/myjogbo · high confidence

A new MyDataSource interface has been added to define the contract for user-specific data operations. This interface exposes methods for retrieving user information, managing jogbo lists (including creation, deletion, and detail retrieval), handling store interactions (liking, reporting, and shared jogbo details), and managing account actions such as logout and withdrawal. This change establishes the data layer contract for the 'My' section of the application.

data/my/src/main/java/com/hankki/data/my/datasource · high confidence

The StoreDetailRepositoryImpl class has been added to implement the StoreDetailRepository interface, providing the data layer for store detail features. This implementation enables users to retrieve store details, manage store favorites (hearts), view and edit store nicknames, add stores to their jogbo (favorites list), and perform menu management operations such as adding, updating, and deleting menu items.

data/storedetail/src/main/java/com/hankki/data/storedetail/repositoryImpl · high confidence

The new core.navigation module provides the foundational interfaces for the application's navigation system. It defines a base Route interface and a MainTabRoute interface, establishing the contract for navigation destinations within the app.

core/navigation · high confidence

The core/network module now provides a centralized networking foundation. It introduces BaseResponse and CreatedBaseResponse data classes for standardized API response parsing, and a ContentUriRequestBody class that automatically compresses and rotates images before uploading to reduce payload size. Authentication is handled by an OauthInterceptor that automatically attaches access tokens to requests and transparently reissues expired tokens using a refresh token; if reissuance fails, the user is logged out and the app restarts. The module is wired via Hilt (NetworkModule) to provide separate OkHttp/Retrofit instances for authenticated (@JWT) and unauthenticated (@NoToken) requests, and includes a localized relogin toast message for expired sessions.

core/network · high confidence

The app now uses a set of custom Compose Snackbar components (HankkiSnackBar, HankkiTextSnackBar, HankkiTextSnackBarWithButton, and HankkiWhiteSnackBarWithButton) instead of the default Material 3 Snackbar. These components provide a branded look with rounded corners, specific padding, and distinct styles for text-only and text-with-button variants, allowing for more consistent UI presentation of user notifications.

core/designsystem/src/main/java/com/hankki/core/designsystem/component/snackbar · high confidence

The login domain now includes request and response data models for authentication, specifically a LoginRequestEntity containing a platform identifier and a LoginResponseEntity returning an accessToken, refreshToken, and registration status. A new LoginRepository interface has been added to define the postLogin operation, enabling the system to handle login requests and process the resulting token and user state.

domain/login · high confidence

The app now uses a new main entry point (MainActivity) that initializes the core navigation graph, manages deep-link handling (e.g., Kakao links), and provides a unified snackbar system for error and action messages. The main screen includes a bottom navigation bar with Home, Report, and My tabs, and integrates Amplitude tracking for tab interactions. A new network monitor tracks connectivity status to inform the UI about online/offline states.

feature/main/src/main/java/com/hankki/feature/main · high confidence

Adds the ReportRoute, ReportViewModel, ReportState, and ReportSideEffect components for the report feature. This introduces the ability to select a university, pick a food category, upload an image, and enter menu items with prices. The screen handles validation (e.g., price limits, university checks), manages navigation to the finish screen or back with tracking, and displays error dialogs or snack bars for submission failures.

feature/report/src/main/java/com/hankki/feature/report/main · high confidence

The design system now includes four new Compose text field components: HankkiTextField (the base component with customizable borders, icons, and colors), HankkiTitleTextField (adds a title, error state, and error message display), HankkiCountTextField (handles specific input logic for jogbo names with character limits and special regex validation), and HankkiSearchTextField (provides a search-specific input with a clear button and search keyboard action). These components replace or supplement previous generic text inputs, offering consistent styling, validation, and focus management across the app.

core/designsystem/src/main/java/com/hankki/core/designsystem/component/textfield · high confidence

The Home feature now displays a Naver Map with store markers and a bottom sheet for store details, replacing the previous implementation. Users can filter stores by category, price, and sort order using chips, and the map view is centered on the user's selected university or current location. The screen includes a back-press handler to exit the app, university selection logic, and analytics tracking for map and store interactions.

feature/home/src/main/java/com/hankki/feature/home · high confidence

The MyPage screen now supports user logout and account deletion (withdrawal). Upon successful logout or deletion, the app triggers a full process restart via ProcessPhoenix to reset the application state. The page also displays user profile information and provides links to the Terms of Use and Inquiry pages via an in-app WebView.

feature/my/src/main/java/com/hankki/feature/my/mypage · high confidence

Added Kotlin data classes (StoreDetailResponseDto, StoreDetailHeartResponseDto, StoreDetailNicknameResponseDto, FavoritesResponseDto) in the data layer to deserialize store detail, heart, nickname, and favorites API responses into domain entities.

data/storedetail/src/main/java/com/hankki/data/storedetail/response · high confidence

The SearchStore feature is now available, allowing users to search for stores by name with debounced input and view results in a list. Users can select a store to report it; the system validates the store against the user's university, handling cases where the store is already registered at their school, registered at another school (offering an 'add' option), or new. The UI includes loading, empty, and error states, and navigation to the store detail page or the report completion screen is triggered based on the validation outcome.

feature/report/src/main/java/com/hankki/feature/report/searchstore · high confidence

A new domain module for university selection has been added, providing the core data structures and repository interface for this feature. The module includes the \UniversitySelectionEntity\ to represent university details (name, coordinates) and the \UniversitySelectionRequestEntity\ for submission payloads. It also defines the \UniversitySelectionRepository\ interface, which exposes methods to retrieve the list of available universities and to post a user's selection.

domain/universityselection · high confidence

The university selection feature now includes a dedicated screen allowing users to choose a specific university or accept a default 'All' (전체) selection. The implementation uses a lazy list to display available universities, tracks the user's choice in state, and posts the selection to the backend. If no university is explicitly selected, the system defaults to the 'All' option with predefined coordinates, ensuring a valid selection is always submitted.

feature/universityselection/src/main/java/com/hankki/feature/universityselection · high confidence

Adds a new Amplitude integration within the core common module, providing an AmplitudeManager that initializes the SDK and exposes a centralized track method for logging events. This change introduces structured enums for EventType (such as Add, Click, Create, Completed) and PropertyKey (including Store, Food, Price, and Jogbo) to standardize event naming and property definitions, along with a CompositionLocal for dependency injection of the tracker.

core/common/src/main/java/com/hankki/core/common/amplitude · high confidence

The login feature now includes dedicated navigation definitions for the Login and Onboarding screens. Users can navigate to the login screen with an optional flag to trigger a login dialog, and the onboarding flow is wired to proceed to the university selection screen. This establishes the entry points and transitions for the initial user journey within the app.

feature/login/src/main/java/com/hankki/feature/login/navigation · high confidence

This change adds several new model classes to the Home feature's data layer to support recent UI and logic updates. It defines \ChipState\ and \ChipStyle\ to manage the visual appearance and selection state of home chips (Selected, Unselected, Fixed), including specific color definitions for the fixed state. New models include \StoreItemModel\ for displaying store details with image support, \PinModel\ for map pin coordinates, \MarkerItem\ for map markers, \UniversityModel\ for university data, and helper classes \CategoryChipItem\ and \ChipItem\ for filter chips. Extension functions are also added to map domain entities (\StoreEntity\, \StorePinEntity\, \UniversityResponseEntity\) to these new models.

feature/home/src/main/java/com/hankki/feature/home/model · high confidence

The application now includes Dagger Hilt modules to manage the lifecycle and injection of core data storage components. Specifically, the new SharedPreferencesModule provides a singleton SharedPreferences instance backed by the application context, while the TokenDataStoreModule provides a singleton TokenDataStore implementation that depends on the shared preferences. These changes enable dependency injection for token storage and general shared preferences throughout the app without manual instantiation.

core/datastore/src/main/java/com/hankki/core/datastore/di · high confidence

A new HomeRepository interface has been added to the domain layer, defining the contract for fetching home screen data. This interface exposes methods to retrieve user university information, category lists (including price and sort categories), store listings with filtering and sorting options, store pins, store thumbnails, and favorite store details (Jogbo). It also includes functionality to add stores to a user's favorites list, establishing the data access layer for the home feature.

domain/home/src/main/java/com/hankki/domain/home/repository · high confidence

A new LoginDataSource interface has been added to the login data module, defining a postLogin method that accepts an accessToken and a LoginRequestDto, and returns a BaseResponse containing a LoginResponseDto. This establishes the contract for the login data source, integrating with the core network BaseResponse wrapper.

data/login/src/main/java/com/hankki/data/login/datasource · high confidence

A new data class MyJogboModel has been added to represent jogbo items, including fields for ID, image, name, and selection state. This model includes a conversion function from the domain entity MyJogboEntity and a utility function transformImage that maps string-based image type identifiers (e.g., "TYPE\_ONE") to specific drawable resource IDs from the design system.

feature/my/src/main/java/com/hankki/feature/my/myjogbo/model · high confidence

A new MyRepository interface has been added to the domain layer, defining the contract for user-related data operations. This interface exposes methods for retrieving user information, managing Jogbo lists (including creation, deletion, and detail retrieval), handling store interactions (liking/unliking, viewing liked/reported stores), and managing account status (logout, withdrawal, and ownership checks). It serves as the primary abstraction for the 'My' page features, including shared Jogbo functionality.

domain/my/src/main/java/com/hankki/domain/my/repository · high confidence

A new ReportRepository interface has been added to the report domain, defining the contract for data operations related to store reporting and management. This interface exposes methods for retrieving store locations, report counts, categories, and user information, as well as actions for validating stores, posting reports with optional images, managing university associations, and handling favorite store interactions (jogbo). This change establishes the foundational data access layer for the report feature set.

domain/report/src/main/java/com/hankki/domain/report/repository · high confidence

The design system now exposes three new CompositionLocal providers—LocalSnackBarTrigger, LocalButtonSnackBarTrigger, and LocalWhiteSnackBarTrigger—to allow child components to trigger snack bar messages. These provide a standardized way for UI elements to request snack bar displays without direct dependencies on specific implementation details.

core/designsystem/src/main/java/com/hankki/core/designsystem/event · high confidence

The StoreDetailDataSource interface has been added to define the contract for store detail data operations. This interface exposes methods for retrieving store details, managing store favorites (hearts), interacting with user collections (jogbo), handling store nicknames, and performing CRUD operations on store menus (adding, updating, and deleting menu items).

data/storedetail/src/main/java/com/hankki/data/storedetail/datasource · high confidence

A new StoreDetailRepository interface has been added to the domain layer, defining the contract for store detail-related data operations. This interface exposes methods for retrieving store details and nicknames, managing store favorites (hearts) and jogbo associations, as well as handling menu CRUD operations including adding, updating, and deleting menu items. This change establishes the foundational repository contract for the store detail feature set.

domain/storedetail/src/main/java/com/hankki/domain/storedetail/repository · high confidence

A new TokenDataStore interface and its SharedPreferences-based implementation have been added to the core datastore module. This change introduces a dedicated mechanism for storing and retrieving access and refresh tokens, along with a clearInfo function to remove them, enabling the application to manage user authentication state locally.

core/datastore/src/main/java/com/hankki/core/datastore · high confidence

The design system now includes two new top bar components: HankkiTopBar, which supports leading, central, and trailing icons with a fixed 48dp height, and HankkiHeadTopBar, a simpler variant with a minimum height of 41dp. These components provide a standardized way to structure header content across the application.

core/designsystem/src/main/java/com/hankki/core/designsystem/component/topappbar · high confidence

A new data module for token management has been added, providing the concrete implementation of the TokenRepository interface. This includes TokenRepositoryImpl, which handles storing and retrieving access and refresh tokens via TokenDataStore, and TokenRepositoryModule, which configures Dagger Hilt to bind the implementation to the interface for singleton-scoped dependency injection.

data/token · high confidence

New Hilt modules have been introduced in the login data layer to configure dependency injection. DataSourceModule binds the LoginDataSource interface to its implementation, RepositoryModule binds the LoginRepository interface to its implementation, and ServiceModule provides the LoginService instance using a Retrofit client annotated with the NoToken qualifier.

data/login/src/main/java/com/hankki/data/login/di · high confidence

The LoginDataSourceImpl class has been added to the data login module, implementing the LoginDataSource interface. It provides a postLogin method that accepts an accessToken and a LoginRequestDto, delegating the call to the underlying LoginService and returning a BaseResponse containing a LoginResponseDto.

data/login/src/main/java/com/hankki/data/login/datasourceImpl · high confidence

The MyRepositoryImpl class has been added to implement the MyRepository interface, providing the data layer for user profile and jogbo-related features. This implementation connects to MyDataSource to support retrieving user information, managing jogbo lists and details, handling store interactions (liking, unliking, reporting), and managing user account actions such as logout and withdrawal. It also includes functionality for creating and sharing jogbos and checking jogbo ownership.

data/my/src/main/java/com/hankki/data/my/repositoryimpl · high confidence

A new MyStoreModel data class has been added to the My Store feature to represent store information, including fields for category, heart count, ID, image URL, like status, lowest price, and name. A corresponding extension function converts StoreEntity domain objects into this model, enabling the UI layer to consume store data with consistent default values.

feature/my/src/main/java/com/hankki/feature/my/mystore/model · high confidence

This change introduces a new set of Compose UI modifier extensions and a formatting utility in the common module. Users can now apply a 'bounceClick' effect with scale and color animations to clickable elements, use 'dashedBorder' for styled round-rect outlines, and leverage 'animateScrollAroundItem' to automatically scroll a list to a focused item. Additionally, a 'formatPrice' extension is added to Strings to display integers with thousand separators, and utility modifiers like 'noRippleClickable' and 'ignoreNextModifiers' are provided for specific interaction control.

core/common/src/main/java/com/hankki/core/common/extension · high confidence

The app now includes a new screen for creating a Jogbo, supporting both personal and shared creation modes. Users can input a title and tags, with the submit button enabled only when both fields are non-empty. The feature integrates with the backend API to create the Jogbo and handles specific error scenarios, such as displaying a dialog when a duplicate name is detected (HTTP 409). It also tracks user interactions via Amplitude analytics.

feature/my/src/main/java/com/hankki/feature/my/newjogbo · high confidence

Added new Compose UI components for the My Jogbo detail screen: JogboHeader (top bar with back navigation and title), JogboFolder (main card with title, hashtag chips, user info, and share button), JogboHashtagChip, JogboShareButton, and MoveToHomeButton. These components support displaying shared vs. owned Jogbo states and include preview functions for design verification.

feature/my/src/main/java/com/hankki/feature/my/myjogbodetail/component · high confidence

Added three new Compose UI components to the My feature's Jogbo list: AddJogboItem, which displays a button to add a new list with distinct states for edit and non-edit modes; JogboItem, which renders an individual list item with a title, image, and selection indicator; and JogboItemText, a shared text component used for displaying titles with specific styling and overflow handling. These components form the visual building blocks for the Jogbo list interface.

feature/my/src/main/java/com/hankki/feature/my/myjogbo/component · high confidence

Added the ReportFinishCard composable, which displays the reported store name and provides a clickable action to add a 'jogbo' (note). The card visually distinguishes between adding a new jogbo versus adding to an existing one by dynamically changing the button text and includes a shadow effect and rounded corners for styling.

feature/report/src/main/java/com/hankki/feature/report/finish/component · high confidence

A new Report Finish screen has been added to the report feature, displaying a completion summary and the associated store details. Users can navigate to the store detail page or return to the home screen from this view. The screen also integrates with the Jogbo system, allowing users to add the current store to their Jogbo favorites via a bottom sheet; this action triggers a confirmation message and updates the UI state to reflect the addition.

feature/report/src/main/java/com/hankki/feature/report/finish · high confidence

The Store Detail feature now includes a suite of new Compose UI components to support menu management and store display. Users can now edit menu items via the new HankkiModTextField and SegmentedButton (Delete/Edit options), with a PriceWarningMessage alerting them when menu prices exceed 8,000 won. The StoreDetailMenuBox displays the updated menu list, while StoreDetailHeadBox and StoreDetailMapBox present the store's title, category, and an interactive Naver Map with address copy functionality. Additional components like StoreDetailButton variants and the StoreDetailCategoryChip enhance the visual presentation of store details and actions.

feature/storedetail/src/main/java/com/hankki/feature/storedetail/component · high confidence

Added the StoreItem composable, which displays store details including image, category, name, heart count, and price, and supports both click and long-press interactions. Also added the UrlImage composable, which loads images from URLs using Coil and displays a placeholder in preview/inspection mode.

core/designsystem/src/main/java/com/hankki/core/designsystem/component/item · high confidence

A new UniversityItem composable component has been added to the university selection feature. This component displays a university name and allows users to select it by tapping, visually distinguishing the selected item with a specific color (Red500) and typography style compared to the unselected state (Gray800).

feature/universityselection/src/main/java/com/hankki/feature/universityselection/component · high confidence

The build-logic module now provides a set of Gradle plugin conventions that standardize Android project configuration. These conventions automatically apply and configure Kotlin 17, Compose (including Material3 and strong skipping mode), Hilt with KSP, Kotlinx Serialization, and Coroutines. They also enforce Java 17 compilation, enable core library desugaring, and provide a helper to set the Android namespace based on the module name.

build-logic/src/main/java/com · high confidence

The design system now includes four new Compose dialog components: SingleButtonDialog, DoubleButtonDialog, ImageDoubleButtonDialog, and DialogWithDescription. These components provide reusable UI patterns for confirmation prompts, informational messages, and actions involving named users, featuring consistent styling with rounded corners, specific typography, and support for optional descriptions and multiple button configurations.

core/designsystem/src/main/java/com/hankki/core/designsystem/component/button, core/designsystem/src/main/java/com/hankki/core/designsystem/component/dialog · high confidence

This change introduces several new data models in the store detail domain to support upcoming API integrations. Specifically, it adds \StoreDetailResponseEntity\ and \MenuItem\ to structure store information including menus and location data, \StoreDetailHeartsResponseEntity\ for heart/like counts, \StoreDetailNicknameEntity\ for user nicknames, \JogboResponseEntity\ for jogging-related store data, and request entities (\StoreDetailMenuAddRequestEntity\, \MenuUpdateRequestEntity\) for menu management operations.

domain/storedetail/src/main/java/com/hankki/domain/storedetail/entity · high confidence

Added new data classes in the domain layer to support the 'My' page functionality, including \MyJogboEntity\ and \MyJogboDetailEntity\ for jogbo (group) management, \UserInformationEntity\ for user profile data, \IsJogboOwnerEntity\ for ownership checks, \LikedStoreResponseEntity\ for store interaction status, and \StoreEntity\ for store details.

domain/my/src/main/java/com/hankki/domain/my/entity/response · high confidence

This change introduces the complete data layer for the home screen, enabling users to discover stores filtered by university, category, price, and sort options. It adds data sources and DTOs for retrieving university details, store categories, price categories, and sort options, as well as fetching store lists, store pins, and store thumbnails. Additionally, it supports managing user favorites (Jogbo) by allowing retrieval of a user's saved stores and adding new stores to their favorites.

data/home · high confidence

This change introduces a suite of new Compose components for the home feature, including \HankkiCategoryScrollableTabRow\ for category selection, \HankkiFilterBottomSheet\ and \HankkiFilterChip\ for price and sort filtering, \HankkiStateChip\ for stateful filter controls, \HomeStoreItem\ for displaying store listings with a plus button, and \RepositionButton\ for map repositioning. These components implement the visual design for the home page, including chip shadows, bounce click animations, and gradient indicators, and integrate amplitude tracking for user interactions.

feature/home/src/main/java/com/hankki/feature/home/component · high confidence

The design system now includes new layout components to standardize UI patterns. A loading screen has been added that uses a Lottie animation instead of a simple spinner, alongside a basic circular progress indicator. Empty states are now handled by reusable views that display an image and text, with an optional button slot. Additionally, top and bottom blur layouts have been introduced to apply gradient overlays to the screen edges.

core/designsystem/src/main/java/com/hankki/core/designsystem/component/layout · high confidence

The store detail module now includes a dedicated screen for editing restaurant menus. Users can view, select, and delete menu items. A key behavioral change is the addition of a specific warning dialog when attempting to delete the last remaining menu item, alerting the user that deleting it will result in the entire restaurant being removed. The interface also handles loading and error states, displaying snackbar notifications for failures.

feature/storedetail/src/main/java/com/hankki/feature/storedetail/editbottomsheet/edit/editmenu · high confidence

The store detail module now includes a dedicated route for editing menu items, featuring a new UI with fields for menu name and price. The system enforces a price limit of 8,000, displaying a warning when exceeded and preventing submission if the limit is breached. Users must confirm changes via a completion dialog, and can delete the last menu item, which triggers a specific confirmation dialog. The flow includes success screens and snackbar notifications for errors.

feature/storedetail/src/main/java/com/hankki/feature/storedetail/editbottomsheet/edit/mod · high confidence

Added a set of new data-transfer objects in the report module to handle API responses for categories, favorites (Jogbo), store details, locations, university info, and user info. These DTOs define the structure for deserializing JSON payloads (e.g., category lists, favorite items with titles and images, store validation status) and include mapping functions to convert them into domain entities, enabling the report feature to consume these specific data points from the backend.

data/report/src/main/java/com/hankki/data/report/dto/response · high confidence

Added two new data transfer objects to the request DTO package: JogbosRequestDto, which accepts a list of favorite IDs for managing favorites, and NewJogboDto, which accepts a title and a list of details for creating new Jogbo entries. These DTOs include serialization annotations and extension functions to facilitate conversion from domain entities.

data/my/src/main/java/com/hankki/data/my/dto/request · high confidence

Added two new domain request entities to support store-related operations: ReportStoreRequestEntity, which captures store details including name, category, address, location coordinates, university association, and associated menus; and ValidateStoreRequestEntity, which captures university ID, location coordinates, and store name for validation purposes.

domain/report/src/main/java/com/hankki/domain/report/entity/request · high confidence

A new data class, NewJogboEntity, has been added to the domain layer to represent the request payload for creating a new Jogbo. This entity captures the title and a list of details required for the operation.

domain/my/src/main/java/com/hankki/domain/my/entity/request · high confidence

Added new data-transfer objects to support the 'My' page features: IsJogboOwnerResponseDto for checking jogbo ownership, JogboDetailDto for detailed jogbo information including stores and nickname, LikedStoreResponseDto for store like status, MyJogboDto for listing user's jogbos, StoreDto for store details, and UserInformationDto for user nickname. Each DTO includes serialization annotations and conversion methods to domain entities.

data/my/src/main/java/com/hankki/data/my/dto/response · high confidence

This change introduces two new utility files in the common module. Regex.kt provides pre-compiled regular expressions for validating Korean, English, and special character inputs with length limits of 20 and 30 characters, as well as a validator for numbers under 100,000. UiState.kt defines sealed interfaces for representing Loading, Success, Failure, and Empty states, enabling consistent handling of UI data states across the application.

core/common/src/main/java/com/hankki/core/common/utill · high confidence

Added Hilt modules to wire the report data layer, providing bindings for ReportDataSource, ReportRepository, and ReportService to enable dependency injection for report-related operations.

data/report/src/main/java/com/hankki/data/report/di · high confidence

The Store Detail feature has been expanded to allow users to report inaccurate store information and manage menu items. Users can now submit a report via a new confirmation flow that deletes the store listing if confirmed, and the UI includes a dedicated report route with radio-button options for the reason. Additionally, the screen now supports adding and editing menu items through bottom sheets, and displays a heart count for liked stores. The view model handles state for these interactions, including loading states, navigation side effects, and snack bar notifications for actions like store deletion.

feature/storedetail/src/main/java/com/hankki/feature/storedetail · high confidence

The data module for university selection has been implemented, introducing the ability to retrieve available universities and submit a user's university choice. This change adds the network service interface (Retrofit) for endpoints /api/v1/universities and /api/v1/users/me/university, along with the corresponding data source, repository, and DTOs (request/response) to handle the data flow. Dependency injection modules (Hilt) are also added to bind the service, data source, and repository implementations.

data/universityselection/src/main/java · high confidence

The My data module now includes three new Dagger Hilt modules (DataSourceModule, RepositoryModule, and ServiceModule) that wire up the data layer. DataSourceModule binds the MyDataSource interface to its MyDataSourceImpl implementation, while RepositoryModule binds the MyRepository interface to MyRepositoryImpl. ServiceModule provides Retrofit-based instances for both MyService (using the @JWT qualifier) and NoTokenMyService (using the @NoToken qualifier), enabling the application to inject these services without manual instantiation.

data/my/src/main/java/com/hankki/data/my/di · high confidence

This change adds a set of new Gradle convention plugins to the build-logic module, establishing a standardized build configuration for the project. It introduces plugins for Android applications, libraries, and features, which automatically apply Kotlin, Hilt, Coroutines, and Compose configurations. Specifically, the feature plugin bundles dependencies for navigation, lifecycle, and UI components, while the data plugin configures Retrofit and serialization. A dedicated Kotlin library plugin is also added to enforce JVM toolchain 17.

build-logic/src/main/java · high confidence

The Add Menu screen in the Store Detail feature now enforces a price range of 1 to 8000, displays error states for invalid prices, and shows a snackbar for submission errors. The delete button is hidden when only one menu item remains, and the interface includes focus management and analytics tracking for menu addition completion.

feature/storedetail/src/main/java/com/hankki/feature/storedetail/editbottomsheet/add/addmenu · high confidence

The app module now includes a dedicated proguard-rules.pro file to configure code shrinking and obfuscation for release builds. This configuration preserves essential classes and members for Kotlin, Android components, Jetpack Compose, Hilt, Retrofit, and other key libraries, ensuring that reflection-based features and public APIs remain functional while reducing the final APK size.

app · high confidence

The Store Detail feature now uses a dedicated navigation layer that defines serializable routes for the main store view, menu editing flows (add, edit, modify), and their respective success states. This change introduces helper functions to navigate between these screens while managing the back stack (e.g., popping to the store detail view upon completion) and wires up the UI callbacks to trigger these navigation actions, effectively consolidating how users move through the store management workflow.

feature/storedetail/src/main/java/com/hankki/feature/storedetail/navigation · high confidence

The reissue token data implementation has been relocated from the network module to a new, dedicated \data/reissuetoken\ module. This change introduces the data-layer components (DataSource, Repository, Service, and DI bindings) for refreshing authentication tokens, while the domain interface remains in the domain layer. Users benefit from a cleaner separation of concerns where token reissuance logic is now isolated in its own data module.

data/reissuetoken · high confidence

The reissue token functionality has been relocated from the network module to the domain module. This change introduces a new domain layer containing a \ReissueTokenRepository\ interface and a \ReissueTokenResponseEntity\ data class, establishing the core domain model and repository contract for token reissuance within this specific module.

domain/reissuetoken · high confidence

A new Border constant file has been added to the design system, defining internal values for focused (1.5) and unfocused (1) border radii to standardize visual styling.

core/designsystem/src/main/java/com/hankki/core/designsystem/constant · high confidence

The project now includes a Gradle wrapper configuration that pins the build tool to version 8.9. This ensures that all developers and CI environments use the same specific Gradle distribution, improving build consistency and reproducibility across the team.

gradle · high confidence

The project is initialized with a multi-module structure (app, core, data, domain, feature, baselineprofile) and a centralized build-logic plugin. The build configuration defines Android SDK targets (compileSdk 35, targetSdk 35, minSdk 28) and integrates key libraries including Kakao SDK (v2-user, v2-share), Naver Map, Retrofit, OkHttp, Coil, Lottie, and Hilt. It also sets up Baseline Profile generation for performance optimization and configures build variants for debug, release, and benchmark builds.

(dependencies) · high confidence

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

• CAI 46 → 47 (+1.0)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 95 → 94 (-1.1)
• Architecture 85 → 86 (+0.6)
• Maturity 51 → 52 (+0.3)
• Readiness 15 → 17 (+1.9)
• Security 95 → 97 (+2.4)
• Domain Modelling 100 → 100 (+0.0)

• Change coupling: HomeRoute.kt ↔ HomeNavigation.kt (feature/home/src/main/java/com/hankki/feature/home/HomeRoute.kt)
• Change coupling: HomeRoute.kt ↔ HomeState.kt (feature/home/src/main/java/com/hankki/feature/home/HomeRoute.kt)
• Change coupling: MainScreen.kt ↔ MainTab.kt (feature/main/src/main/java/com/hankki/feature/main/MainScreen.kt)
• Change coupling: ReportDataSource.kt ↔ ReportService.kt (data/report/src/main/java/com/hankki/data/report/datasource/ReportDataSource.kt)
• Change coupling: ReportRepositoryImpl.kt ↔ ReportService.kt (data/report/src/main/java/com/hankki/data/report/repositoryimpl/ReportRepositoryImpl.kt)
• Change coupling: ReportService.kt ↔ ReportRepository.kt (data/report/src/main/java/com/hankki/data/report/service/ReportService.kt)
• Dependency hygiene not measured — no supported dependency manifest was read
• Duplicated block (10 lines × 2) (feature/my/src/main/java/com/hankki/feature/my/myjogbodetail/MyJogboDetailViewModel.kt)
• Duplicated block (10 lines × 2) (feature/storedetail/src/main/java/com/hankki/feature/storedetail/navigation/navigateStoreDetail.kt)
• Duplicated block (13 lines × 2) (feature/my/src/main/java/com/hankki/feature/my/newjogbo/NewJogboViewModel.kt)
• Duplicated block (14 lines × 2) (feature/home/src/main/java/com/hankki/feature/home/HomeViewModel.kt)
• Duplicated block (15 lines × 2) (core/designsystem/src/main/java/com/hankki/core/designsystem/component/dialog/DialogWithDescription.kt)
• Duplicated block (15 lines × 2) (feature/report/src/main/java/com/hankki/feature/report/main/ReportRoute.kt)
• Duplicated block (16 lines × 2) (core/designsystem/src/main/java/com/hankki/core/designsystem/component/dialog/DoubleButtonDialog.kt)
• Duplicated block (16 lines × 2) (feature/login/src/main/java/com/hankki/feature/login/OnboardingRoute.kt)
• Duplicated block (17 lines × 2) (feature/my/src/main/java/com/hankki/feature/my/newjogbo/NewJogboRoute.kt)
• Duplicated block (18 lines × 2) (feature/storedetail/src/main/java/com/hankki/feature/storedetail/editbottomsheet/edit/delete/DeleteSuccessLastRoute.kt)
• Duplicated block (18 lines × 3) (feature/login/src/main/java/com/hankki/feature/login/OnboardingRoute.kt)
• Duplicated block (19 lines × 2) (feature/storedetail/src/main/java/com/hankki/feature/storedetail/editbottomsheet/add/addsuccess/AddMenuSuccessRoute.kt)
• Duplicated block (19 lines × 3) (feature/login/src/main/java/com/hankki/feature/login/OnboardingRoute.kt)
• …and 8 more

• Change coupling: AddPhotoButton.kt ↔ StoreNameSearchButton.kt (core/designsystem/src/main/java/com/hankki/core/designsystem/component/button/AddPhotoButton.kt)
• Change coupling: DoubleButtonDialog.kt ↔ ImageDoubleButtonDialog.kt (core/designsystem/src/main/java/com/hankki/core/designsystem/component/dialog/DoubleButtonDialog.kt)
• Change coupling: HankkiFilterChip.kt ↔ HankkiStateChip.kt (feature/home/src/main/java/com/hankki/feature/home/component/HankkiFilterChip.kt)
• Change coupling: HomeRepository.kt ↔ HomeState.kt (domain/home/src/main/java/com/hankki/domain/home/repository/HomeRepository.kt)
• Change coupling: ImageDoubleButtonDialog.kt ↔ StoreDetailRoute.kt (core/designsystem/src/main/java/com/hankki/core/designsystem/component/dialog/ImageDoubleButtonDialog.kt)
• Change coupling: JogboFolder.kt ↔ JogboShareButton.kt (feature/my/src/main/java/com/hankki/feature/my/myjogbodetail/component/JogboFolder.kt)
• Change coupling: JogboFolder.kt ↔ MoveToHomeButton.kt (feature/my/src/main/java/com/hankki/feature/my/myjogbodetail/component/JogboFolder.kt)
• Change coupling: JogboShareButton.kt ↔ MoveToHomeButton.kt (feature/my/src/main/java/com/hankki/feature/my/myjogbodetail/component/JogboShareButton.kt)
• Change coupling: ReportFinishCard.kt ↔ ReportRoute.kt (feature/report/src/main/java/com/hankki/feature/report/finish/component/ReportFinishCard.kt)
• Change coupling: ReportRoute.kt ↔ ReportState.kt (feature/report/src/main/java/com/hankki/feature/report/main/ReportRoute.kt)
• Change-coupling hub: HomeRoute.kt → HankkiTopBar.kt, HomeState.kt, HankkiFilterChip.kt, HomeNavigation.kt (feature/home/src/main/java/com/hankki/feature/home/HomeRoute.kt)
• Change-coupling hub: MainScreen.kt → HomeNavigation.kt, MainActivity.kt, MainTab.kt, MyNavigation.kt, ReportNavigation.kt (feature/main/src/main/java/com/hankki/feature/main/MainScreen.kt)
• Change-coupling hub: MyJogboDetailRoute.kt → BaseEmptyView.kt, MyJogboDetailState.kt, MyStoreRoute.kt (feature/my/src/main/java/com/hankki/feature/my/myjogbodetail/MyJogboDetailRoute.kt)
• Change-coupling hub: MyRoute.kt → DoubleButtonDialog.kt, JogboShareButton.kt, MoveToHomeButton.kt, ArrowIconButton.kt (feature/my/src/main/java/com/hankki/feature/my/mypage/MyRoute.kt)
• Change-coupling hub: ReportService.kt → ReportDataSource.kt, ReportRepositoryImpl.kt, ReportRepository.kt (data/report/src/main/java/com/hankki/data/report/service/ReportService.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (feature/my/src/main/java/com/hankki/feature/my/myjogbodetail/MyJogboDetailViewModel.kt)
• …and 32 more

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

Team-Hankki/hankki-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.