android/compose-samples

This repository is a collection of Android sample applications, including JetLagged, JetNews, Jetcaster, Jetchat, Jetsnack, and Reply, designed to demonstrate modern Jetpack Compose development practices. Each sample implements a distinct domain—such as sleep tracking, news reading, podcasting, messaging, food ordering, and email management—while showcasing advanced UI patterns like adaptive layouts, Material 3 theming, and home screen widgets. The codebase also provides shared infrastructure for build automation, dependency management, and testing across these diverse reference implementations.

41 changes.

This period focused on releasing and expanding a suite of Jetpack Compose sample applications, including JetNews, Jetsnack, Jetchat, and Jetcaster, to demonstrate various UI patterns and architectural approaches. The work involved establishing robust data layers with repository abstractions and dependency injection, while simultaneously migrating all samples to Material 3 theming, adaptive layouts, and modern navigation components. Additionally, build infrastructure was standardized across projects using Gradle 9.5.0 and centralized dependency management, alongside the addition of comprehensive UI tests and maintenance automation scripts.

46 changes.

This period focused on developing and expanding a suite of Jetpack Compose sample applications, including Reply, Jetcaster, JetLagged, and JetNews, to demonstrate modern Android development practices. The work emphasized adaptive layouts that dynamically adjust to various screen sizes and form factors such as foldables, tablets, and Wear OS devices. Additionally, the samples integrated Material 3 design systems, Glance-based home screen widgets, and comprehensive testing infrastructure to showcase robust, production-ready architectures.

7 changes.

This period focused on migrating JetNews to the Navigation 3 runtime, rewriting its deep-linking and back-stack management logic to support key-based navigation. Simultaneously, the Jetsnack app expanded its home screen presence by implementing a new Recent Orders Glance widget with responsive Compose layouts, while Jetchat introduced hardware-accelerated frosted-glass effects for UI elements.

The JetLagged sample app, a sleep tracking application built with Jetpack Compose, has been added to the repository. This addition includes the necessary project scaffolding such as Gradle wrapper scripts, an .editorconfig for code style consistency, a .gitignore file, and licensing information for assets.

JetLagged · high confidence

The Jetcaster app now includes a home screen widget built with Android Glance. This widget displays the current podcast episode title, podcast name, and album art, along with a play/pause button. It supports multiple size buckets to adapt to different home screen grid configurations and uses the app's Material 3 color scheme for light and dark modes.

Jetcaster/glancewidget/src/main/java · high confidence

The Jetsnack app now includes a complete model layer in the \com.example.jetsnack.model\ package, providing the data structures and static content that power the UI. This introduces a \Snack\ data class and a \SnackRepo\ object containing static lists of snack items organized into collections (such as 'Android's picks' and 'Popular on Jetsnack'), along with an \OrderLine\ model for cart state. To support navigation and filtering, the diff adds a \Filter\ class and static lists for category, lifestyle, price, and sort filters, as well as a \SearchRepo\ with static search categories and suggestions. Additionally, a \SnackbarManager\ is introduced using Kotlin \StateFlow\ to manage the display of transient UI messages.

Jetsnack/app/src/main/java/com/example/jetsnack/model · high confidence

The app now includes a new home screen widget that displays a list of recent orders. Users can view their latest order history directly from the home screen, and tapping the shopping cart icon in the widget title bar navigates to the main cart activity. The widget supports multiple sizes (small, medium, large) and includes a demonstration activity to show how widget actions are handled.

Jetsnack/app/src/main/java/com/example/jetsnack/widget · high confidence

This change introduces the Snack Detail screen, providing a dedicated view for individual snack items. The implementation features a scrollable layout with a sticky header and title, an image that scales and moves via shared element transitions from the list view, and a bottom bar for cart interactions. It also includes a 'see more' functionality for long descriptions and utilizes Material 3 components for theming.

Jetsnack/app/src/main/java/com/example/jetsnack/ui/snackdetail · high confidence

The Jetsnack app now includes a new Search screen that allows users to browse food categories, view search suggestions, and see filtered results. The implementation adds four new UI components: SearchCategories for displaying grouped food items with custom layouts, SearchResults for listing matching snacks with prices and add-to-cart buttons, SearchSuggestions for showing autocomplete suggestions, and a main Search composable that manages the search state and switches between these views based on user interaction.

Jetsnack/app/src/main/java/com/example/jetsnack/ui/home/search · high confidence

Users can now view unread messages directly on their device's home screen via a new Glance-based widget. This change introduces the JetChatWidget implementation and its corresponding WidgetReceiver, which fetches the list of unread messages and displays them using the app's Glance theme and custom composables.

Jetchat/app/src/main/java/com/example/compose/jetchat/widget · high confidence

A new \Currency.kt\ utility file was added to the UI utils package, providing a \formatPrice\ function that converts a long value representing cents into a localized currency string.

Jetsnack/app/src/main/java/com/example/jetsnack/ui/utils · high confidence

Introduced the RecentOrdersDataRepository in the widget data layer to supply mock order data to the new Recent Orders Glance widget. This component manages a local cache of demo order items and exposes them as a Flow, enabling the widget to display a list of recent snack orders with associated images and actions.

Jetsnack/app/src/main/java/com/example/jetsnack/widget/data · high confidence

The app now includes the underlying data structures and view model for the home screen, enabling the display of sleep graphs, wellness metrics (snoring, coughing, respiration), and heart rate data. This change introduces \JetLaggedHomeScreenState\ to aggregate these data points, along with \JetLaggedHomeScreenViewModel\ to manage the UI state, and provides fake data implementations (\FakeHeartRateData\, \FakeSleepData\) to populate these views during development.

JetLagged/app/src/main/java/com/example/jetlagged/data · high confidence

Users can now view recent chat messages directly on their Android home screen via a new Glance-based widget. The widget displays a scrollable list of message items, showing the author and content, and allows users to tap a message to open the main JetChat activity.

Jetchat/app/src/main/java/com/example/compose/jetchat/widget/composables · high confidence

The app now includes a dedicated AppNavRail component for large screens, providing a vertical navigation sidebar with icons and labels that mirrors the mobile bottom navigation. Additionally, a new JetnewsSnackbarHost component has been introduced to handle snackbars with specific layout constraints for large screens, limiting their width to 550dp and aligning them to the start. These changes enhance the user experience on tablets and large displays by offering more efficient navigation and better message visibility.

JetNews/app/src/main/java/com/example/jetnews/ui/components · high confidence

Introduced the core data layer for the Reply application, including data classes for Account, Email, and EmailAttachment, along with an enum for MailboxType. Implemented repository interfaces (AccountsRepository, EmailsRepository) and their local implementations, which serve dummy data via LocalAccountsDataProvider and LocalEmailsDataProvider to support the app's UI and navigation.

Reply/app/src/main/java/com/example/reply/data · high confidence

The app now includes static data providers (\LocalAccountsDataProvider\ and \LocalEmailsDataProvider\) that supply mock account and email data for development and demonstration purposes. These providers populate the UI with sample user accounts, contacts, and email threads, allowing the application to function with realistic-looking content without requiring a live backend connection.

Reply/app/src/main/java/com/example/reply/data/local · high confidence

The Jetchat sample data layer now includes a comprehensive set of initial chat messages in FakeData.kt, featuring text, emojis, and media attachments. Specifically, the data model now supports video messages (via videoUri) and image resources (via drawable IDs), allowing users to see how the app handles rich content types in the conversation view.

Jetchat/app/src/main/java/com/example/compose/jetchat/data · high confidence

New theme definitions have been introduced for the Jetchat Glance widget, including a color scheme that applies the app's existing light and dark color palettes to the widget context, and a set of text styles (title and body medium) configured for Glance-compatible text rendering.

Jetchat/app/src/main/java/com/example/compose/jetchat/widget/theme · high confidence

The Jetsnack cart interface has been updated to allow users to remove items by swiping them away. This change introduces a new \SwipeDismissItem\ composable that wraps each cart entry, utilizing Material 3's \SwipeToDismissBox\ to handle the gesture. When a user swipes an item, it is visually dismissed with a fade and placement animation before being removed from the list via the \CartViewModel\.

Jetsnack/app/src/main/java/com/example/jetsnack/ui/home/cart · high confidence

The library screen now renders a dedicated section titled 'Latest episodes' that lists recent episodes from subscribed podcasts. This new UI component uses a grid layout to display episode details, allowing users to navigate to the player, queue episodes, or remove them from the queue directly from this view.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/home/library · high confidence

The home screen now displays a dedicated Heart Rate card that shows the average beats per minute alongside a smooth, gradient-filled graph visualizing heart rate variance over time. This new component, implemented in HeartRateCard.kt and HeartRateGraph.kt, integrates with the existing app theme to render the graph using specific color resources, providing users with a clear, visual summary of their heart rate data directly on the main dashboard.

JetLagged/app/src/main/java/com/example/jetlagged/heartrate · high confidence

The Jetcaster mobile application is introduced, featuring a new UI layer built with Jetpack Compose and Hilt. The app implements shared element transitions between the Home and Player screens, supports predictive back animations, and adapts to window size classes and display features. It includes an offline error dialog and manages navigation state to prevent duplicate events.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui · high confidence

The Jetcaster sample app is introduced as a podcast application built with Jetpack Compose, designed to demonstrate architecture and UI patterns across mobile, TV, and Wear OS form factors. The release includes a Redux-style architecture using ViewModels and StateFlow, integration with the Horologist Media Toolkit for Wear OS features (such as rotating side button support), and a dark-themed UI optimized for media consumption. The project setup includes standard Gradle wrapper scripts, an .editorconfig for code style consistency, and a stability configuration for Kotlin collections.

Jetcaster · high confidence

The Jetcaster core design system is established, providing the visual identity and building blocks for the app. This includes a comprehensive Material 3 color palette with light/dark modes and contrast levels, custom typography using Montserrat and RobotoFlex fonts, and shape definitions. Reusable UI components are introduced to support the player and podcast screens: \HtmlTextContainer\ for rendering HTML-formatted text with selection support, \ImageBackground\ with gradient and color scrims for header visuals, and \PodcastImage\ for displaying artwork with fade-in/out placeholder animations. A default empty-state vector graphic is also included.

Jetcaster/core/designsystem · high confidence

This change introduces the complete Jetcaster TV app, providing a dedicated interface for podcast consumption on Android TV devices. The app features a TV-optimized UI built with Jetpack Compose for TV, including a navigation drawer for switching between Discover, Library, Search, and Settings screens. Key capabilities include browsing podcasts and episodes in horizontal rows with robust D-pad focus management, a dedicated player screen with playback controls (play/pause, skip, rewind), and a dark-mode-only theme. The implementation includes custom UI components such as a circular loading indicator, error states, and background image handling, along with data models for categories, episodes, and podcasts.

Jetcaster/tv/src/main/java · high confidence

The Jetsnack sample app is now available, demonstrating how to implement a custom design system, custom layouts, and animations using Jetpack Compose. The project includes a bespoke color system that does not rely on Material color theming, custom layout implementations for features like collapsible images and bottom navigation, and uses Coil for image loading. This entry covers the initial commit of the sample code, documentation, and build configuration files.

Jetsnack · high confidence

The Reply sample project has been added, providing a Jetpack Compose implementation of a Material Design study for adaptive design. This sample demonstrates adaptive layouts for mobile, tablets, and foldables using Material 3 theming, dynamic colors (Material You), and dynamic window resizing. It includes configuration files such as .editorconfig for code formatting, .gitignore, and Gradle wrapper scripts to support building and running the app.

Reply · high confidence

The Jetcaster app now includes a local data layer that persists podcast information using a Room database. This change introduces database entities for podcasts, episodes, categories, and user subscriptions, along with corresponding Data Access Objects (DAOs) to manage these records. Repository classes (EpisodeStore, PodcastStore, CategoryStore) abstract the database operations, providing a clean interface for the rest of the application to fetch and store podcast data. A Dagger Hilt module wires up the database, DAOs, and repositories, while network utilities handle RSS feed fetching and parsing to populate the local storage.

Jetcaster/core/data · high confidence

The app now initializes a global \JetnewsApplication\ class that creates an \AppContainer\ instance during startup. This container acts as the central dependency injection point, allowing other components in the app to access shared data repositories and services.

JetNews/app/src/main/java/com/example/jetnews · high confidence

The app now uses a dedicated repository interface (PostsRepository) to manage post data, favorites, and interests. This change replaces previous direct data access patterns with a structured data layer, providing methods to fetch posts, observe feeds, and toggle favorites, supported by in-memory fake implementations for development and testing.

JetNews/app/src/main/java/com/example/jetnews/data/posts · high confidence

The app now includes a dedicated Interests screen that allows users to browse and select topics, people, and publications. This feature is implemented via a new \InterestsScreen\ composable that presents a tabbed interface (Topics, People, Publications) using Material 3 components like \PrimaryScrollableTabRow\ and \Scaffold\. The screen is backed by an \InterestsViewModel\ which manages the UI state and handles data fetching from the \InterestsRepository\ in parallel, exposing the results via \StateFlow\. Users can toggle their selections using the new \SelectTopicButton\ component, which visually indicates the selected state with distinct colors and icons.

JetNews/app/src/main/java/com/example/jetnews/ui/interests · high confidence

The app now defines specific data classes for representing news content, including \Post\ (with metadata, author, and paragraph details), \Publication\, and \PostsFeed\. The \PostsFeed\ class organizes posts into categories such as highlighted, recommended, popular, and recent, and provides a convenience property to access all posts in a single list. These models form the foundation for displaying structured news content in the UI.

JetNews/app/src/main/java/com/example/jetnews/model · high confidence

The Jetcaster mobile module now includes a new PlayerScreen and PlayerViewModel, providing the core UI and state management for the podcast player. This change introduces a responsive layout that adapts to different window sizes and display features, supports seeking via a slider, and displays episode details with HTML-formatted summaries. The player screen also features animations for thumbnails, shared element transitions, and the ability to add episodes to a queue with snackbar feedback.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/player · high confidence

The conversation screen now supports rich message styling, allowing users to format text with bold, italic, strikethrough, inline code, clickable links, and clickable user mentions. It also introduces audio recording via a swipe-to-cancel gesture and full video message support, including inline thumbnails in the chat list and a fullscreen player with frosted-glass controls. The UI has been migrated to Material 3 and uses a Scaffold layout to properly handle edge-to-edge display and IME padding.

Jetchat/app/src/main/java/com/example/compose/jetchat/conversation · high confidence

The JetNews sample application is introduced as a reference implementation for building news-reading apps with Jetpack Compose. The release includes the full source code for the app's UI, covering a post list, post details, and an interests screen, along with an AppWidget powered by Glance. It also provides the necessary build infrastructure, including Gradle wrapper scripts, an \.editorconfig\ for code formatting, and licensing information for fonts.

JetNews · high confidence

This release introduces a dedicated Wear OS version of the Jetcaster podcast app. The new module includes a complete navigation structure with screens for the player, library, latest episodes, podcast details, and the up-next queue. It integrates with Google's Horologist library for media playback and volume controls, utilizes Hilt for dependency injection, and applies a Material 3 design system tailored for wearables.

Jetcaster/wear/src/main · high confidence

The Jetchat sample app is introduced as a reference implementation for Jetpack Compose, featuring edge-to-edge UI with synchronized IME transitions, Material Design 3 theming with dynamic color support, and nested scrolling interop between View and Compose components. The entry includes the full README documentation detailing features like UI state management, navigation, and focus handling, along with build infrastructure files such as .editorconfig, .gitignore, and Gradle wrapper scripts to support the project setup.

Jetchat · high confidence

Developers can now use the new @DevicePreviews annotation in the mobile UI module to quickly preview Compose screens across a variety of device configurations, including Pixel 4A, generic phones, landscape mode, foldables, and tablets.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/tooling · high confidence

Added a set of Compose-based layout utilities for Android App Widgets (Glance) in the Jetsnack sample app. This includes a responsive ImageTextListLayout that adapts its grid/list presentation across Small, Medium, and Large widget sizes, along with supporting components like ListItem, NoDataContent, EmptyListContent, and rounded scrolling containers (RoundedScrollingLazyColumn and RoundedScrollingLazyVerticalGrid) to provide a consistent, rounded-rectangle scrolling experience for widget content.

Jetsnack/app/src/main/java/com/example/jetsnack/widget/layout · high confidence

The app now includes a dedicated data layer for managing user interests, defined by the new InterestsRepository interface and a corresponding FakeInterestsRepository implementation. This change introduces the ability to fetch curated lists of topics, people, and publications, and allows users to toggle their selections for these items. The repository exposes the currently selected interests via Kotlin Flows, enabling the UI to reactively display the user's personalized feed preferences.

JetNews/app/src/main/java/com/example/jetnews/data/interests · high confidence

The JetNews app now includes a home screen widget built with Glance, allowing users to view a curated feed of top posts directly on their device. This widget displays post titles, authors, and reading times, supports bookmarking, and opens the full article in the app when tapped. It adapts its layout based on available space and respects the system's light/dark theme, serving as a functional example for developers migrating to Compose-based widgets.

JetNews/app/src/main/java/com/example/jetnews/glance · high confidence

The Jetchat app now includes a dedicated Profile screen that displays user details (name, position, status, Twitter handle, and timezone) in a scrollable layout. This feature introduces Material 3 components, including a Floating Action Button that triggers a 'functionality not available' popup, and integrates with the app's navigation drawer. The implementation supports nested scrolling to coordinate with the app bar and includes preview compositions for various screen widths and dark theme modes.

Jetchat/app/src/main/java/com/example/compose/jetchat/profile · high confidence

The app introduces new Compose UI components in the \ui.components\ package to enhance the email viewing experience. \ReplyEmailListItem\ now supports multi-select mode with visual highlighting for selected and opened emails, and enables long-press to toggle selection. \ReplyEmailThreadItem\ displays individual thread messages with reply and reply-all action buttons. A new \ReplyDockedSearchBar\ component provides a docked search interface that filters emails by subject or sender in real-time. These components are built using Material 3 design primitives.

Reply/app/src/main/java/com/example/reply/ui/components · high confidence

The backgrounds module now includes several new visual options: BubbleBackground and FadingCircleBackground provide animated circle-based visuals, while SimpleGradientBackground adds a vertical gradient modifier. Additionally, shader-based backgrounds (SolarFlareShaderBackground and MovingStripesBackground) are introduced for Android 13+ to render complex animated patterns via RuntimeShader, with a simple gradient fallback for older devices.

JetLagged/app/src/main/java/com/example/jetlagged/backgrounds · high confidence

Added a set of shell scripts to the scripts directory to streamline the maintenance of Compose sample apps. The new tools include verify\_samples.sh to check builds, lint, and formatting; format.sh to automatically apply code formatting via Spotless; updateDeps.sh to update dependencies using the version catalog (excluding Jetcaster); checksum.sh to generate file checksums; and gradlew\_recursive.sh to run Gradle commands across all sample projects.

scripts · high confidence

The home screen now includes a new category view that displays top podcasts in a horizontal uncontained carousel and lists episodes below. The carousel items support tap-to-navigate to podcast details and follow/unfollow actions, while episode list items use shared element transitions for smoother navigation to the player.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/home/category · high confidence

The Jetcaster core domain module now provides the business logic and data models for the app. It introduces use cases for filtering podcasts by category and retrieving the latest episodes from followed podcasts, along with the immutable data models (CategoryInfo, EpisodeInfo, PodcastInfo) and mapping functions required to support these operations. Additionally, it defines the EpisodePlayer interface and a MockEpisodePlayer implementation, establishing the contract for playback controls such as queuing, seeking, and speed adjustment.

Jetcaster/core/domain/src/main · high confidence

The Jetchat app now includes a new \backdropBlur\ Modifier in the \blur\ package, enabling hardware-accelerated frosted-glass effects on translucent UI elements like navigation bars and cards. This feature leverages Android's \RenderNode.setBackdropRenderEffect\ API (available on Android 17/API 37+) to blur the content behind a composable, supporting configurable blur radii, shapes, tint colors, and elevation shadows. For older Android versions, it gracefully falls back to a solid color, ensuring consistent visual structure across devices.

Jetchat/app/src/main/java/com/example/compose/jetchat/blur · high confidence

The app now includes a dedicated podcast details screen that displays podcast information and a list of episodes in an adaptive grid layout. Users can subscribe to podcasts, queue episodes for playback, and remove episodes from their queue, with visual feedback provided via snackbars. The screen is backed by a new ViewModel that combines podcast and episode data, handling state transitions between loading and ready states.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/podcast · high confidence

The mobile module now includes new shared UI components: \EpisodeListItem\ and \Loading\. The \EpisodeListItem\ composable displays podcast episode details, supporting swipe-to-dismiss actions to remove episodes from the queue, and renders episode metadata such as date and duration. The \Loading\ composable provides a standard circular progress indicator for asynchronous states.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/shared · high confidence

The Jetcaster mobile module now includes a suite of new utility components to enhance the user interface and device adaptability. Users will see a new animated follow/unfollow button in podcast lists, featuring a smooth rotation effect when toggling subscriptions. The app also introduces custom gradient scrim modifiers for improved visual layering in lists, alongside helper functions for handling pluralized string resources and full-width items in grid layouts. Additionally, new utilities detect foldable device postures (such as book or tabletop modes) and window size classes, enabling the interface to adapt more effectively to different screen configurations.

Jetcaster/mobile/src/main/java/com/example/jetcaster/util · high confidence

The app introduces several new utility components in the utils package to improve developer experience and code clarity. A new ErrorMessage data class provides a structured way to handle error messages with string resources. LazyListUtils adds an isScrolled extension property to LazyListState, using derivedStateOf to efficiently track scroll position without unnecessary recompositions. MapExtensions introduces an addOrRemove function for Sets, allowing atomic toggling of elements. Additionally, MultipreviewAnnotations defines FontScalePreviews, DevicePreviews, and CompletePreviews annotations, enabling developers to easily preview composables across different font sizes, device configurations, and themes in the Android Studio preview tool.

JetNews/app/src/main/java/com/example/jetnews/utils · high confidence

The Sleep screen now includes a new header with a navigation drawer toggle, a scrollable tab row for selecting time ranges (Day, Week, Month, Six Months, One Year), and a custom time graph visualization. The graph displays sleep data as animated bars with rounded corners and gradients, allowing users to tap to expand details. Day labels are localized using the current platform locale, and the layout uses a custom Compose Layout for precise positioning of time bars relative to hour headers.

JetLagged/app/src/main/java/com/example/jetlagged/sleep · high confidence

The Reply app now uses a type-safe navigation system with sealed interface routes (Inbox, Articles, Direct Messages, Groups) and a new \ReplyNavigationWrapper\ that adapts the UI layout based on window size. It switches between a bottom navigation bar for compact screens, a navigation rail for medium widths, and a permanent navigation drawer for expanded widths, while also supporting a modal drawer for back-press handling. This change replaces the previous static navigation structure with a dynamic, adaptive approach using Material 3's NavigationSuiteScaffold.

Reply/app/src/main/java/com/example/reply/ui/navigation · high confidence

The Reply app now adapts its layout to device size and posture, switching between a single-pane list view and a dual-pane list-detail view on larger screens. It utilizes the Material 3 Window Size Class API to determine layout and integrates with the Window Manager to detect folding features, ensuring content avoids the hinge in book posture. The UI state is hoisted to the ViewModel to manage email selection and detail visibility, and the navigation host is configured to handle transitions between these adaptive states.

Reply/app/src/main/java/com/example/reply/ui · high confidence

A new Spotless copyright template file has been added to enforce the Apache 2.0 license header across Kotlin source files, ensuring consistent legal attribution and licensing compliance in the project.

Reply/spotless · high confidence

The Jetsnack sample app now includes dedicated ProGuard configuration files (\proguard-rules.pro\ and \proguard-benchmark-rules.pro\) to support code shrinking and optimization. The main rules file suppresses warnings for specific SSL/TLS libraries (Bouncy Castle, Conscrypt, OpenJSSE) and preserves Compose UI platform classes, while the benchmark-specific file disables obfuscation to ensure accurate baseline profile generation. These changes enable R8 optimization for the sample app while maintaining necessary runtime behavior for debugging and benchmarking.

JetLagged/app, Jetsnack/app · high confidence

The JetNews sample app now includes a proguard-rules.pro file to configure code shrinking and obfuscation. This configuration preserves line number information for debugging stack traces, repackages classes into the top-level, and suppresses warnings for specific Bouncy Castle and Conscrypt SSL libraries. It also explicitly keeps the AndroidCompositionLocals class required by Jetpack Compose to ensure correct runtime behavior.

JetNews/app · high confidence

The mobile module now includes a dedicated proguard-rules.pro file to configure code shrinking and obfuscation for release builds. This configuration preserves line number information for debugging, repackages classes, and includes specific keep rules for ROME feed libraries and Android Compose UI components, while suppressing warnings for missing classes from OkHttp, JDOM, and Bouncy Castle to ensure stable release builds.

Jetcaster/mobile · high confidence

The app module now includes a proguard-rules.pro file that suppresses warnings for Bouncy Castle JSSE, Conscrypt, and OpenJSSE libraries. This prevents build noise and potential confusion during the release build process when these security providers are used but their internal classes are not directly referenced in a way that R8 can resolve.

Reply/app · high confidence

The Discover screen's category selection UI has been updated to use Material 3 FilterChips instead of the previous implementation. This change improves readability and visual consistency by displaying category tabs as selectable chips with a checkmark icon for the active selection, rounded corners, and distinct color states for selected and unselected items.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/home/discover · high confidence

The Jetchat app now uses R8 for release builds, improving app size and security through code shrinking and obfuscation. This change introduces a new .gitignore to exclude build artifacts and a proguard-rules.pro file that preserves specific Android Compose internals and suppresses warnings for Bouncy Castle and Conscrypt SSL libraries, ensuring stable release builds without breaking functionality.

Jetchat/app · high confidence

The Home screen UI and its underlying ViewModel have been restructured to improve code organization and responsiveness. The previous \HomeState\ has been removed in favor of a single, immutable \HomeScreenUiState\ data class, and the ViewModel now uses \shareIn\ for subscribed podcasts to optimize data flow. The layout logic has been decoupled from the deprecated \WindowSizeClass.compute()\ method, replacing it with a custom \calculateScaffoldDirective\ function that explicitly handles pane partitioning based on window size and hinge policies. Additionally, the UI now displays the latest episodes for all subscribed podcasts in the library section, and the home category selection logic has been refined to default to 'Discover' when no featured podcasts are available.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/home · high confidence

The Home screen in JetNews has been refactored to use a dedicated \HomeViewModel\ that manages the UI state via Kotlin Flows. This change introduces a \HomeUiState\ sealed interface to distinguish between loading, error, and data states, allowing the UI to reactively display a pull-to-refresh mechanism, error snackbar notifications, and the post feed. The \HomeScreen\ composable now consumes this state, enabling better separation of concerns and more robust handling of asynchronous data loading from the \PostsRepository\.

JetNews/app/src/main/java/com/example/jetnews/ui/home · high confidence

The Jetsnack sample now implements a custom set of UI components built on top of Material 3, replacing previous styling approaches. This includes a new \JetsnackButton\ with gradient backgrounds, a \JetsnackCard\ and \JetsnackSurface\ that handle elevation and content colors via the Jetsnack theme, and a \JetsnackDivider\. The update also adds a \JetsnackScaffold\ and \JetsnackSnackbar\ to manage layout and snackbars using Material 3 primitives, alongside utility components like \FilterChip\, \QuantitySelector\, and \GradientTintedIconButton\ that utilize the new theme colors and shared transition APIs.

Jetsnack/app/src/main/java/com/example/jetsnack/ui/components · high confidence

The app now supports a dark theme alongside the existing light mode, with distinct color schemes for each. This change introduces a new \JetLaggedExtraColors\ system that provides specific colors for sleep stages (Awake, REM, Light, Deep) and UI elements like heart rate graphs and cards, ensuring visual consistency across both themes. The theme also integrates the Lato font via Google Fonts for titles and headings.

JetLagged/app/src/main/java/com/example/jetlagged/ui/theme · high confidence

The app now includes a foundational data layer structure, introducing a generic \Result\ sealed class to standardize how data operations and errors are handled across the application. Additionally, an \AppContainer\ interface and its \AppContainerImpl\ implementation have been added to manage dependency injection, specifically providing lazy-initialized access to \PostsRepository\ and \InterestsRepository\ (currently backed by fake implementations). This change establishes the architectural basis for separating data logic from UI components.

JetNews/app/src/main/java/com/example/jetnews/data · high confidence

The JetChat sample application's UI components have been updated to use Material 3. This includes a new \JetchatAppBar\ built with \CenterAlignedTopAppBar\, a \JetchatDrawer\ utilizing \ModalNavigationDrawer\ and \ModalDrawerSheet\, and a new \AnimatingFabContent\ component that provides an animated expand/collapse effect for the floating action button. Supporting utilities like \BaselineHeightModifier\ and \JetchatIcon\ have also been added to support the new design system.

Jetchat/app/src/main/java/com/example/compose/jetchat/components · high confidence

The JetNews sample app's UI layer has been updated to use Material 3 components (e.g., \ModalDrawerSheet\, \NavigationDrawerItem\) and the new Navigation 3 runtime (\NavKey\, \NavDisplay\). This change introduces adaptive layout support: the app now detects expanded screens to display a navigation rail instead of a drawer, and implements predictive back gestures with shared transitions for screen navigation. The main activity also enables edge-to-edge display and handles deep links to restore the correct navigation state.

JetNews/app/src/main/java/com/example/jetnews/ui · high confidence

The app's navigation layer has been rewritten to use the new \androidx.navigation3\ runtime, replacing the previous implementation. This change introduces a key-based navigation model where routes are identified by \NavKey\ objects rather than string paths, as seen in the new \DeepLinkKey\ interface and \NavigationItem\ data class. The \Navigator\ and \NavigationState\ classes now manage multiple independent back stacks for top-level destinations, and the \ListDetailScene\ implements a new \SceneStrategy\ to handle list-detail layouts on expanded screens using the \Scene\ and \NavEntry\ abstractions.

JetNews/app/src/main/java/com/example/jetnews/ui/navigation · high confidence

The JetNews app's UI theme has been updated to use Material 3 components, replacing the previous Material 2 implementation. This change introduces a new color system defined in Color.kt with distinct light and dark palettes, updates typography in Type.kt to include letter spacing and line-break settings, and applies new corner radii in Shape.kt. Additionally, the theme now supports dynamic colors on Android 12+ (API 31+) by utilizing the system's accent colors, while falling back to the static light/dark palettes on older versions.

JetNews/app/src/main/java/com/example/jetnews/ui/theme · high confidence

The Jetcaster mobile application's UI theme has been updated to use the Material 3 Expressive API, introducing support for dynamic color schemes and multiple contrast levels (light, dark, medium, and high). This change ensures better accessibility compliance by adhering to WCAG AA guidelines for contrast ratios and allows the app's appearance to adapt to system-level dark mode and dynamic color settings on supported Android devices.

Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/theme · high confidence

The Jetchat app's visual presentation has been updated to follow Material 3 design guidelines. This change introduces a new color system defined in the theme package, replacing previous color definitions with a structured palette of primary, secondary, tertiary, and neutral tones. The application now supports dynamic color theming on devices running Android 12 (API level 31) and higher, automatically adapting the app's color scheme to the user's system wallpaper. For older devices or when dynamic color is disabled, the app falls back to predefined light and dark color schemes. Additionally, the typography has been updated to use the Montserrat and Karla font families, leveraging downloadable fonts from Google Fonts to ensure consistent text rendering across different devices.

Jetchat/app/src/main/java/com/example/compose/jetchat/theme · high confidence

The Jetchat sample app has been updated to use Material 3 components, specifically replacing the previous scaffold with a Compose-based navigation drawer (JetchatDrawer) and enabling edge-to-edge display. The main activity (NavActivity) now manages drawer state via a new MainViewModel using Kotlin StateFlow, ensuring the drawer opens correctly when triggered and resets its state after opening. Additionally, a new UI helper (UiExtras) provides a standard Material 3 alert dialog for unavailable functionality.

Jetchat/app/src/main/java/com/example/compose/jetchat · high confidence

The Jetsnack sample app's UI layer has been restructured to support shared element transitions between the home feed and snack detail screens, using \SharedTransitionLayout\ and custom \CompositionLocal\ providers to manage animation scopes. The main navigation container now utilizes a \JetsnackScaffold\ with a bottom bar that participates in these shared transitions, and the app enables edge-to-edge display via \enableEdgeToEdge()\ in \MainActivity\. Additionally, a new \RecentOrdersWidget\ is introduced, with \MainActivity\ handling widget preview generation on newer Android versions.

Jetsnack/app/src/main/java/com/example/jetsnack/ui · high confidence

The Jetsnack sample app has been updated to use Material 3 as its underlying theming system. This change introduces a new semantic color palette with distinct light and dark modes, defines specific shapes for UI components, and applies custom typography using the Montserrat and Karla font families. The theme implementation now leverages Material 3's \ColorScheme\, \Typography\, and \Shapes\ APIs to provide a consistent and modern visual experience.

Jetsnack/app/src/main/java/com/example/jetsnack/ui/theme · high confidence

The deep-linking logic in the app has been rewritten to support the Navigation 3 runtime. This change introduces a new set of utility classes (DeepLinkMatcher, DeepLinkPattern, KeyDecoder) that parse incoming URIs, match them against defined patterns for the Home, Post, and Interests screens, and decode path/query arguments into serializable navigation keys. Users will experience deep links resolving correctly within the new navigation architecture, ensuring that opening a link to a specific article or interest category navigates to the correct destination and restores the proper back-stack state.

JetNews/app/src/main/java/com/example/jetnews/deeplink · high confidence

The home screen now features a new DestinationBar component that displays the delivery address and includes an expandable icon, integrated with shared element transitions for smoother navigation. The Feed screen has been updated to wrap the snack list and filter UI in a SharedTransitionLayout, enabling a polished animated overlay when the FilterScreen is opened. Additionally, the FilterScreen itself now supports shared bounds animations, allowing it to expand and contract smoothly from its trigger point, while the bottom navigation layout has been refined to use expressive spring animations for tab selection.

Jetsnack/app/src/main/java/com/example/jetsnack/ui/home · high confidence

The JetLagged app now displays sleep data using a new card-based layout on the home screen, featuring specific components for average time in bed, average time asleep, wellness, and heart rate. The navigation drawer has been rebuilt to support predictive back gestures and includes smooth, decay-based animations for opening and closing. Additionally, the app now supports edge-to-edge display and adapts its layout for different window sizes.

JetLagged/app/src/main/java/com/example/jetlagged · high confidence

The Jetcaster core module structure has been reorganized to separate concerns, introducing distinct modules for domain logic (renamed from model), data access, and the design system. Additionally, new testing-specific modules have been created to isolate test utilities, including a \data-testing\ module and a \domain-testing\ module, with \PreviewData\ moved into the testing infrastructure to support development workflows.

Jetcaster/core · high confidence

The Reply sample app has been updated to use the Material 3 design system. This change introduces a new theme structure in the \ui/theme\ package, including \Color.kt\ with light, dark, and contrast-aware color palettes; \Shapes.kt\ defining rounded corner radii; \Type.kt\ for Material 3 typography; and \Theme.kt\ which orchestrates these resources and supports dynamic color theming on supported Android versions.

Reply/app/src/main/java/com/example/reply/ui/theme · high confidence

The TV application module has been renamed from "tv-app" to "tv". To support the release build, a .gitignore file was added to exclude build artifacts, and a proguard-rules.pro file was introduced to configure code shrinking and obfuscation, including specific rules for debugging, class repackaging, and handling dependencies like ROME, OkHttp, JDOM, and Bouncy Castle.

Jetcaster/tv · high confidence

Added Android UI test for app launch; Added Android UI tests for Jetchat conversation, navigation, and input flows; Added UI and unit tests for JetNews app; Added instrumentation tests for app navigation and launch; Added navigation test for Wear app; Added test-only data repository implementations; Added unit tests for domain use cases and mock player; New domain-testing module with shared preview data.

This change introduces the build infrastructure for the JetLagged, JetNews, and Jetcaster sample applications. It adds the necessary Gradle build scripts (including \build.gradle.kts\, \settings.gradle.kts\, and \gradle.properties\) and centralizes dependency management via \libs.versions.toml\ files. The configuration updates the Android Gradle Plugin to version 9.3.1, sets the minimum SDK to 24, and configures the Compose BOM for version 2026.09.00. Additionally, it integrates Spotless for code formatting and the \version-catalog-update\ plugin to manage dependency versions across the samples.

(dependencies) · high confidence

The JetNews sample app now includes a Gradle wrapper configuration that specifies Gradle 9.5.0 (bin distribution) as the build tool version. This ensures that the project uses a consistent, specific version of the Gradle build system for all users and CI environments, replacing any previous or default wrapper settings.

JetNews/gradle · high confidence

The Jetcaster project now uses Gradle 9.5.0 for building, as defined in the newly added gradle-wrapper.properties file. This ensures that builds are executed with the specified Gradle distribution, which may affect build performance and compatibility with existing build scripts.

Jetcaster/gradle · high confidence

The Gradle wrapper configuration in the Reply project has been updated to use Gradle 9.5.0. This change ensures that the build environment uses a specific, consistent version of the Gradle build tool, which may bring performance improvements, new features, or compatibility updates associated with this major version release.

JetLagged/gradle, Jetchat/gradle, Reply/gradle · high confidence

The Jetsnack project now uses Gradle 9.5.0 for builds, updating the wrapper distribution URL to the latest binary release. Additionally, a Spotless copyright header file has been added to enforce standard Apache 2.0 license headers across Kotlin source files, ensuring consistent licensing compliance in the codebase.

Jetsnack/gradle · high confidence

The project now includes a Spotless configuration file defining the standard Apache 2.0 copyright header. This ensures that all source files automatically adhere to the required license and copyright notices upon formatting.

JetNews/spotless · high confidence

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

• CAI 46 → 43 (-2.9)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 98 → 99 (+1.0)
• Architecture 94 → 93 (-1.6)
• Maturity 76 → 64 (-12.0)
• Readiness 35 → 34 (-0.9)
• Security 33 → 33 (-0.8)
• Domain Modelling 70 → 60 (-9.9)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (12 lines × 2) (Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/player/PlayerScreen.kt)
• Duplicated block (15 lines × 2) (Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/player/PlayerScreen.kt)
• Duplicated block (20 lines × 2) (Jetchat/app/src/main/java/com/example/compose/jetchat/components/JetchatDrawer.kt)
• Duplicated block (24 lines × 2) (JetNews/app/src/main/java/com/example/jetnews/ui/home/HomeScreens.kt)
• Duplicated block (26 lines × 2) (Reply/app/src/main/java/com/example/reply/ui/MainActivity.kt)
• Duplicated block (26 lines × 2) (Reply/app/src/main/java/com/example/reply/ui/navigation/ReplyNavigationComponents.kt)
• Duplicated block (9 lines × 3) (Reply/app/src/main/java/com/example/reply/ui/navigation/ReplyNavigationComponents.kt)
• 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)
• 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)
• High: security finding (details withheld)
• …and 44 more

• 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 project overview (README.md)
• Duplicated block (12 lines × 2) (JetNews/app/src/main/java/com/example/jetnews/ui/home/HomeScreens.kt)
• Duplicated block (12 lines × 2) (Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/player/PlayerScreen.kt)
• Duplicated block (12 lines × 2) (Jetcaster/wear/src/main/java/com/example/jetcaster/ui/latest_episodes/LatestEpisodesScreen.kt)
• Duplicated block (12 lines × 2) (Jetchat/app/src/main/java/com/example/compose/jetchat/components/JetchatDrawer.kt)
• Duplicated block (13 lines × 2) (Jetsnack/app/src/main/java/com/example/jetsnack/ui/home/Profile.kt)
• Duplicated block (14–15 lines × 2) (Jetcaster/wear/src/main/java/com/example/jetcaster/ui/latest_episodes/LatestEpisodesScreen.kt)
• Duplicated block (15 lines × 2) (Jetcaster/mobile/src/main/java/com/example/jetcaster/ui/player/PlayerScreen.kt)
• Duplicated block (16 lines × 2) (Jetcaster/wear/src/main/java/com/example/jetcaster/ui/podcast/PodcastDetailsScreen.kt)
• Duplicated block (19 lines × 3) (Jetcaster/wear/src/main/java/com/example/jetcaster/ui/podcast/PodcastDetailsScreen.kt)
• Duplicated block (26 lines × 2) (Jetchat/app/src/main/java/com/example/compose/jetchat/blur/BackdropBlurModifier.kt)
• Duplicated block (5 lines × 2) (Jetcaster/mobile/src/main/java/com/example/jetcaster/util/WindowInfoUtil.kt)
• Duplicated block (56 lines × 2) (Reply/app/src/main/java/com/example/reply/ui/navigation/ReplyNavigationComponents.kt)
• Duplicated block (7 lines × 2) (JetLagged/app/src/main/java/com/example/jetlagged/backgrounds/SolarFlareShaderBackground.kt)
• Duplicated block (8–9 lines × 3) (Reply/app/src/main/java/com/example/reply/ui/navigation/ReplyNavigationComponents.kt)
• Further orphaned files (smaller)
• Further sole-owners (lower concentration)
• …and 54 more

• 45 commits — 40 feature/other, 5 fixes

• Jetchat/app — 28 commits
• (repo) — 9 commits
• JetLagged/gradle — 5 commits
• .github/workflows — 3 commits

• fix: Fix YAML files and pinned versions
• fix: Fix YAML files and pinned versions (#1714)
• fix: Fix edge padding for the top of the component.
• fix: Fix edge padding for the top of the component.
• fix: build: revert AGP to 9.3.1 and restore version catalog plugin references
• change: Add RenderEffect chaining.
• change: Add RenderEffect chaining.
• change: Add example BackdropBlur Modifier using platform RenderNode.setBackdropRenderEffect (#1710)
• change: Add video message support to Jetchat
• change: BackdropBlurModifier, using RenderNode to backdrop blur contents.
• change: BackdropBlurModifier, using RenderNode to backdrop blur contents.
• change: Cleanup
• change: Code cleanup
• change: Code cleanup and fixing blur regions
• change: Code cleanup and fixing blur regions
• change: Code cleanup and fixing blur regions
• change: Dont show blank message.
• change: Dont use UUID
• change: Increase timeout and enable kvm permissions
• change: Make the middle control smaller.
• …and 25 more

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

android/compose-samples 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.