SMS Gateway - Complete Documentation

The SMS Gateway module replaces Odoo IAP for sending SMS messages. Instead of a cloud service, it uses physical Android phones as SMS gateways. Each phone is paired with Odoo via a QR code and automatically sends SMS messages from the queue.

1. System Architecture

Components

2. Odoo Module Installation

Prerequisites

• Odoo 18 with modules: sms, mass_mailing_sms, phone_validation
• Python library qrcode (for QR code generation)

Steps

1. Install the Python dependency:

   pip install qrcode[pil]

2. Copy the sms_gateway module to the Odoo addons directory:

   cp -r extra/sms/sms_modules/sms_gateway /path/to/odoo/addons/

3. Restart the Odoo server and update the module list
4. Install the SMS Gateway module via Applications

3. Mobile App Installation

Download APK (recommended)

Download the latest release APK from GitHub Releases. On your phone, open the downloaded .apk file and allow installation from unknown sources.

Install the latest release via ADB (script)

Connect the phone via USB (with USB debugging enabled). From the sms-gateway module root (extra/sms):

# Latest release
./scripts/install-release.sh

# A specific tag
./scripts/install-release.sh v1.3.0

# Re-download even if cached
./scripts/install-release.sh --force

Downloads app-release.apk from the GitHub release (cached per tag under .release-cache/), installs it with adb install -r and grants the SMS-limit permission. Requires gh (authenticated) and adb — no build toolchain needed.

Prerequisites (build from source)

• Android phone (version 8.0+ / API 26)
• Node.js 18+ (the setup script installs Node 20 via nvm automatically)
• Android Studio / Android SDK (the setup script auto-detects it)
• ADB and gh in PATH

Build & install (one script)

Connect the phone via USB. From the sms-gateway module root (extra/sms):

./scripts/setup.sh              # full flow: deps, prebuild, build, install
./scripts/setup.sh --clean      # prebuild with --clean (after app.json / native changes)
./scripts/setup.sh --no-install # build only, skip ADB install

The script bootstraps nvm + Node 20 (installs them if missing), initializes the sms-gateway-app submodule, detects the Android SDK, installs dependencies, prebuilds, builds the release APK, installs it via ADB and grants WRITE_SECURE_SETTINGS.

Build manually

git submodule update --init --recursive   # fetch sms-gateway-app sources
cd sms-gateway-app

# Install dependencies
npm install

# Prebuild native project (required for native modules)
npx expo prebuild

# Run on a connected phone
npx expo run:android

# OR build a release APK via EAS
eas build --profile production-apk --platform android

Upload as GitHub Release

gh release create v1.x.x ./build/*.apk \
  --repo Varyshop/sms-gateway-app \
  --title "v1.x.x" \
  --notes "Release notes"

Required Android Permissions

4. Module Settings in Odoo

Creating a gateway phone

1. Go to Email Marketing > SMS Gateway > Gateway Phones
2. Click New
3. Fill in:

   Field	Description	Example
   Name	Phone name	Phone 1 - O2
   Phone Number	Main number (international format)	+420777123456
   Phone Number 2	Second number (dual SIM, optional)	+420608987654
   Daily Limit	Max SMS per day	500
   SMS per Minute	Max SMS per minute (rate limit)	100
   Heartbeat Timeout	Minutes without heartbeat before going offline	5

4. Click Generate API Key - an API key and QR code will be generated

5. Phone Pairing

1. In Odoo, open the gateway phone form and make sure a QR code has been generated
2. On the Android phone, open the SMS Gateway app
3. Go to the Settings tab
4. Click Scan QR Code
5. Point the camera at the QR code displayed in Odoo
6. The app will automatically connect to the server and start sending heartbeats

The QR code contains

{
    "type": "sms_gateway",
    "url": "https://vas-odoo-server.cz",
    "api_key": "nahodny_bezpecnostni_token"
}

6. SMS Campaign Setup

Creating a campaign

1. Go to Email Marketing > SMS Marketing
2. Click New
3. Configure:
   • Subject: Campaign name (internal)
   • Recipients: Select a model (e.g. Contacts) and a filter
   • Body: SMS message text

Example SMS text

Ahoj {{ object.name }}! Mate 20% slevu na vse.
Nakupte na https://www.example.cz/akce
STOP pro odhlaseni

Filtering recipients

Use the Odoo domain filter to select recipients:

7. Domain Filtering for Phones

Each gateway phone can have a Partner Domain Filter configured. This filter determines which SMS messages will be assigned to the given phone based on the recipient's partner.

How it works

1. When sms.sms._send() assigns SMS to the queue, it searches for available phones
2. For each phone with a configured domain_filter, it verifies whether the recipient's partner matches the filter
3. A phone without a filter accepts SMS for all partners
4. A phone with a filter only accepts SMS where the partner matches the domain

Usage examples

8. Sending

Automatic sending (campaign)

1. Create and configure a campaign (see section 6)
2. Click Send or Schedule
3. Odoo creates sms.sms records in the outgoing state
4. A cron job (SMS: SMS Queue Manager) picks up outgoing SMS
5. _send() assigns each SMS to a gateway phone and changes the state to pending
6. The mobile app fetches pending SMS via the API
7. The app sends the SMS and confirms the state (sent/error)

Manual sending (Force Create SMS Queue)

If SMS records were not created automatically:

1. Open the campaign
2. Click Force Create SMS Queue
3. The system creates SMS records for all remaining recipients

Pausing a campaign

A campaign can be paused without cancelling it:

1. Open the campaign in Sending mode
2. Toggle the Paused switch to active
3. SMS in the queue will not be sent, but will remain assigned
4. To resume, turn off the Paused switch

9. How Links and Tracking Work

Automatic link conversion

All URLs in the SMS body are automatically converted to short tracking links:

How tracking works

1. Link creation: Odoo creates a link.tracker record with a short code and UTM parameters
2. Adding SMS ID: Each link gets /s/{sms_id} appended to identify the specific recipient
3. Recipient clicks: The recipient clicks the link in the SMS message
4. Server records:
   • IP address and country of the clicker
   • Click timestamp
   • Association with mailing.trace (which recipient clicked)
5. Redirect: The server redirects to the original URL with UTM parameters:

   https://www.example.cz/akce?utm_campaign=Q1_2025&utm_medium=sms&utm_source=kampan

UTM parameters

Automatically added on redirect:

10. Unsubscribe and Blacklist (GDPR)

How unsubscribing works

The system supports two ways to unsubscribe from SMS campaigns:

Method 1: STOP message (recommended)

1. At the end of each SMS there is the text: STOP pro odhlaseni
2. The recipient replies with an SMS message containing the word STOP
3. The mobile app detects an incoming SMS containing the word STOP
4. The app sends the information to the Odoo endpoint /sms-gateway/inbound
5. Odoo adds the recipient's number to phone.blacklist
6. All future campaigns automatically skip blacklisted numbers

Method 2: Web link (standard Odoo)

Odoo normally generates an unsubscribe URL in the format /sms/{mailing_id}/{trace_code}. Our module replaces these URLs with the text "STOP pro odhlaseni", because:

• A URL takes too much space in an SMS (160 character limit)
• Text "STOP" is simpler for users
• It corresponds to standard SMS marketing practice

Blacklist model

Odoo uses the phone.blacklist model from the phone_validation module:

• Numbers are stored in E.164 format (e.g. +420777123456)
• Duplicates are automatically detected
• Blacklisted numbers are skipped when creating SMS records
• An administrator can remove a number from the blacklist (e.g. if the customer consents again)

Where to find the blacklist

SMS Marketing > Configuration > Phone Blacklist

11. Campaign Statistics and Performance

Tracked metrics

Where to find statistics

1. Campaign overview: Open the campaign - the header shows Sent/Clicked/Bounced counters
2. Detailed statistics: Click a counter to display the list of records
3. Link Tracker: Email Marketing > Link Tracker - overview of all tracked links with click counts
4. Gateway phones: SMS Gateway > Gateway Phones - sent_today, sent_total, pending, error counters

Link Tracker - detailed analysis

Each link in an SMS has its own link.tracker record:

• Total click count - how many times the link was clicked (including repeated clicks)
• Unique clicks - how many different recipients clicked
• Country - geolocated by IP address
• Timeline - when clicks occurred (peak hours)

12. Limits and Rate Limiting

Limit types

How rate limiting works

1. The server sets rate_limit on each gateway phone (e.g. 100 SMS/min)
2. The mobile app gets the rate_limit from the heartbeat response
3. Between each SMS the app waits 60000 / rate_limit milliseconds
4. If the phone reaches the daily_limit, no further SMS is assigned to it

adb shell settings put global sms_outgoing_check_max_count 10000

13. Dual SIM Support

The system supports phones with two SIM cards:

• Each gateway phone can have two numbers: phone_number and phone_number_2
• The app automatically detects both SIM cards using the native SimManager module
• The heartbeat sends both numbers; the server counts pending SMS for each number separately
• When sending, the SMS is sent via the SIM slot corresponding to the assigned number

14. API Reference

All endpoints require the X-API-Key header with a valid gateway phone API key.

POST /sms-gateway/heartbeat

Send a heartbeat and get the queue status.

// Request
{
    "phone_numbers": ["+420777123456", "+420608987654"],
    "battery_level": 85,
    "signal_strength": -70
}

// Response
{
    "success": true,
    "pending_count": {"+420777123456": 12, "+420608987654": 5},
    "rate_limit": 100
}

POST /sms-gateway/pending

Get SMS waiting to be sent.

// Request
{"phone_numbers": ["+420777123456"], "limit": 20}

// Response
{
    "success": true,
    "sms_list": [
        {
            "id": 123,
            "phone_number": "+420999888777",
            "message": "Text SMS zpravy...",
            "uuid": "abc-123-def",
            "gateway_phone_number": "+420777123456"
        }
    ]
}

POST /sms-gateway/confirm/{sms_id}

Confirm the send status of an SMS.

// Request - uspech
{"status": "sent"}

// Request - chyba
{"status": "error", "error_message": "Permission denied"}

// Request - probihajici
{"status": "sending"}

// Response
{"success": true}

POST /sms-gateway/inbound

Report an incoming SMS (for STOP detection). The message is saved to the sms.gateway.inbound model and if it contains STOP, the number is added to the blacklist.

// Request
{
    "from_number": "+420999888777",
    "message": "STOP",
    "to_number": "+420777123456"
}

// Response
{
    "success": true,
    "blacklisted": true,
    "partner_found": true
}

POST /sms-gateway/inbound-batch

Bulk report of multiple incoming SMS at once. Since v1.2.0 the app sends all received SMS (not just STOP) to the server. The server deduplicates based on the combination from_number + to_number + message + received_at, so resending the same messages (e.g. on inbox rescan) will not create duplicates.

// Request
{
    "messages": [
        {
            "from_number": "+420999888777",
            "message": "STOP",
            "to_number": "+420777123456",
            "received_at": "2026-03-22T10:30:00Z"
        },
        {
            "from_number": "+420111222333",
            "message": "Dekuji za informaci",
            "to_number": "+420777123456",
            "received_at": "2026-03-22T11:15:00Z"
        }
    ]
}

// Response
{
    "success": true,
    "processed": 2,
    "duplicates_skipped": 0
}

Model: sms.gateway.inbound

All incoming SMS are stored in the sms.gateway.inbound model:

POST /sms-gateway/stats

Gateway phone statistics.

// Response
{
    "success": true,
    "phones": [
        {
            "id": 1,
            "name": "Telefon 1 - O2",
            "phone_number": "+420777123456",
            "phone_number_2": null,
            "state": "online",
            "sent_today": 142,
            "daily_limit": 500,
            "sent_total": 4582,
            "pending_count": 23,
            "rate_limit": 100
        }
    ]
}

POST /sms-gateway/register-fcm

Register an FCM token for push notifications. The phone sends its FCM token after pairing or when the token is renewed.

// Request
{
    "fcm_token": "dK3xP9...dlouhy_firebase_token"
}

// Response - uspech
{
    "success": true,
    "message": "FCM token registered"
}

// Response - FCM neni povoleno
{
    "success": true,
    "message": "FCM not enabled, token ignored"
}

POST /sms-gateway/confirm-batch

Bulk confirmation of the status of multiple SMS at once. More efficient than individual /confirm/{sms_id} calls.

// Request
{
    "results": [
        {"sms_id": 123, "status": "sent"},
        {"sms_id": 124, "status": "sent"},
        {"sms_id": 125, "status": "error", "error_message": "Number unreachable"}
    ]
}

// Response
{
    "success": true,
    "processed": 3
}

14b. Marketing Models (Segments and Templates)

Since version v18.0.2.2.0 the module includes models for SMS marketing directly from the mobile app. An admin defines segments and templates in Odoo; an operator uses them from the app without backend access.

Model: sms.marketing.segment

Defines a group of recipients (e.g. "No order in 3 months").

Default segments (data)

Key methods

Model: sms.marketing.template

SMS template assigned to a gateway phone.

New fields on mailing.mailing

14c. Campaign API (Mobile App)

Endpoints for the mobile app enabling creation and monitoring of SMS campaigns without backend access. All endpoints: POST, auth via X-API-Key, JSON body/response.

POST /sms-gateway/campaign/templates

Returns templates assigned to the phone identified by the API key.

// Response
{
    "success": true,
    "templates": [
        {
            "id": 1,
            "name": "Akce tento tyden",
            "body": "Ahoj {{object.name}}! Mate slevu 20%...",
            "segments": [
                {"id": 1, "name": "Neobjednali 3 mesice", "code": "no_order_3m"},
                {"id": 2, "name": "Jedina objednavka", "code": "one_order_only"}
            ],
            "default_limit": 100,
            "max_limit": 500,
            "exclude_contacted_days": 14
        }
    ]
}

POST /sms-gateway/campaign/filters

For each segment, counts the number of matching recipients (including phone domain filter and exclusion).

// Request
{"template_id": 1}

// Response
{
    "success": true,
    "filters": [
        {
            "id": 1,
            "code": "no_order_3m",
            "name": "Neobjednali 3 mesice",
            "description": "Partneri s objednavkou ale zadnou za 90 dni",
            "recipient_count": 342
        }
    ]
}

POST /sms-gateway/campaign/preview

Campaign preview — recipient count and rendered text with a sample partner.

// Request
{"template_id": 1, "segment_id": 1, "limit": 200}

// Response
{
    "success": true,
    "recipient_count": 200,
    "preview_text": "Ahoj Jan Novak! Mate slevu 20%...",
    "template_name": "Akce tento tyden",
    "segment_name": "Neobjednali 3 mesice"
}

POST /sms-gateway/campaign/create

Creates a mailing.mailing with full tracking. Accepts optional custom_body (text edit from the app) and a send_now switch.

// Request
{
    "template_id": 1,
    "segment_id": 1,
    "limit": 200,
    "custom_body": "Upraveny text SMS...",
    "send_now": true
}

// Response
{
    "success": true,
    "campaign_id": 42,
    "recipient_count": 200,
    "state": "sending"
}

POST /sms-gateway/campaign/assign-sim

Assigns a gateway phone and SIM to the SMS in the campaign. Uses the same logic as the "Send via Gateway" action in Odoo.

// Request — jedina SIM (nebo auto-prirazeni bez SIM cisla)
{
    "campaign_id": 42,
    "mode": "single",
    "sim_number": "+420777123456"
}

// Request — rozdeleni mezi vice SIM
{
    "campaign_id": 42,
    "mode": "split",
    "sim_numbers": ["+420777123456", "+420608987654"]
}

// Response
{
    "success": true,
    "assigned": 200,
    "message": "Assigned 200 SMS to phone"
}

POST /sms-gateway/campaign/list

List of campaigns created from the app for the given phone.

// Response
{
    "success": true,
    "campaigns": [
        {
            "id": 42,
            "name": "Akce tento tyden - 04.04.2026 10:30",
            "state": "done",
            "date_created": "2026-04-04 10:30:00",
            "total": 200,
            "sent": 195,
            "pending": 0,
            "error": 5,
            "clicked": 42,
            "total_clicks": 67,
            "order_count": 8,
            "revenue": 12400.0,
            "optout": 3
        }
    ]
}

POST /sms-gateway/campaign/status/{mailing_id}

Campaign detail with marketing statistics.

// Response
{
    "success": true,
    "id": 42,
    "name": "Akce tento tyden - 04.04.2026 10:30",
    "state": "done",
    "total": 200,
    "sent": 195,
    "pending": 0,
    "error": 5,
    "clicked": 42,
    "total_clicks": 67,
    "order_count": 8,
    "revenue": 12400.0,
    "optout": 3,
    "created_at": "2026-04-04 10:30:00"
}

Statistics explanation

15. Troubleshooting

Diagnostic commands (curl)

# Test heartbeat
curl -X POST https://vas-server.cz/sms-gateway/heartbeat \
  -H "Content-Type: application/json" \
  -H "X-API-Key: VAS_API_KLIC" \
  -d '{"phone_numbers": ["+420777123456"]}'

# Overeni pending SMS
curl -X POST https://vas-server.cz/sms-gateway/pending \
  -H "Content-Type: application/json" \
  -H "X-API-Key: VAS_API_KLIC" \
  -d '{"phone_numbers": ["+420777123456"], "limit": 5}'

# Test inbound STOP
curl -X POST https://vas-server.cz/sms-gateway/inbound \
  -H "Content-Type: application/json" \
  -H "X-API-Key: VAS_API_KLIC" \
  -d '{"from_number": "+420999888777", "message": "STOP", "to_number": "+420777123456"}'

16. FCM Push Notifications

Since version v18.0.2.0.0 the module supports Firebase Cloud Messaging (FCM) for immediately waking up the phone when new SMS are in the queue. Instead of waiting for the next polling interval, the phone receives a push notification and immediately fetches pending SMS.

Architecture

Configuration on the Odoo side

Python dependency

pip install firebase-admin

The firebase-admin library is automatically installed when the module is installed (declared in external_dependencies in the manifest). If installation fails (e.g. missing system libraries), the FCM feature silently deactivates and phones continue in polling mode.

Implementation: tools/fcm_service.py

The main function send_fcm_wake(phone) sends an FCM data message to the registered phone. A data message (unlike a notification message) wakes the app in the background without showing a notification to the user.

# Format FCM data message
{
    "type": "sms_pending",
    "phone_id": "7",
    "timestamp": "1710751200"
}

Backward compatibility

17. Background and Reliability (Android)

Android aggressively restricts background app activity to save battery. This section documents the strategies used in the SMS Gateway app for reliable operation even with a locked screen and in Doze mode.

AlarmManager vs ScheduledExecutorService

For regular polling (heartbeat + fetching SMS) the app uses AlarmManager with exact wakeup instead of ScheduledExecutorService or Handler.postDelayed().

WorkManager for incoming SMS

Processing incoming SMS (STOP detection) uses WorkManager (InboundSmsWorker) instead of direct HTTP calls from the BroadcastReceiver. Reasons:

• BroadcastReceiver has a time limit of ~10 seconds — a network request may fail
• WorkManager automatically retries on failure (exponential backoff)
• WorkManager respects network conditions (constraint: NetworkType.CONNECTED)
• Survives device restart

WakeLock strategy

The app uses PowerManager.WakeLock in two places to prevent the CPU from sleeping during critical operations:

IMPORTANCE_HIGH notification channel

The foreground service notification uses a channel with IMPORTANCE_HIGH. This ensures Android does not kill the service even under low memory conditions. The user sees a persistent notification in the status bar (Android requirement for foreground service).

Battery optimization exception

On first app launch the user is asked to grant a battery optimization exception (REQUEST_IGNORE_BATTERY_OPTIMIZATIONS). Without this exception Android may:

• Delay AlarmManager alarms in Doze (groups them into a maintenance window)
• Restrict background network access
• Terminate foreground service after prolonged inactivity (MIUI, Samsung)

Rescan Inbox (native method)

Since v1.2.0 the app includes a native method SmsModule.rescanInbox(days), which reads the SMS inbox for the last N days (default: 30) and sends all found messages to the server via the endpoint /sms-gateway/inbound-batch.

This feature is available to the user via the Re-scan received SMS button in Settings > Service. The server performs deduplication, so it is safe to run the rescan repeatedly.

// React Native volani
import { NativeModules } from 'react-native';
const messages = await NativeModules.SmsModule.rescanInbox(30);
// messages: Array<{from: string, body: string, date: number}>

// Nasledne se zpravy odeslou pres inbound-batch endpoint

WRITE_SECURE_SETTINGS permission

To increase the native Android limit on the number of outgoing SMS, the app needs the WRITE_SECURE_SETTINGS permission. This permission cannot be granted from the phone's GUI — it requires an ADB connection:

# Primo pres ADB
adb shell pm grant com.varyshop.smsgatewayapp android.permission.WRITE_SECURE_SETTINGS

# Nebo pri buildu ze zdrojaku
yarn grant-permission

Heartbeat safety net

Even with FCM there can be situations where a push notification does not arrive (e.g. temporary Google service outage). Therefore the app maintains a heartbeat safety net:

1. Every heartbeat returns pending_count for each number
2. If pending_count > 0, the app immediately starts a poll cycle
3. The heartbeat interval is typically 60 seconds — the maximum delay on FCM failure is therefore 1 minute
4. This mechanism works independently of FCM and ensures delivery even without push notifications

18. Changelog

v18.0.2.6.0 / App v1.5.0 (2026-04-06)

• SMS limit enforcement: Endpoint /sms-gateway/pending now checks the remaining daily/monthly capacity of the phone before issuing SMS. If the limit is exhausted, active campaigns are automatically paused and the response contains limit_reached: true
• Pause/Resume campaign: New endpoints POST /campaign/pause/<id> and POST /campaign/resume/<id>. A paused campaign stays in state sending with paused=True — its SMS are not picked up in the pending endpoint (filter m.paused = false in the pickup query). Resume sets paused=False and the campaign continues
• Campaign archiving: New endpoint POST /campaign/archive/<id> sets active=False. In the app available only in advanced mode for completed campaigns
• Filters in campaign list: The default view shows only in_queue, sending and paused campaigns. Added "Completed" and "Archived" toggles (archived only in advanced mode). API parameters include_done and include_archived in /campaign/list
• Fix: The "Send now" button now appears only when the campaign is in in_queue state — previously it reappeared after leaving and returning to the screen
• App UI: Red "Pause sending" button when actively sending, yellow "Resume sending" when in paused state. Status badge shows "Paused" with amber color

v18.0.2.5.0 (2026-04-05)

• Sentinel -1 for "never contacted": stats_last_sms_days (on both res.partner and res.partner.stats) now returns -1 if the partner has no last_sms_sent_date. Previously it returned 0, which the UI could not distinguish from "contacted today" — the operator could not tell which was which. The value -1 gives an unambiguous signal in form view and in exports. Search semantics remain identical (> N still includes never-contacted partners via the OR branch, so campaigns with exclude_contacted_days > 0 will include brand-new partners and exclude only those contacted in the last N days).
• Edge test on production DB copy: Verified that all 3 scenarios behave correctly: contacted today → days=0, never contacted → days=-1, contacted 3 days ago → days=3. Search leaf ('stats_last_sms_days', '>', 30): today match=0, never match=1, 3d_ago match=0 — exactly as intended (campaign includes never-contacted + old, excludes today + recent).

v18.0.2.4.0 (2026-04-05)

• Critical fix — NULL-aware exclusion filter: res.partner.stats_last_sms_days was a related field via O2m stats_id, so Odoo converted the domain search to a LEFT JOIN res_partner_stats and NULL rows (partners without a stats row) fell out. A campaign with exclude_contacted_days=30 would thus not receive even a single never-contacted partner — the exact opposite of intended behavior.
  • The field is now computed + has its own _search_stats_last_sms_days handler
  • For operators >/>= it returns an OR branch: partners with a stats row satisfying the date or partners without a stats row (('stats_id', '=', False))
  • Verified on production DB copy (24 974 partners): before fix ('stats_last_sms_days','>',30) returned 5 026 partners, after fix 14 467 (9 441 never contacted + 5 026 old)
• Perf test @ scale: Pending endpoint CTE query tested on 10 000 pending SMS + 41 456 SMS traces on production DB copy. EXPLAIN ANALYZE: 8.98 ms execution (limit=20), partial index mailing_trace_sms_res_id_write_date_idx is index-only scan, 20 lookups instead of sequential scan — confirms feasibility at target 100k+/10k+ scale.
• Bulk recompute test: _update_last_sms_sent processed 14 750 partners in 1.19 s via execute_values bulk UPDATE.

v18.0.2.3.0 / App v1.4.0 (2026-04-05)

• SQLite-based SMS status persistence: Replaced in-memory batch queue with persistent SQLite WAL — SMS status is written before HTTP sync, so app crashes do not cause data loss
• Sync with exponential backoff: Retry based on sync_attempts (0–2 always, 3–5 ~30s, 6–9 ~5min, 10+ ~30min)
• Reconcile endpoint: New POST /sms-gateway/reconcile — returns already_confirmed_ids, stuck_ids, not_found_ids for synchronization on app start
• Hourly housekeeping: Automatic deletion of old records from the local DB (max 1× per hour)
• Heartbeat unsynced_count: Server logs a warning if unsynced SMS > 10
• No duplicate SMS — 6 race conditions fixed:
  • AtomicBoolean isPollingActive protects against overlapping poll cycles
  • SELECT ... FOR UPDATE in _update_gateway_status prevents TOCTOU race
  • sentReceiver: getOrPut → null-check (ignores late callbacks after sweep)
  • sweepStaleTrackers requires strict equality sentParts == totalParts && failedParts == 0
  • Cron _cron_reset_stuck_gateway_sms resets SMS stuck > 30 min back to pending
  • Fixed trace_status values 'failed' → 'error' (valid Odoo selection)
• Simple Mode in the app: New toggle in settings for non-technical employees — hides:
  • "Messages" tab
  • Dashboard: FCM/Poll badge, monthly limit, month/total/rate statistics
  • Settings: polling/heartbeat intervals, SMS limits, URL/API key, disconnect button, build number
  • Campaigns: the entire "Campaign results" section (CTR, revenue, clicks, orders, unsubscribes)
• Declarative exclusion filter: _get_exclusion_domain() now returns ('stats_last_sms_days', '>', days) instead of an SQL query on mailing_trace. Exclusion is part of the stored mailing_domain and Odoo applies it in a single search query together with the segment and phone filter — eliminating large ('id', 'not in', [...]) clauses and runtime SQL in mailing.mailing._get_recipients()
• Filtered counts in segments: Endpoint /campaign/filters now shows for each segment the recipient count already after subtracting exclude_contacted_days (thanks to the declarative leaf it propagates automatically)
• Fix: _search_last_sms_sent_days for operators >/>= now includes partners without SMS history (last_sms_sent_date IS NULL)
• Fix: res.partner.stats.last_sms_sent_date is now updated in real time on every successful SMS send (_touch_last_sms_sent called from sms.sms._update_gateway_status). Previously the field was only updated by a nightly cron, causing duplicate SMS to the same recipients within the same day — the exclusion filter saw stale values
• Fix: Nightly cron _update_last_sms_sent now reads from mailing_trace states ('pending', 'sent', 'open', 'reply') instead of only 'sent' (in Odoo 18 'sent' means "delivered", not "sent")
• Just-in-time exclusion at pickup: Endpoint /sms-gateway/pending now just before issuing SMS to the phone cancels records whose recipient has been contacted by another campaign within the exclude_contacted_days window in the meantime. Solves race condition: campaign A created at 10:00 with 10 000 recipients, before sending finishes B sends SMS to some of the same recipients at 11:00. The check is optimized for large databases (100k+ contacts, 10k+ per campaign):
  • Pre-check CTE limits the candidate set to the first limit SMS (typically 20) ordered ORDER BY id ASC — same as the pickup query. Does not check the entire campaign, only the next batch
  • EXISTS subquery on mailing_trace with filter mt.mass_mailing_id != s.mailing_id (not self)
  • Partial index mailing_trace_sms_res_id_write_date_idx created in post_init_hook on columns (res_id, write_date) with WHERE clause trace_type='sms' AND trace_status IN ('pending','sent','open','reply') — EXISTS is an index-only scan
  • Cost per poll: ~limit index lookups (<1 ms) instead of sequential scan of entire mailing_trace
  • Cancelled SMS get failure_type='sms_duplicate' — visible in Odoo UI
• New server action: Recompute Last SMS Sent on model res.partner (available from list/form view) — manual recomputation of last_sms_sent_date from mailing_trace. Parallel to the existing Recompute Order Stats action
• Partner form: Order Stats tab now shows fields stats_last_sms_sent and stats_last_sms_days, so it is visible why a partner is in/out of the exclusion filter
• Fix: Campaign sent count mismatch (Odoo 593 vs phone 334) — endpoint campaign/status/campaign/list now counts trace_status IN ('pending', 'sent', 'open', 'reply') same as Odoo UI
• Fix: Redundant "Send now" button no longer appears after a successful send_now=true
• Stuck SMS cron: Timeout moved from 10 to 30 minutes for backwards compatibility with slow rate limits of the old app

v18.0.2.2.0 / App v1.3.0 (2026-04-04)

• Campaign Wizard in the app: New "Campaigns" tab — operator selects a template, segment, number of recipients and sends the campaign directly from the phone
• Marketing segments: sms.marketing.segment with declarative and SQL-based domains (3 default segments)
• Marketing templates: sms.marketing.template assigned to gateway phones
• Campaign API: 7 new endpoints (templates, filters, preview, create, assign-sim, list, status)
• SMS text editing: Operator can edit the template text before sending directly in the preview
• Send choice: "Send now" vs "Queue" when creating a campaign
• SIM selection: Automatic assignment for single SIM, selection/splitting for dual SIM
• Marketing statistics: Clicks, orders, revenue from the campaign, unsubscribes — in the app and API
• Domain optimization: Declarative segments are stored as readable domain; SQL segments are pre-resolved to compact ('id', 'in', [...])
• Phone domain compositing: sms.gateway.phone.domain_filter is automatically combined with the segment domain in _get_full_domain()
• Exclusion: Partners contacted in the last N days are excluded via mailing_trace
• Fix: email_from NOT NULL error when creating an SMS campaign
• Fix: Filtering of empty phone numbers (empty string was not filtered out)
• Fix: gateway_phone_forced_id as fallback in sms.sms._send()

v18.0.2.1.0 / App v1.2.0

• Incoming SMS tab and inbound history
• Rescan inbox (native method)
• Batch inbound endpoint with deduplication
• FCM push notifications
• Dual SIM support

SMS Gateway v18.0.2.6.0 • VaryShop • 2026