skydoves/chatgpt-android

This is an Android application that integrates the OpenAI ChatGPT API with the Stream Chat SDK to facilitate AI-powered messaging. It provides a multi-module architecture supporting user authentication, channel management, and asynchronous message processing via background workers. The system handles chat completions, real-time communication, and persistent user preferences within a Jetpack Compose-based interface.

The application now includes an AppInitializer class that registers the StreamChatInitializer as a dependency during the AndroidX Startup process. This ensures that the Stream Chat library is properly initialized before the rest of the application starts, providing a standardized way to handle library initialization order.

app/src/main/kotlin/com/skydoves/chatgpt/initializer · high confidence

Users can now view their chat channels and create new ChatGPT-specific channels via a floating action button. The screen includes a persistent tooltip guiding users to create a channel, which is dismissed and remembered after the first interaction. It also automatically joins a common channel upon user login and displays success or error toasts for channel creation actions.

feature-chat/src/main/kotlin/com/skydoves/chatgpt/feature/chat/channels · high confidence

The core-model module now includes Kotlin data classes (GPTChatRequest, GPTChatResponse, GPTChoice, GPTMessage, GPTUsage) that map to the OpenAI Chat Completions API, enabling the app to serialize requests and deserialize responses for AI chat interactions.

core-model · high confidence

The chat feature now includes Dagger Hilt modules and entry points to manage dependencies for the Stream Chat client and background message workers. This enables the application to inject the ChatClient and WorkManager instances into components like StreamChatInitializer and ChatGPTMessageWorker, ensuring proper lifecycle management and access to these services within the chat module.

feature-chat/src/main/kotlin/com/skydoves/chatgpt/feature/chat/di · high confidence

A new benchmark module has been introduced to generate baseline profiles and run macrobenchmarks for the app. This includes a BaselineProfileGenerator that captures the critical startup journey, along with specific scenario implementations for exploring Channels and Messages screens, supported by utility functions for UI automation and device interaction.

benchmark · high confidence

A new background worker (ChatGPTMessageWorker) has been introduced to handle sending messages to the ChatGPT API asynchronously. This component retrieves message text and channel details from work parameters, constructs a request using the GPT-3.5-turbo model, and sends the AI's response back to the Stream Chat channel. This ensures that message processing does not block the main UI thread, improving app responsiveness during AI interactions.

feature-chat/src/main/kotlin/com/skydoves/chatgpt/feature/chat/worker · high confidence

The application now includes its core entry points: the ChatGPTApp class initializes the Hilt dependency injection container, and the MainActivity sets up the Compose UI theme and navigation. A key behavioral addition is the provision of a LocalOnFinishDispatcher, which allows child composables to trigger the activity's back-press finish action, enabling consistent navigation behavior throughout the app.

app/src/main/kotlin/com/skydoves/chatgpt · high confidence

This change introduces the initial set of Gradle convention plugins in the build-logic module to standardize Android project configuration. It adds plugins for Android application and library modules (configuring Kotlin and Compose), a feature module plugin that enforces dependencies on core modules (designsystem, navigation, data) and libraries (coroutines, Stream log), and a Hilt plugin that migrates dependency injection to use KSP (Kotlin Symbol Processing) instead of annotation processing. Additionally, a Spotless plugin is added to enforce code formatting and license headers, and the Gradle wrapper is set to version 7.4.2.

build-logic/convention/src/main/kotlin · high confidence

This change introduces the core-data module, establishing the data access layer for the application. It defines repository interfaces and implementations for managing GPT chat messages (via a dedicated network service) and Stream Chat channels (handling channel creation, joining a common channel, and user state). The module also includes a custom coroutine sharing strategy, dependency injection bindings, and static chat models.

core-data · high confidence

The core-network module has been added to provide the foundational networking infrastructure for communicating with the OpenAI API. This includes a Retrofit setup targeting the OpenAI base URL, a GPTInterceptor that injects the API key into requests, and a ChatGPTService interface defining the endpoint for sending chat completions. The module also configures dependency injection for network clients and coroutine dispatchers, and handles unauthorized session errors by providing a user-facing error message.

core-network · high confidence

The repository has been initialized with the core project structure, including Gradle wrapper scripts, an EditorConfig, and a .gitignore that excludes secrets.properties and build artifacts. It also introduces standard open-source governance files: a Code of Conduct, a Contributing guide, and a README.md that details the app's architecture, tech stack (Jetpack Compose, Hilt, Stream Chat, OpenAI API), and step-by-step build instructions.

(repo-wide) · high confidence

This change introduces the core application entry point, ChatGPTMain, which sets up the Compose theme and navigation host, and adds a custom reaction factory for the chat feature that enables users to apply specific emoji reactions (good, love, smile, joy, wink) to messages. It also establishes standard Apache 2.0 copyright headers across Kotlin, Kotlin Script, and XML files to ensure consistent licensing in the codebase.

app/src/main/kotlin/com/skydoves/chatgpt/ui, feature-chat/src/main/kotlin/com/skydoves/chatgpt/feature/chat/reactions, spotless · high confidence

This change introduces the core design system module, providing the foundational visual identity and reusable UI components for the application. It establishes a Compose-based theme with specific color palettes (including STREAM\_PRIMARY and specific dark/light backgrounds), typography scales, and a background handling component. Additionally, it adds shared UI elements such as a loading indicator and a small top bar, along with a composition local for managing finish callbacks, ensuring a consistent look and feel across the app.

core-designsystem · high confidence

The app now uses a centralized navigation graph that starts at the Login screen and supports navigation to the Channels list and individual Message threads. The Login screen is the entry point, while the Channels screen displays a top bar with the app name, and the Messages screen accepts a channel ID argument to display the correct conversation history.

app/src/main/kotlin/com/skydoves/chatgpt/navigation · high confidence

The login feature now displays a dedicated screen that waits for the Stream Chat SDK to finish initializing before navigating to the channels list. Users will see a loading indicator during this process, and if the SDK fails to initialize, an error message is shown instead of proceeding.

feature-login/src/main/kotlin/com/skydoves/chatgpt/feature/login · high confidence

This change adds the foundational navigation layer for the ChatGPT application, defining the app's screen routes (Login, Channels, and Messages) and providing a Jetpack Compose-compatible navigator. It includes the \ChatGPTComposeNavigator\ implementation, navigation command types, and a Hilt dependency-injection module to wire the navigator into the app's singleton component, enabling ViewModels to trigger screen transitions and pass results back through the navigation stack.

core-navigation · high confidence

A new core-preferences module has been added to the application, providing a centralized and dependency-injection-friendly way to store and retrieve user preferences. This module introduces a \Preferences\ class backed by Android's \SharedPreferences\, exposing specific keys for a unique user identifier (\userUUID\) and a flag to track whether the balloon channel display has been shown (\balloonChannelDisplayed\). The implementation includes Kotlin property delegates for type-safe access to boolean and string preferences, and a Dagger Hilt module (\PreferencesModule\) that provides the singleton \Preferences\ instance scoped to the application context, ensuring consistent state across the app.

core-preferences · high confidence

The app module now includes explicit ProGuard and R8 configuration files (proguard-rules.pro and benchmark-rules.pro) to control code shrinking, obfuscation, and optimization. These rules preserve critical components such as ComposeView, Parcelable implementations, and native methods, while suppressing warnings for AndroidX, Dagger, Retrofit, and cryptographic libraries to ensure stable builds and correct runtime behavior.

app · high confidence

The chat feature now offloads ChatGPT API calls to a background worker (ChatGPTMessageWorker) using AndroidX WorkManager. When a user sends a message, the UI immediately displays it, while the background worker handles the API interaction and updates the chat with the AI's response upon success or failure, improving UI responsiveness and handling network constraints.

feature-chat/src/main/kotlin/com/skydoves/chatgpt/feature/chat/messages · high confidence

A new Kotlin object, Configurations, has been introduced in the buildSrc module to centralize Android build settings. This change defines the compile SDK, target SDK, and minimum SDK levels, as well as the application's version name (1.1.1) and version code (13), making these values easier to manage and update across the project.

buildSrc · high confidence

The chat feature now uses AndroidX Startup to initialize the Stream Chat SDK. A new StreamChatInitializer sets up the ChatClient with offline and state plugins, connects the user using a development token, and assigns a random name and image. A companion StreamLogInitializer installs the Stream logger in debug builds. This replaces previous manual initialization, ensuring the chat client is ready before other components depend on it.

feature-chat/src/main/kotlin/com/skydoves/chatgpt/feature/chat/initializer · high confidence

This change introduces new Gradle convention plugins in the build-logic module to standardize Android and Jetpack Compose setup across the project. The \configureKotlinAndroid\ function now enforces a minimum SDK of 21, compile SDK 34, and Java/Kotlin 17 compatibility, while enabling specific experimental APIs for coroutines, Material3, and lifecycle composition. The \configureAndroidCompose\ function applies the Kotlin Compose compiler plugin, enables strong skipping mode for performance optimization, and configures compiler reports output.

build-logic/convention/src/main/kotlin/com · high confidence

The project's Gradle wrapper has been updated to use Gradle 8.7 (specifically the 'all' distribution). This ensures that builds are executed with the specified Gradle version, providing access to the features, performance improvements, and bug fixes included in this release.

gradle · high confidence

The project is initialized as a multi-module Android application (chatgpt-android) featuring a modular structure with core modules (model, network, data, preferences, designsystem, navigation) and feature modules (chat, login), alongside a dedicated benchmark module. The build system utilizes a version catalog (libs.versions.toml) to manage dependencies, establishing baseline versions for key libraries including Kotlin 2.0.0, Android Gradle Plugin 8.6.0, Jetpack Compose 1.7.8, Stream Chat SDK 6.5.1, and Firebase BOM 33.10.0. The configuration includes convention plugins for standardized build logic, KSP for code generation, Hilt for dependency injection, and Spotless for code formatting.

(dependencies) · high confidence

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

• CAI 54 → 55 (+0.6)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 100 → 100 (+0.0)
• Architecture 100 → 93 (-6.6)
• Maturity 52 → 52 (+0.0)
• Readiness 41 → 41 (+0.0)
• Security 64 → 64 (+0.0)
• Performance 100 (new)

• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)

• No ADRs found
• Off the main sequence: chatgpt-android:core-designsystem
• Off the main sequence: chatgpt-android:core-model
• Off the main sequence: chatgpt-android:core-preferences
• Off the main sequence: chatgpt-android:feature-chat
• Off the main sequence: chatgpt-android:feature-login

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

skydoves/chatgpt-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.