capcom6/android-sms-gateway

This system is an Android-based SMS gateway application that transforms a device into a hub for sending and receiving SMS, data, and MMS messages. It provides a local REST API with JWT authentication for message submission and inbox management, while simultaneously synchronizing with a cloud server via Firebase Cloud Messaging and Server-Sent Events for real-time control and state updates. The application features robust background processing for message queuing, webhook delivery with retry logic, and end-to-end encryption, ensuring reliable operation even when the app is in the background.

22 changes.

The project underwent a major structural overhaul, introducing a modular architecture with Koin dependency injection and a centralized event bus to replace ad-hoc implementations. Key features added include cloud synchronization via a new Gateway module, push notifications through Firebase Cloud Messaging, and a robust message queue with scheduling and rate limiting. The user interface was completely redesigned with tabbed navigation, detailed message tracking, and JWT-secured local server endpoints.

22 changes.

This period focused on a comprehensive architectural restructuring of the SMS Gateway, introducing dedicated modules for webhooks, health monitoring, and background orchestration to improve reliability and maintainability. Significant security enhancements were implemented, including end-to-end message encryption and JWT-based authentication with granular access control for the local server API. The work also standardized data handling through ISO 8601 formatting and expanded webhook capabilities with persistent queuing, batch delivery, and payload signing.

13 changes.

This period focused on expanding the application's messaging capabilities to fully support MMS, including unified data models, attachment handling, and local persistence. It also introduced robust real-time features such as Server-Sent Events for notifications, network health monitoring, and background encrypted message uploads to the gateway.

The application now actively monitors internet connectivity and exposes connection details through the health check system. A new ConnectionService registers a network callback to detect connection loss and status changes, logging events and updating a live status flag. This service provides health check results for the current internet status, the active network transport types (WiFi, Ethernet, Cellular), and the specific cellular network generation (2G, 3G, 4G, or 5G) when available, allowing users to verify the device's network state.

app/src/main/java/me/capcom/smsgateway/modules/connection · high confidence

The local server module now includes a new IPReceivedEvent that broadcasts the device's local and public IP addresses. This allows other parts of the application to react to network address changes, supporting features such as displaying connection details or managing remote access configurations.

app/src/main/java/me/capcom/smsgateway/modules/localserver/events · high confidence

The app now includes a static Swagger UI bundle in the assets folder, allowing users to view and interact with the API documentation directly within the application.

app/src/main/assets · high confidence

The app now includes BootReceiver and EventsReceiver components to handle system-level and message-specific broadcasts. BootReceiver ensures the OrchestratorService starts automatically on device boot, reboot, or shutdown, supporting various Android OEM-specific boot intents. EventsReceiver asynchronously processes sent, delivered, and MMS-sent message status updates by delegating to the MessagesService, while logging any processing errors to the LogsService. These receivers are registered to listen for specific application-defined actions (ACTION\_SENT, ACTION\_DELIVERED, ACTION\_MMS\_SENT) and ensure reliable state tracking for outgoing messages.

app/src/main/java/me/capcom/smsgateway/receivers · high confidence

The app now queues incoming SMS, Data SMS, and MMS messages locally in a new \gateway\_\_inbox\_upload\ database table and uploads them to the gateway in the background via an \InboxUploadWorker\. Messages are encrypted before storage and transmission, with MMS attachments handled as encrypted JSON blobs. The worker processes pending items in batches of 100, requires a network connection, and uses a foreground notification to indicate processing. Failed uploads trigger a retry with exponential backoff, and individual message failures are logged.

app/src/main/java/me/capcom/smsgateway/modules/gateway/inbox · high confidence

The app now retrieves and displays both the device's local IP address and its public IP address. The local IP is determined by checking the Wi-Fi connection info first, then falling back to scanning network interfaces for a non-loopback IPv4 address, which improves reliability in scenarios like tethering. The public IP is fetched via the GatewayService, replacing the previous external dependency approach.

app/src/main/java/me/capcom/smsgateway/providers · high confidence

The local server's message submission API now supports sending data messages (with specific ports), MMS messages (including text and attachments), and scheduled messages. The \PostMessageRequest\ model has been updated to accept these new message types alongside the existing text message, enforcing mutual exclusivity between them. Additionally, users can now specify a \scheduleAt\ time for future delivery or use \ttl\/\validUntil\ fields to define message expiration, replacing the previous limitation to simple text-only, immediate sends.

app/src/main/java/me/capcom/smsgateway/modules/localserver/domain/messages · high confidence

The application introduces its foundational user interface resources, including a comprehensive set of vector drawables for navigation, settings, and status indicators (such as connection status, server types, and message states), along with XML layouts for key screens like the home dashboard, message lists, and settings dialogs.

app/src/main/res · high confidence

This change adds the Gateway module, which enables the app to synchronize with a cloud server. It introduces a new API client (GatewayApi) for device registration, message retrieval, and settings management, along with background workers to handle message pulling, state updates, and webhook synchronization. The module also includes an event-driven architecture (EventsReceiver) to coordinate these background tasks and manages cloud connection settings via GatewaySettings.

app/src/main/java/me/capcom/smsgateway/modules/gateway · high confidence

The app now uses a singleton EventBus to handle internal event processing, replacing ad-hoc mechanisms. This module defines event types such as MessageEnqueued, WebhooksUpdated, MessagesExportRequested, SettingsUpdated, and MessageCancelled, and provides a base EventsReceiver class for components to subscribe to and process these events asynchronously via Kotlin coroutines.

app/src/main/java/me/capcom/smsgateway/modules/events · high confidence

A new notifications module has been added to the application, introducing a centralized \NotificationsService\ that manages Android push notifications for various gateway operations. This service defines specific notification channels and distinct icons for events such as local service status, send workers, webhook workers, ping services, settings changes, SMS received webhooks, and realtime events. Users will now see tailored system notifications with appropriate icons and priorities for these background activities, improving visibility into the gateway's operational state.

app/src/main/java/me/capcom/smsgateway/modules/notifications · high confidence

Users can now encrypt SMS messages using a passphrase, with the system defaulting to a hardened encryption provider (AES-256-CBC with PBKDF2-SHA1 and 300,000 iterations) while maintaining backward compatibility with legacy formats. The encryption module includes settings storage for the passphrase, a service layer for encrypt/decrypt operations, and a factory to manage algorithm providers, ensuring that new messages are encrypted securely while existing encrypted data can still be decrypted.

app/src/main/java/me/capcom/smsgateway/modules/encryption · high confidence

The application now stores webhook configurations and the processing queue in a local Room database. This change adds entities and DAOs to manage webhook definitions (URL, event type, source) and a dedicated queue table that tracks delivery status (pending, processing, failed, completed, permanently\_failed), retry counts, and scheduling timestamps. A repository layer implements enqueueing, status updates, and cleanup logic, enabling reliable, persistent tracking of webhook delivery attempts and configuration state on the device.

app/src/main/java/me/capcom/smsgateway/modules/webhooks/db · high confidence

The local server module now includes a new \LocalServerService\ and \WebService\ that manage an embedded Ktor HTTP server. This update adds support for JWT-based authentication (with configurable secrets and TTLs) alongside basic auth, introduces new API endpoints for device information (\/device\), message inbox (\/inbox\), and webhooks (\/webhooks\), and exposes health check capabilities. The service also handles device ID generation and manages network locks to ensure stability.

app/src/main/java/me/capcom/smsgateway/modules/localserver · high confidence

The app now includes a dedicated webhooks module that listens for SMS lifecycle events (sent, delivered, failed, cancelled) and system pings, queuing them for HTTP delivery via background workers. Users can configure whether internet access is required for sending, set a custom retry count, and enable HMAC payload signing (with configurable secret, algorithm, and header names) to ensure webhook integrity. Failed or pending deliveries are tracked in a queue that users can inspect via a new diagnostic screen, providing visibility into delivery status and statistics.

app/src/main/java/me/capcom/smsgateway/modules/webhooks · high confidence

The gateway module now includes dedicated background workers to keep local data in sync with the server. Settings and webhooks are automatically fetched and updated every 24 hours via \SettingsUpdateWorker\ and \WebhooksUpdateWorker\, while \SendStateWorker\ ensures message delivery statuses are reported to the gateway. Additionally, \RegistrationWorker\ handles device registration and updates, and \PullMessagesWorker\ periodically retrieves new messages, all managed through Android WorkManager with network constraints and retry policies.

app/src/main/java/me/capcom/smsgateway/modules/gateway/workers · high confidence

A new Ping module has been added to the application, providing a service that can start and stop a foreground service based on user settings. The module includes a settings class that allows users to configure the ping interval (in seconds) and supports exporting and importing these settings via a key-value storage system. The service respects the enabled state, which is determined by whether a valid interval is set, ensuring that the foreground service only runs when explicitly configured by the user.

app/src/main/java/me/capcom/smsgateway/modules/ping · high confidence

A new Ping module has been added to the application, featuring a PingForegroundService that runs a background thread to periodically emit PingEvent instances containing health check data. To ensure reliable network connectivity and device wakefulness during these operations, the service acquires both a partial WakeLock and a high-performance WifiLock upon creation and releases them on destruction. The service operates in the foreground with a persistent notification and is designed to start and stop cleanly via companion object methods.

app/src/main/java/me/capcom/smsgateway/modules/ping/services · high confidence

The MMS module now supports sending and receiving multimedia messages with attachments. Incoming MMS attachments are persisted to local storage with metadata and are automatically cleaned up after 30 days. Outgoing MMS messages can include text and multiple attachments, which are encoded into MMS PDUs and sent via the Android MMS service.

app/src/main/java/me/capcom/smsgateway/modules/mms · high confidence

The application introduces a new data access layer for managing message lifecycle and authentication tokens. For messages, the system now supports FIFO and LIFO processing orders based on priority and creation time, allows cancellation of pending messages, and tracks message statistics and history with filtering capabilities. For authentication, a new token management system supports JWT access and refresh tokens, including token rotation, revocation of active tokens and their children, and automatic cleanup of expired tokens.

app/src/main/java/me/capcom/smsgateway/data/dao · high confidence

The app now includes dedicated RecyclerView adapters to power new list screens for incoming messages, outgoing messages, message recipients, log entries, webhooks, and the webhook queue. These adapters handle the display of message details (sender, type, preview), log entries (date, message, module, priority icon), webhook configurations (ID, URL, event, source), and webhook queue status (URL, retry count, creation date), enabling users to view and interact with these data sets within the application.

app/src/main/java/me/capcom/smsgateway/ui/adapters · high confidence

This change introduces the domain data classes that power several new local server capabilities: device information retrieval (including SIM card details via Device and SimCard), message sorting options (MessageSort), log viewing (GetLogsResponse), and authentication with JWT refresh tokens (TokenRequest, TokenResponse). It also adds InboxRefreshRequest to support batched webhook deliveries and MMS filtering. These models define the structure of requests and responses for the corresponding endpoints.

app/src/main/java/me/capcom/smsgateway/modules/localserver/domain · high confidence

A new health module has been introduced to provide visibility into the application's operational status. This module aggregates checks from existing services, specifically monitoring the connection and message subsystems, while adding new capabilities to track device battery level and charging state (USB or AC). The system reports an overall PASS, WARN, or FAIL status based on these combined checks, allowing users to identify potential issues such as low battery or connectivity problems.

app/src/main/java/me/capcom/smsgateway/modules/health · high confidence

This change introduces a new module for tracking incoming SMS, Data SMS, and MMS messages. It adds support for persisting MMS attachments and provides a configurable log retention policy (via \lifetimeDays\) that automatically truncates old messages and their associated attachments using a background worker. The module exposes a repository and ViewModel to query messages by type and date range, enabling UI components to filter and display incoming message history.

app/src/main/java/me/capcom/smsgateway/modules/incoming · high confidence

The app now includes a dedicated logs module that persists log entries to a local database and exposes them via a ViewModel for UI consumption. Users benefit from automatic log retention management: a default 30-day lifetime is applied to stored logs, enforced by a background WorkManager job that periodically truncates entries older than the configured period. The module supports importing and exporting the retention setting, allowing users to adjust how long logs are kept.

app/src/main/java/me/capcom/smsgateway/modules/logs · high confidence

The app introduces dedicated ViewModels for the messages module: \MessagesListViewModel\ manages the main message list with support for filtering by processing state and dynamic pagination (loading more items), while \MessageDetailsViewModel\ handles the display of individual message details. These components replace previous ad-hoc logic, providing a structured way to fetch and display message data from the repository.

app/src/main/java/me/capcom/smsgateway/modules/messages/vm · high confidence

The app introduces a new Home screen flow and message management interface. A new FirstStartDialogFragment guides users through initial setup, supporting sign-up, sign-in with credentials, and sign-in by code. The HomeFragment now displays local and remote server details, including copyable links for credentials and device IDs. A new HolderFragment manages a tabbed view for messages, allowing users to switch between outgoing and incoming lists. Incoming messages can now be filtered by type (SMS, Data SMS, MMS), and outgoing messages can be filtered by processing state (Pending, Sent, Delivered, Failed, Cancelled). Tapping a message opens a MessageDetailsFragment showing content and recipients. A new LogsListFragment provides access to application logs, and the SettingsFragment now supports changing the app language and disabling battery optimizations.

app/src/main/java/me/capcom/smsgateway/ui · high confidence

The application now includes a dedicated messages module that manages SMS sending via a persistent queue. This introduces support for scheduling messages at specific times, setting expiration (TTL), and applying rate limits (such as a per-30-minutes cap). Users can configure SIM selection strategies (OS default, round-robin, or random), define work hours to restrict sending times, and choose between FIFO or LIFO processing orders. The system also supports message cancellation, delivery reports, and handles multiple message types including text, data, and MMS.

app/src/main/java/me/capcom/smsgateway/modules/messages · high confidence

The application now uses a structured settings module that centralizes configuration management. This change introduces interfaces for exporting and importing settings, a service to coordinate various setting categories (encryption, gateway, messages, webhooks, etc.), and a storage layer backed by Android SharedPreferences with serialization support. Users benefit from a more robust settings system that supports structured data import/export and consistent handling of different setting types across the app.

app/src/main/java/me/capcom/smsgateway/modules/settings · high confidence

The app now includes a dedicated receiver module that handles incoming SMS, data SMS, and MMS messages. It registers broadcast receivers for standard SMS and WAP-PUSH (MMS) intents, and adds content observers as fallbacks to catch messages when broadcasts are intercepted by the carrier or device. Incoming messages are processed by a central ReceiverService, which enqueues them to the gateway, stores them in the incoming messages database, and emits webhook events (including batch support for exports). MMS handling includes parsing the WAP-PUSH PDU for initial headers and using a content observer to read full message details and attachments from the MMS provider after download, with retry logic for incomplete data. The module also supports dynamic registration/unregistration of receivers and allows disabling the SMS content provider observer via settings.

app/src/main/java/me/capcom/smsgateway/modules/receiver · high confidence

The settings UI has been reorganized into dedicated fragments, introducing new configuration options for the local server (port, username, password, and JWT secret regeneration), webhooks (retry count and payload signing key), and message processing (work hours and send intervals). A new diagnostic screen allows users to inspect the webhook queue status and details, while the cloud server settings now support changing the password and requesting login codes for multi-device registration.

app/src/main/java/me/capcom/smsgateway/ui/settings · high confidence

The app now runs a foreground service (SSEForegroundService) that maintains a Server-Sent Events (SSE) connection to the server to receive real-time notifications. Upon connecting, the service immediately pulls any pending messages and routes incoming server events (such as message enqueuing) through the events router. To ensure reliable delivery, the service acquires a partial wake lock and a high-performance Wi-Fi lock while active, and displays a persistent notification to the user indicating that the app is listening for server events.

app/src/main/java/me/capcom/smsgateway/modules/gateway/services · high confidence

The local server now requires authentication for all API endpoints using JWT access and refresh tokens, replacing any previous open access. Access is controlled via granular scopes (such as messages:send, inbox:list, settings:write) defined in AuthScopes, ensuring clients only have permissions for the specific actions they need. This change introduces new token management endpoints for issuing, refreshing, and revoking credentials, and applies these security checks across all local server routes including messages, inbox, webhooks, settings, and logs.

app/src/main/java/me/capcom/smsgateway/modules/localserver/routes · high confidence

A new Colors.kt file defines specific color codes for each state in the ProcessingState enum (Pending, Cancelling, Cancelled, Processed, Sent, Delivered, Failed), enabling the UI to visually distinguish message statuses.

app/src/main/java/me/capcom/smsgateway/ui/styles · high confidence

The application now initializes a comprehensive modular architecture using Koin dependency injection, wiring together core services such as the event bus, settings, database, logging, notifications, MMS, message handling, incoming message tracking, receivers, encryption, gateway, health checks, webhooks, local server, ping, connection monitoring, and orchestrator. A new GlobalExceptionHandler ensures that unhandled crashes are logged via the LogsService before terminating. The main user interface has shifted from a single-page layout with a start/stop button to a tabbed navigation structure (Home, Messages, Settings) using ViewPager2 and TabLayout, allowing users to switch between these primary sections seamlessly.

app/src/main/java/me/capcom/smsgateway · high confidence

The new SendMessagesWorker ensures that pending SMS messages are sent in the background with higher priority and visibility. By leveraging Android's WorkManager with expedited work requests, the system can now process messages even when the app is in the background or under system resource constraints. The worker runs as a foreground service, displaying an ongoing notification to keep the user informed of the sending progress, and includes built-in retry logic with linear backoff to handle transient failures gracefully.

app/src/main/java/me/capcom/smsgateway/modules/messages/workers · high confidence

The local data layer has been restructured to support advanced message lifecycle tracking. The database version has been bumped to 24, introducing new entities for message recipients, recipient states, and JWT tokens, while migrating the core message table to store structured content and support encryption and priority fields. To ensure data integrity during this transition, the system now includes explicit migration scripts for versions 7→8, 13→14, and 21→22, alongside robust type converters that handle legacy date formats to prevent crashes when reading older records.

app/src/main/java/me/capcom/smsgateway/data · high confidence

This change introduces several new domain entities to support updated gateway capabilities. A new HealthResponse model exposes version, release ID, and health check results to users. Message handling is enhanced with a ProcessingState enum (replacing the previous state model) to track message lifecycle including cancellation, and a MessageContent sealed class that now supports Text, Data (with port info), and Mms (with attachments) content types. Additionally, WebhookDelivery configuration now supports Batch delivery modes alongside Individual and Disabled options, and an EntitySource enum defines the origin of entities (Local, Cloud, or deprecated Gateway).

app/src/main/java/me/capcom/smsgateway/domain · high confidence

The webhook payload structure has been extended to support new event types and richer data. New payload classes include \AppStartedPayload\ for application startup events, and specific payloads for SMS lifecycle events (\SmsSent\, \SmsDelivered\, \SmsFailed\, \SmsCancelled\) and MMS events (\MmsReceived\, \MmsDownloaded\). The \SmsSent\ payload now includes a \partsCount\ field. Additionally, batch support is introduced via \BatchEventPayload\ and its subclasses (\SmsBatchReceivedPayload\, \MmsBatchReceivedPayload\, \MmsBatchDownloadedPayload\, \SmsDataBatchReceivedPayload\), allowing multiple messages to be sent in a single webhook call. A new \simNumber\ field is added to message payloads to identify the SIM card used, and the legacy \phoneNumber\ field is deprecated in favor of \sender\/\recipient\.

app/src/main/java/me/capcom/smsgateway/modules/webhooks/payload · high confidence

The receiver module now uses a new sealed class \InboxMessage\ to represent incoming messages, supporting text, binary data, and MMS payloads. This change introduces specific subtypes (\Text\, \Data\, \MmsHeaders\, \MMS\) with distinct equality and hashing logic, enabling the system to handle MMS content and data messages alongside standard SMS in a unified structure.

app/src/main/java/me/capcom/smsgateway/modules/receiver/data · high confidence

The webhook module now defines its core domain models (WebHookDTO, WebHookEvent, WebHookEventDTO) to structure webhook configuration and event data. This includes support for a wider range of event types such as SMS, MMS, data messages, and system events, with specific handling for batched events (e.g., sms:batch:received). The models also incorporate device identification and source tracking to ensure events are correctly attributed.

app/src/main/java/me/capcom/smsgateway/modules/webhooks/domain · high confidence

A new OrchestratorService has been introduced to centralize the startup and shutdown sequences of the application's core modules. This service now manages the initialization order for components such as the gateway, incoming messages, webhooks, local server, and ping services, ensuring they start in a defined sequence. It also handles error resilience by catching exceptions during the start of foreground services (like the local server and ping) when the app is in the background, logging warnings instead of crashing. Additionally, an EventsRouter is included to unify event processing, routing external events (such as message enqueuing, cancellation, and settings updates) to the appropriate internal event buses. The service also triggers an 'app started' webhook event upon initialization, providing external systems with a notification of the gateway's readiness.

app/src/main/java/me/capcom/smsgateway/modules/orchestrator · high confidence

The gateway now exposes specific event classes to handle distinct lifecycle and configuration changes. Device registration outcomes are now reported via DeviceRegisteredEvent (carrying success details like login/password or failure reasons), while message cancellation is tracked through MessageCancelledEvent. Additionally, new events have been added to signal when messages are enqueued, settings are updated, or webhooks are modified, allowing the system to react to these specific state changes.

app/src/main/java/me/capcom/smsgateway/modules/gateway/events · high confidence

This change introduces a suite of new helper classes in the app's helpers module to support core gateway functionality. BuildHelper exposes a flag for insecure/debug builds, likely to relax restrictions like allowing insecure HTTP webhooks. DateTimeParser provides robust ISO date parsing with fallbacks for older Android versions. LocaleHelper manages app language settings and configuration context updates. PhoneHelper validates and formats phone numbers using the Google libphonenumber library. SSEManager implements a resilient Server-Sent Events client with automatic reconnection for real-time updates. SettingsHelper centralizes preference management, including a migration for server tokens and autostart controls. SubscriptionsHelper abstracts Android's SubscriptionManager to retrieve active SIM card details, slot indices, and phone numbers across different API levels.

app/src/main/java/me/capcom/smsgateway/helpers · high confidence

The app no longer runs a local Netty-based web server (previously exposed on port 53954) to receive commands; instead, it now uses Firebase Cloud Messaging (FCM) via the new PushService. This service handles FCM token registration and routes incoming push events (such as message enqueuing) through an event router, while skipping FCM registration entirely if the gateway is configured for SSE-only communication.

app/src/main/java/me/capcom/smsgateway/services · high confidence

The application now uses a consistent ISO 8601 date format for all JSON serialization via Gson. A new configuration function ensures that dates are serialized with millisecond precision and timezone information (using 'Z' for UTC or explicit offsets for other timezones), improving compatibility and readability of logs and API payloads across different Android API levels.

app/src/main/java/me/capcom/smsgateway/extensions · high confidence

The app replaces the previous per-event webhook sending approach with a dedicated queue-based system. A new WebhookQueueProcessorWorker handles sending webhook payloads in batches, featuring configurable retry counts, HTTP timeouts, and optional internet-connection constraints to ensure reliable delivery. Additionally, a ReviewWebhooksWorker periodically checks for pending SMS-received webhooks and notifies the user, improving visibility into webhook status.

app/src/main/java/me/capcom/smsgateway/modules/webhooks/workers · high confidence

Added tests for MessageWithRecipients state aggregation; Added tests for date conversion robustness; Added tests for hardened and legacy passphrase encryption providers; Added tests for phone number filtering logic; Added unit tests for MMS notification parsing; Added unit tests for message sorting and service dispatch logic; Added unit tests for webhook queue repository and view model.

The Gradle wrapper configuration has been upgraded from version 7.3.3 to 8.0. This change ensures that the build process uses the newer Gradle distribution, which may bring performance improvements, new features, and compatibility updates to the project's build lifecycle.

gradle · high confidence

The project upgrades the Android Gradle Plugin to version 8.1.2 and Kotlin to 1.7.22, while also introducing the KSP plugin for annotation processing. New dependencies include the Firebase BoM (31.1.1) with Firebase Messaging, the Koin dependency injection framework (3.4.0), and the libphonenumber library (9.0.22). Additionally, Ktor libraries are updated to version 2.2.4, and various AndroidX components (Core, AppCompat, Material, ConstraintLayout) are bumped to newer patch versions. The build configuration now supports insecure debug builds and adds signing configurations for release builds.

(dependencies) · high confidence

The repository has been initialized with core documentation files, including a comprehensive README detailing features like MMS support, webhooks, and multi-SIM usage, a CHANGELOG tracking versions from v1.58.0 to v1.75.0, and an Apache 2.0 LICENSE. A \.env.example\ template is provided for Android build configuration (keystore passwords), and the \.gitignore\ has been updated to exclude \.env\ files and adjust IDE-specific exclusions.

(repo-wide) · high confidence

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

• CAI 38 → 55 (+16.4)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 → 91 (-7.9)
• Architecture 96 → 90 (-5.2)
• Maturity 51 → 59 (+7.3)
• Readiness 26 → 60 (+34.3)
• Security 35 → 50 (+15.3)
• Domain Modelling 55 → 51 (-4.4)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• 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)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No artifact signing
• …and 3 more

• Change coupling: AppDatabase.kt ↔ MessagesService.kt (app/src/main/java/me/capcom/smsgateway/data/AppDatabase.kt)
• Change coupling: PullMessagesWorker.kt ↔ MessagesService.kt (app/src/main/java/me/capcom/smsgateway/modules/gateway/workers/PullMessagesWorker.kt)
• Change coupling: WebService.kt ↔ EventsReceiver.kt (app/src/main/java/me/capcom/smsgateway/modules/localserver/WebService.kt)
• ClassTooLong: MessagesService (app/src/main/java/me/capcom/smsgateway/modules/messages/MessagesService.kt)
• ClassTooLong: PduComposer (app/src/main/java/me/capcom/smsgateway/modules/mms/pdu/aosp/PduComposer.java)
• ClassTooLong: PduHeaders (app/src/main/java/me/capcom/smsgateway/modules/mms/pdu/aosp/PduHeaders.java)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no architecture or design documentation (README.md)
• Duplicated block (12 lines × 2) (app/src/main/java/me/capcom/smsgateway/modules/receiver/MmsContentObserver.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/me/capcom/smsgateway/modules/receiver/MmsContentObserver.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/me/capcom/smsgateway/modules/receiver/MmsContentObserver.kt)
• Duplicated block (18–20 lines × 2) (app/src/main/java/me/capcom/smsgateway/modules/localserver/routes/InboxRoutes.kt)
• Duplicated block (21 lines × 2) (app/src/main/java/me/capcom/smsgateway/modules/gateway/workers/SettingsUpdateWorker.kt)
• Duplicated block (7 lines × 2) (app/src/main/java/me/capcom/smsgateway/modules/incoming/vm/IncomingMessagesListViewModel.kt)
• Duplicated block (7 lines × 2) (app/src/main/java/me/capcom/smsgateway/modules/receiver/MessagesReceiver.kt)
• Duplicated block (7 lines × 2) (app/src/main/java/me/capcom/smsgateway/ui/IncomingMessagesListFragment.kt)
• Duplicated block (9 lines × 2) (app/src/main/java/me/capcom/smsgateway/ui/IncomingMessagesListFragment.kt)
• FileTooLong: aosp/PduComposer.java (app/src/main/java/me/capcom/smsgateway/modules/mms/pdu/aosp/PduComposer.java)
• FileTooLong: messages/MessagesService.kt (app/src/main/java/me/capcom/smsgateway/modules/messages/MessagesService.kt)
• FixmeComment (app/src/main/java/me/capcom/smsgateway/modules/mms/pdu/aosp/SendReq.java)
• …and 61 more

• 20 commits — 19 feature/other, 1 fixes

• app/src — 18 commits
• (root) — 2 commits

• fix: [messages] fix queue stuck when there is a scheduled message
• change: [data] support legacy date formats
• change: [docs] update readme, changelog, etc.
• change: [docs] update swagger, readme, and changelog
• change: [encryption] implement hardened passphrase encryptor
• change: [encryption] refactor
• change: [gateway] add upload API
• change: [helpers] new API for resolve phone number
• change: [i18n] update strings
• change: [i18n] update translations
• change: [localserver] add messages sort param
• change: [messages] async processing of sent/delivered broadcasts
• change: [messages] new API for delivery status parsing
• change: [messages] replace scheduled worker on new immediate message
• change: [mms] sending feature
• change: [receiver] batch webhooks support
• change: [ui] allow to filter messages by state/type
• change: [ui] improve start/stop button
• change: [webhooks] add webhook queue diagnostic list screen
• change: [webhooks] use scheduling instead of polling

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

• app

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

capcom6/android-sms-gateway 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.