How the Bark Notification Push Integration Works in SmsForwarder

The Bark notification push integration in SmsForwarder converts incoming messages into HTTP POST requests using the Bark API, with support for automatic verification code detection, optional AES encryption, and Basic Authentication.

The Bark notification push integration is implemented in the open-source Android application SmsForwarder (pppscn/SmsForwarder) as a core sender channel. When a forwarding rule triggers, the framework deserializes the Bark-specific configuration and constructs a compliant HTTP request to your Bark server endpoint. This implementation follows a request-builder pattern shared across all sender types in the application.

Architecture Overview

The Bark integration operates through a centralized dispatcher that routes messages to the appropriate sender utility. When the sender type TYPE_BARK is detected in SendUtils.sendMsgSender, the system instantiates a BarkSetting object from the rule's JSON configuration and delegates transmission to BarkUtils.sendMsg. This utility handles request construction, optional encryption, network transmission via the XHttp library, and response parsing using BarkResult.

Step-by-Step Implementation

Sender Selection and Configuration Parsing

In SendUtils.kt (lines 38–41), the framework iterates through the rule's senderList. When encountering TYPE_BARK, it deserializes the stored JSON into a BarkSetting object defined in BarkSetting.kt. This data class contains all configurable parameters including the server URL, encryption keys, and notification styling options.

Building the HTTP Request

The BarkUtils.sendMsg function (lines 31–63 in BarkUtils.kt) prepares the transmission by:

1. Extracting the final title and body from the incoming MsgInfo object and any applied templates
2. Parsing the setting.server URL to detect embedded credentials
3. Adding a Basic Authentication interceptor if the URL contains a user:password component (e.g., https://user:pass@host/...)

Payload Construction

The utility constructs a mutable map (lines 64–78) that maps to the Bark API specification:

• title – The processed message title
• body – The final content string
• isArchive – Hardcoded to 1 to ensure message history retention
• Optional fields – group, icon, level, sound, badge, url, and call (included only when present in the settings)

The map is then serialized to JSON using Gson().toJson(msgMap).

Automatic Verification Code Detection

If the autoCopy field is empty (lines 80–94), the system applies a comprehensive regular expression to detect verification codes within the message content. Upon detection, it automatically injects two additional fields into the payload:

• "copy" – The extracted verification code
• "autoCopy": 1 – Triggers the Bark client to copy the code to the device clipboard

Optional Payload Encryption

For security-sensitive deployments (lines 98–117), the integration supports algorithmic transformation of the payload. When setting.transformation specifies AES, AES/GCM, or similar algorithms:

1. The JSON payload is encrypted using the provided key and initialization vector (iv)
2. The encrypted string is transmitted as the ciphertext parameter
3. The Content-Type header switches to application/x-www-form-urlencoded

Network Request Execution

The actual transmission uses the XHttp library (lines 119–126) with specific configurations:

• Certificate handling – ignoreHttpsCert() bypasses HTTPS validation errors for self-hosted servers
• Response format – keepJson(true) preserves the raw JSON response
• Retry logic – Respects global retryCount and retryDelay settings
• Logging – LoggingInterceptor captures request/response data for the internal log database

Response Handling

The response processing logic (lines 128–144) distinguishes between success and failure states:

• Success – Parses the JSON into a BarkResult object; if code == 200, sets log status to 2 (success)
• Failure – Non-200 codes or ApiException triggers set status to 0 (failure) and logs the error message

In both cases, SendUtils.updateLogs persists the outcome, and SendUtils.senderLogic determines whether to proceed to the next sender in the rule chain.

Key Data Structures

The integration relies on three primary entities:

BarkSetting.kt (lines 5–33) defines the configuration schema:

• server: Target Bark API endpoint
• transformation, key, iv: Encryption parameters
• group, icon, sound, level, badge, url, call: Notification metadata
• autoCopy: Clipboard automation setting

BarkResult.kt (lines 3–5) models the server response:

• code: HTTP status equivalent (200 for success)
• message: Server response text
• requestId: Unique request identifier

Practical Implementation Example

Below is a complete example demonstrating how to manually trigger a Bark push with automatic verification code detection:

import cn.ppps.forwarder.utils.sender.BarkUtils
import cn.ppps.forwarder.entity.setting.BarkSetting
import cn.ppps.forwarder.entity.MsgInfo

// Configure the Bark sender
val barkSetting = BarkSetting(
    server = "https://api.example.com/push",
    group = "SecurityAlerts",
    icon = "https://example.com/icon.png",
    sound = "default",
    badge = "1",
    url = "https://example.com/detail",
    level = "active",
    title = "SmsForwarder",
    transformation = "none",  // Use "AES" for encryption
    key = "",
    iv = "",
    call = "",
    autoCopy = ""  // Empty string triggers automatic code detection
)

// Create a message containing a verification code
val msgInfo = MsgInfo(
    type = "sms",
    from = "+8613800000000",
    content = "Your verification code is 1234",
    time = System.currentTimeMillis(),
    simInfo = "SIM1",
    simSlot = 0,
    subId = 0L
)

// Execute the push (normally called automatically by SendUtils)
BarkUtils.sendMsg(barkSetting, msgInfo)

This execution will:

1. Detect the verification code "1234" and add "copy":"1234" to the payload
2. POST to the specified server with Basic Auth if credentials are embedded in the URL
3. Record the transmission result in the SmsForwarder log database

Summary

• The Bark notification push integration routes messages through SendUtils.sendMsgSender when the sender type is TYPE_BARK, deserializing configuration into BarkSetting objects.
• Request construction in BarkUtils.sendMsg supports Basic Authentication, automatic verification code extraction via regex, and optional AES/GCM encryption.
• Payload delivery uses the XHttp library with disabled certificate validation, JSON response preservation, and configurable retry logic.
• Response handling parses BarkResult objects to set explicit status codes (2 for success, 0 for failure) and maintains comprehensive transmission logs.

Frequently Asked Questions

How does SmsForwarder detect verification codes automatically for Bark notifications?

When the autoCopy field in BarkSetting is empty, BarkUtils.sendMsg applies a comprehensive regular expression to scan the message content for verification codes (lines 80–94). Upon detection, it injects the "copy" field containing the extracted code and "autoCopy": 1 into the JSON payload, instructing the Bark iOS client to automatically copy the value to the system clipboard.

What encryption methods does the Bark integration support?

The integration supports symmetric encryption algorithms specified in the transformation field of BarkSetting, including AES and AES/GCM (lines 98–117). When enabled, the utility encrypts the entire JSON payload using the provided key and iv, then transmits the ciphertext as a form-urlencoded parameter rather than raw JSON.

How does the Bark integration handle authentication and HTTPS certificates?

The system extracts credentials from the server URL (e.g., https://user:pass@host/...) and attaches a Basic Authentication interceptor to the request (lines 31–63). For HTTPS endpoints, the XHttp configuration explicitly calls ignoreHttpsCert() (line 119) to bypass certificate validation errors, enabling compatibility with self-hosted Bark servers using private certificates.

Where is the Bark sender configuration stored in the SmsForwarder source code?

Configuration logic resides in BarkSetting.kt (lines 5–33), which defines the data class storing all user-configurable parameters. The UI for user input is implemented in BarkFragment.kt, while the core transmission logic exists in BarkUtils.kt. Response parsing uses BarkResult.kt to map server responses to internal status codes.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}