Telegram UI × Signal Backend — An Android messaging client that looks and feels exactly like Telegram, but runs entirely on the Signal protocol underneath.
Build an Android app where the user sees Telegram's interface — every screen, animation, cell, toolbar, sheet, and interaction — but every message, call, contact, group, story, and piece of data flows through Signal's end-to-end encrypted protocol and servers.
This is NOT a theme or redesign. This is literally Telegram's Android UI code, stripped of Telegram's backend (MTProto, TDLib, Telegram API), and rewired to Signal's backend (libsignal, signal-service-java, RingRTC, SQLCipher).
| Layer | Source | What It Does |
|---|---|---|
| Presentation | Telegram Android (DrKLO/Telegram) |
All UI: screens, cells, components, animations, navigation, theming |
| Bridge | Sigram (NEW) | Adapter layer that maps Telegram UI data expectations to Signal data models |
| Backend | Signal Android (signalapp/Signal-Android) |
Protocol, crypto, database, server communication, jobs, calls, everything |
User taps "Send" in Telegram's ChatActivity
→ SigramBridge translates to Signal's MessageSender
→ libsignal encrypts with Double Ratchet
→ signal-service-java sends to Signal servers
→ Recipient receives via WebSocket
→ Signal decrypts → stores in SQLCipher
→ SigramBridge posts NotificationCenter event
→ Telegram's ChatMessageCell renders the message
┌─────────────────────────────────────────────────┐
│ Telegram UI Layer (KEPT) │
│ ActionBar, Cells, Components, ChatActivity, │
│ DialogsActivity, PhotoViewer, VoIPFragment, │
│ Stories, custom views, animations │
├─────────────────────────────────────────────────┤
│ Sigram Bridge (NEW) │
│ TLRPC Wrappers: Dialog↔ThreadRecord, │
│ Message↔MessageRecord, User↔Recipient │
│ Controllers → Signal Repositories/Services │
│ Signal LiveData → NotificationCenter events │
├─────────────────────────────────────────────────┤
│ Signal Backend (IMPORTED) │
│ libsignal-client, signal-service-java, │
│ SQLCipher, RingRTC, Jobs, Crypto, Groups, │
│ Stories, Contacts, Notifications │
└─────────────────────────────────────────────────┘
- All UI code:
org.telegram.ui/— screens, cells, components, adapters, animations - Navigation: ActionBarLayout, BaseFragment, LaunchActivity
- Event bus: NotificationCenter (internal observer pattern)
- Utilities: AndroidUtilities, LocaleController, SharedConfig, ImageLoader
- Theming: Telegram's theme system (local-only)
- Performance system: Device classification, adaptive animations
- MTProto: All native C++ networking (
jni/tgnet/) - TLRPC: Auto-generated API types (replaced with wrappers)
- ConnectionsManager: JNI bridge to MTProto
- Telegram API credentials: APP_ID, APP_HASH
- All Telegram-server communication
- Telegram-only features: Channels, Bots, Mini Apps, Premium, Passport, Scheduled Messages, Polls, Nearby People, Secret Chats (redundant — all Signal chats are E2EE), Multiple Accounts, Forum Topics, Inline Bots, Games, Stars
- libsignal-client: End-to-end encryption (Double Ratchet, X3DH, PQXDH)
- signal-service-java: Server communication (WebSocket + REST)
- RingRTC: Voice/video calling (WebRTC)
- SQLCipher: Encrypted local database
- Job system: Background task processing
- All Signal features: Registration, messaging, groups (GV2), stories, reactions, calls, disappearing messages, stickers, safety numbers, linked devices, backups, notifications, search, message requests, sealed sender
All Signal features are preserved and accessible:
Current live blocker: local builds now package Signal Android's app-owned backend through :signal-app-core, commit successful login through Signal's local registration repository, avoid Telegram's old post-auth network path, and start Signal's receive/job runtime after login. Emulator install/launch verification passes and app-private Signal database files are present. A real/dev-server post-login send/receive test still needs a usable Signal account pair; official Signal login is currently rate limited, and the local server workflow does not yet provide scripted account/code provisioning.
Current gate plan: docs/superpowers/plans/2026-06-13-signal-backend-integration-gate.md.
Next phase plan: docs/superpowers/plans/2026-06-13-phase-4-live-client-stabilization.md.
| Feature | Status | UI Source |
|---|---|---|
| Registration | Dev-ready, live verification pending | Telegram LoginActivity → Signal registration |
| 1:1 Messaging | Dev-ready; Phase 4 runtime/start-chat path added; live send/receive pending account pair | Telegram ChatActivity → Signal MessageTable |
| Group Messaging | Dev-ready (Phase 5C) | GV2 create + send/receive + per-sender names; device verification pending |
| Voice/Video Calls | Planned | Telegram VoIPFragment → RingRTC |
| Call Links | Planned | New Telegram-style UI → Signal call links |
| Stories | Planned | Telegram Stories UI → Signal stories |
| Media (photos/video/files) | Dev-ready (Phase 5C) | Telegram attach menu/PhotoViewer → Signal attachments (CDN up/download); voice notes pending |
| View-Once Media | Planned | Shared feature → wire directly |
| GIFs | Planned | Telegram GIF UI → Signal GIPHY proxy |
| Reactions | Dev-ready (Phase 5A) | Telegram reaction UI → Signal reactions |
| Replies | Dev-ready (Phase 5A) | Telegram reply quote UI → Signal quotes |
| Edit / Delete Messages | Dev-ready (Phase 5B) | Edit + delete wired through Signal bridge |
| Disappearing Messages | Partial (Phase 5B) | Peer-notifying timer set/get via Signal; in-chat entry wired, header-menu entry pending |
| Scheduled Messages | Dev-ready (device-local) | Telegram schedule picker → local AlarmManager send (Signal has no server-side schedule) |
| Text Formatting | Dev-ready (Phase 5B) | bold/italic/strike/mono/spoiler, inbound render + outbound send |
| Pinned Messages | Dev-ready (device-local) | Telegram pin UI → local store (Signal has no protocol pin; not synced to peer) |
| Chat Folders | Dev-ready | Shared feature → wire folder tabs to Signal |
| Stickers | Planned | Telegram sticker UI → Signal sticker packs |
| Safety Numbers | Planned | New Telegram-style row in profile |
| Linked Devices | Planned | Shared feature → wire device UI to Signal QR flow |
| Backups | Planned | New Telegram-style settings section |
| Search | Planned | Telegram search UI → Signal search |
| Notifications | Planned | Telegram notification system → Signal notifier |
| Settings & Privacy | Planned | Telegram settings screens → Signal prefs |
| Usernames | Planned | Wire Telegram username UI → Signal private usernames |
| Group Member Labels | Planned | New Telegram-style UI in group member list |
| Location Sharing | Planned | Telegram location picker → Signal coordinate attachment |
| PIN / 2FA | Planned | Wire Telegram PIN screens → Signal PIN/SVR |
| Phase | Milestone | Description |
|---|---|---|
| 0 | Project Scaffold | Complete: merged codebase builds and launches |
| 1 | Login | Complete for local development: official/dev endpoint toggle and Signal login adapter |
| 1.5 | Signal Backend Integration Gate | Local build complete; post-login persistence fix built; device/live verification pending |
| 2 | Chat List | Complete for local development: Telegram chat list renders Signal/dev fixture rows |
| 3 | 1:1 Messaging | Complete for fixture/dev testing, live Signal verification blocked by Phase 1.5 |
| 4 | Live Client Stabilization | Implemented for build/emulator QA: runtime start, QA script, and start-new-1:1 UI; live text send/receive pending account pair |
| 5 | Rich Conversations | In progress: replies + reactions (5A), formatting (both ways) + edit + delete + disappearing timers (5B), device-local scheduled + pinned messages, media (photos/video/files) + group messaging (5C) implemented; timer header-menu entry pending. Media, attachments, reactions, replies, edits/deletes, disappearing messages, formatting, pinned/scheduled messages, search, notifications |
| 6 | Social Surfaces & Account Features | Groups, stories, profiles, contacts, message requests, usernames, privacy/settings, linked devices, backups |
| 7 | Calls & Production Hardening | RingRTC calls/call links, final Telegram-only removal, edge cases, performance, accessibility, release verification |
Local development can now use the bundled Signal dev-server workflow:
.\dev-server\start-signal-server.ps1The app has a login-screen toggle for official Signal endpoints vs the local dev server. Android emulators use http://10.0.2.2:8080; real Android devices should use:
adb reverse tcp:8080 tcp:8080Phase 2 can also be tested without a live Signal account by seeding local client fixture data:
.\dev-server\seed-sigram-emulator.ps1 -Serial <device-or-emulator>Seeded data is app-private local fixture data, not Signal-Server database data. Remove it with:
.\dev-server\seed-sigram-emulator.ps1 -Serial <device-or-emulator> -PurgePhase 4 live-client QA installs the normal APK without fixture seeding, launches it, captures logcat/crash output, and lists app-private state:
.\dev-server\qa-sigram-live-client.ps1 -Serial <device-or-emulator>Expected for the current build: the script exits 0, build\sigram-live-qa\crash.txt has no fatal crash, and build\sigram-live-qa\databases.txt lists Signal database files. Full send/receive verification still requires logging into a real or locally provisioned Signal account pair.
Phase 0 is complete. The merged codebase compiles, builds an APK, and launches on an emulator without crashing.
| Verification Check | Result |
|---|---|
./gradlew :app:assembleDebug compiles |
✅ Pass |
| App installs and launches on emulator | ✅ Pass |
| Telegram intro/welcome screen appears | ✅ Pass |
No ClassNotFoundException or NoSuchMethodError in logcat |
✅ Pass |
Goal: Log in to an existing Signal account through Telegram's login UI.
Concept: Telegram's LoginActivity has 19 inner SlideView classes for its multi-step login wizard. We rewire three of them — PhoneView (phone input), LoginActivitySmsView (code entry), and LoginActivityPasswordView (PIN entry) — to call Signal's RegistrationRepository and RegistrationViewModel through a new SigramLoginBridge adapter.
Login flow:
IntroActivity → "Start Messaging" → LoginActivity
→ PhoneView → SigramLoginBridge.requestVerificationCode() → Signal session + SMS
→ CodeView → SigramLoginBridge.submitVerificationCode() → Signal code verify
→ PINView → SigramLoginBridge.submitPin() → SVR PIN unlock
→ onLoginComplete() → TLRPC.User from Signal data → UserConfig saved → MainTabsActivity
Signal backend initialization: SigramBridge.initialize() now initializes SQLCipher, SignalDatabase, SignalStore, and AppDependencies through typed Signal app APIs. Successful existing-account login now builds LocalRegistrationMetadata and calls Signal's local RegistrationRepository.registerAccountLocally(...).
Still pending: install the new APK on a real device/emulator, confirm login survives process death/restart, confirm app-private Signal databases are created, then verify a new post-login Signal 1:1 text thread can receive and send.
Current state: Official Signal endpoint login remains subject to upstream rate limits, but the app can now switch to the local dev server for development testing.
Goal: Show Signal conversations in Telegram's chat list with unread counts, timestamps, previews, archive, and folder filtering.
Implemented:
SigramThreadRepositoryboundary for reading Signal thread rows.SigramDialogRowDTOs andSigramDialogMapperfiltering/ordering.SigramMessagesController.getDialogs(...)Java-friendly chat-list API.- Existing Telegram
DialogsActivity,DialogsAdapter, andDialogCellnow accept Sigram rows without replacing Telegram's UI. NotificationCenter.dialogsNeedReloadtriggers Sigram chat-list reloads.- Existing Telegram long-press and swipe archive surfaces route Sigram rows to
SigramChatListStore. - Existing Telegram folder tabs map to All, Unread, Archive, and custom Sigram folder membership.
- Dev fixture conversations can be seeded and purged with
dev-server/seed-sigram-emulator.ps1. - Real arm64 device testing confirmed seeded Phase 2 rows render in Telegram's chat list.
Verified without login:
:app:testDebugUnitTest --tests org.sigram.bridge.SigramChatListStoreTest --tests org.sigram.bridge.SigramDialogMapperTest:app:assembleDebugadb install -r -d app/build/outputs/apk/debug/app-debug.apk- App launches as
org.sigram.messenger. - Crash log is empty after launch.
Still needs live-account testing:
- Confirm real Signal threads populate Telegram's
DialogsActivity. - Confirm title, preview, timestamp, unread count, and group/individual display are correct for real conversations.
- Confirm All hides archived conversations, Archive shows archived conversations, and Unread shows only unread unarchived conversations.
- Confirm archive/unarchive works from long-press action bar and configured swipe archive action.
- Confirm custom folder membership survives app restart and data-preserving APK reinstall.
- Confirm no crash log after navigating the logged-in chat-list screen.
Priority: Phase 4 starts by proving this same chat list against live Signal state, not seeded fixtures.
Goal: Send and receive 1:1 Signal text messages through Telegram's ChatActivity.
Implemented:
- Sigram message DTOs and mapping from Signal message rows into Telegram
MessageObject. - Reflection-based Sigram message repository boundary for loading messages, sending text, marking threads read, and sending typing state.
- Dev message fixture store for seeded Phase 3 message history.
SigramMessagesControllermessage APIs for Java UI code.DialogsActivityopens Sigram chat rows inChatActivity.ChatActivityloads Sigram text messages, bypasses Telegram message loading for Sigram chats, and observes Sigram reload notifications.ChatActivityEnterViewsends plain text through Sigram's Signal send boundary in Sigram mode.NotificationCenter.sigramMessagesNeedReload,sigramReceiptsChanged, andsigramTypingChangedrefresh open Sigram chats.- Dev fixture incoming messages can be injected with
dev-server/seed-sigram-emulator.ps1. - Incoming and outgoing typing indicators are bridged through Sigram controller/event APIs.
Fixture/dev testing:
- Seed local message fixtures with
.\dev-server\seed-sigram-emulator.ps1 -Serial <device-or-emulator>. - Inject an incoming fixture reply with
.\dev-server\seed-sigram-emulator.ps1 -Serial <device-or-emulator> -IncomingThreadId 910000 -IncomingBody "Fixture incoming reply". - This verifies Telegram chat UI loading, local outgoing append, incoming refresh, read state, typing callback plumbing, and chat-list preview refresh.
Still needs live backend verification:
- Install the current debug APK without clearing data.
- Confirm
SignalDatabase,SignalStore, andAppDependenciesinitialize on device withoutClassNotFoundExceptionorFATAL EXCEPTION. - Confirm successful login creates Signal local database files and registered state.
- Verify new 1:1 messages created after login. Historical Signal chats from another install are not expected to appear unless a Signal backup/transfer path is implemented.
- Confirm send, receive, read state, delivery state, and typing against another Signal user for new post-login messages.
Current blocker: local build/test proof is complete, emulator install/launch QA is complete, and app-private Signal database files are created. Live-message verification is still required before Phase 2/3 can be called live-complete. The latest APK includes a fix for the reported post-login crash/reset: Signal login now uses a Sigram-specific completion path, saves UserConfig synchronously, and does not run Telegram's old onAuthSuccess() network/controller side effects.
Goal: make Sigram testable as a normal Signal client without seeded fixture conversations.
Implemented:
LoginActivityroutes successful Signal login through a testable Sigram auth completer before navigation.SigramSignalRuntimestarts Signal message retrieval and the job loop after local account activation.ContactsActivityhas a Sigram phone-number start-chat action that opensChatActivitywith a Signal thread id.SigramRecipientRepositorynormalizes/validates phone numbers and resolves or creates Signal recipients/threads.dev-server/qa-sigram-live-client.ps1installs, launches, captures logcat/crash output, and records app-private files/databases/shared prefs.
Verified on 2026-06-13:
.\gradlew.bat :app:testDebugUnitTest --tests org.sigram.bridge.SigramTelegramAuthCompleterTest --tests org.sigram.bridge.SigramSignalRuntimeTest --tests org.sigram.bridge.SigramRecipientRepositoryTest.\gradlew.bat :app:compileDebugKotlin :app:compileDebugJavaWithJavac.\gradlew.bat :app:assembleDebug.\dev-server\qa-sigram-live-client.ps1 -Serial emulator-5554- QA bundle:
build\sigram-live-qa; install succeeded, launch succeeded, PID was captured, crash log had no fatal entries, andsignal-key-value.dbexisted in app-private databases.
Still pending: login into a usable real/dev-server account pair, create a 1:1 from the new phone action, send phase4 outbound, receive phase4 inbound, restart, and verify both messages plus chat-list preview persist without fixture data.
Sigram now runs as a real Signal client on the official Signal server (dev-server path retired). Login persists across restart and data-preserving reinstall. Text + media (photo/file) send works; reactions/replies/edits/deletes/timers/forwarding/group-create are wired. Receive is wired (persistent websocket, FCM disabled) but unverified (single test device). Known degradation: Telegram's native lib libtmessages.49.so is not built, so image/blur ops are guarded/skipped and some icons may be missing. Session handoff: docs/superpowers/plans/2026-06-14-session-handoff.md.
Goal: move Sigram 1:1 chats beyond plain text — replies, reactions, rich text, and (later) media — by enriching the existing message bridge, not replacing Telegram's UI.
Plan: docs/superpowers/plans/2026-06-14-phase-5-rich-conversations.md.
Every feature follows one shape: enrich SigramMessageRow → populate the Telegram MessageObject in SigramMessageMapper → add a verb on SigramMessageRepository (typed Signal APIs) → wire the existing Telegram affordance in Sigram mode → refresh via NotificationCenter.sigramMessagesNeedReload.
Implemented (compiles + bridge unit tests green; device verification pending):
-
Replies (5A): quote send + render. Telegram reply bar in Sigram mode → Signal
OutgoingMessagequote; incomingMmsMessageRecord.getQuote()→ Telegramreply_towith the quoted cell linked. -
Reactions (5A): add/remove/toggle + render. Telegram reaction picker → Signal
MessageSender.sendNewReaction/sendReactionRemoval;ReactionTablerows → TelegramTL_messageReactions. -
Formatting (5B): both directions — inbound Signal
BodyRangeList→ Telegram entities, and outbound Telegram input spans → SignalBodyRangeListon send (bold/italic/strike/mono/spoiler). -
Edit (5B): editing a Sigram message routes through the Signal bridge (
editMessage) instead of Telegram's edit request path. -
Edited indicator (5B): Signal revision number → Telegram
edit_date+ edited flag. -
Delete (5B): long-press delete dialog in Sigram mode → Signal delete-for-me (
SignalDatabase.messages.deleteMessage) / delete-for-everyone (MessageSender.sendRemoteDelete). -
Disappearing timers (5B, partial): peer-notifying timer set/get on the conversation, mirroring Signal's
ExpireTimerSettingsRepository(recipient timer bump +expirationUpdateMessagesend). The in-chat auto-delete callback is wired; the chat-header "Auto-Delete" entry point is still pending. -
Pinned messages (device-local): pin/unpin from the message menu + a chat-header "Pinned Messages" viewer that jumps to a message. Stored in
SigramPinStore(SharedPreferences) — Signal has no protocol pin, so pins are not synced to the peer. -
Scheduled messages (device-local): Telegram's send-button schedule picker is intercepted in
ChatActivity.onMessageSendand delivered byAlarmManager(with catch-up on app start) through the normal Signal send path; a chat-header "Scheduled Messages" viewer offers send-now/delete. Signal has no server-side scheduling, so this is a best-effort device-local mechanism (text only). Design doc:docs/superpowers/specs/2026-06-26-scheduled-and-pinned-messages.md. -
Media (5C, device-local pending verification): send photos/videos/files from Telegram's attach menu → Signal
UriAttachment+MessageSender.send; incomingMmsMessageRecord.getSlideDeck()slides are downloaded (AttachmentDownloadJob), copied to app cache, and mapped to TelegramTL_messageMediaPhoto/Documentfor cell + PhotoViewer rendering. Multi-attachment and captions supported; voice notes not yet wired. -
Group messaging (5C, device-local pending verification): Signal GV2 groups created from Telegram's New Group flow (
MessagesController.createChat→SigramGroupRepository.createGroup), listed/opened from the chat list, and send/receive text + media through the shared message path. Incoming group messages are attributed to the right sender —SigramMessageRow.authorTitle→MessageObject.customName+ a synthetic per-senderTLRPC.User, withsigram_is_groupdriving Telegram's group cell layout (avatars + names).
Pending (next sessions):
- Disappearing timers: wire the chat-header "Auto-Delete" entry point (the bridge/controller layer is done).
- Voice notes in Sigram chats; group member-management UI (add/remove/leave); group avatar in the chat header.
- Design doc for media + groups:
docs/superpowers/specs/2026-06-26-media-and-groups.md.
Verified: :app:compileDebugKotlin :app:compileDebugJavaWithJavac and :app:testDebugUnitTest (mapper/repository/controller tests) pass. Device cross-account test on emulator-5554 (+15551234701) / emulator-5556 (+15551234702) still pending per the test-last workflow.
- Telegram Android: GPL v2 "or later" — forward-compatible with GPL v3 / AGPL v3
- Signal Android: AGPL v3
- Sigram: AGPL v3 (combined work)
Both source projects are open source. Telegram's "or later" clause allows upgrading to GPL v3 which is explicitly compatible with AGPL v3 per Section 13 of the AGPL.
sigram/
├── app/ # Main Sigram app module
│ └── src/main/java/
│ ├── org/telegram/ # Telegram UI (kept from fork)
│ │ ├── ui/LoginActivity.java # Login wizard — rewired to Signal
│ │ ├── ui/IntroActivity.java # Welcome screen
│ │ ├── ui/LaunchActivity.java # App router
│ │ └── messenger/ # Utilities (AndroidUtilities, UserConfig, etc.)
│ ├── org/sigram/ # Sigram bridge layer
│ │ ├── bridge/SigramBridge.kt # Signal backend init
│ │ ├── bridge/SigramLoginBridge.kt # Login flow adapter
│ │ ├── config/SigramBuildConfig.kt # Signal server config
│ │ └── SigramApplication.kt # App entry point
│ └── org/thoughtcrime/securesms/ # Signal app backend packaged via :signal-app-core
├── core/ # Signal core modules
├── lib/ # Signal library modules
├── feature/ # Signal feature modules
├── telegram-client/ # Cloned Telegram Android (reference)
├── signal-client/ # Cloned Signal Android (reference)
├── docs/
│ └── superpowers/
│ ├── specs/ # Design specifications
│ └── plans/ # Implementation plans
└── README.md
# Build debug APK
./gradlew :app:assembleDebug
# Install on connected device/emulator
./gradlew :app:installDebug
# Launch
adb shell am start -n org.sigram.messenger/org.telegram.messenger.DefaultIconRequirements: JDK 17, Android SDK (compileSdk android-36, minSdk 23), Gradle 8.x
Branch: codex/phase-4-live-client-stabilization.
Phase 4 is in live-client debugging, not complete. The latest APK known to have built and been installed is app\build\outputs\apk\debug\app-debug.apk from 2026-06-13 21:12:49. That APK includes the typed Signal text send path and the ProfileActivity crash guard, but it does not include the latest manifest receive-service declarations, the Sigram account profile screen, or the self-message guard added afterward.
Two local dev-server accounts exist on the two emulators:
| Emulator | Account |
|---|---|
emulator-5554 |
+15551234701 |
emulator-5556 |
+15551234702 |
Observed live/dev-server test result:
- Dev-server login and account creation worked.
- Starting a 1:1 chat by phone number works enough to create a thread.
- The original send invocation error was caused by reflective
OutgoingMessageconstruction. The send path now uses typed Signal APIs. - Receive on the second emulator did not complete. Logcat showed Signal tried to start
org.thoughtcrime.securesms.messages.IncomingMessageObserver$ForegroundService, but the service was not declared in the app manifest. - The profile tab was blank because Telegram's
ProfileActivityhas no Signal account model. The working tree now routes registered Signal accounts to a Sigram account screen, but that code has not been built into an APK yet. - The first emulator opened a chat with its own number during manual testing. The working tree now guards against starting a self-chat by entered phone number, but that code has not been built into an APK yet.
Current working tree contains unverified code changes in AndroidManifest.xml, SigramApplication.kt, SigramAccountStore.kt, SigramBridge.kt, SigramMessageRepository.kt, SigramSignalLoginClient.kt, SigramSignalRuntime.kt, ContactsActivity.java, MainTabsActivity.java, ProfileActivity.java, signal-client, plus new files under app\src\main\java\org\sigram\ui, app\src\test\java\org\sigram\bridge, and dev-server.
Next blank-session checklist:
git status --short --branch
Get-CimInstance Win32_Process -Filter "name='java.exe'" | Where-Object {$_.CommandLine -like '*gradle*'}
.\gradlew.bat :app:assembleDebug --console=plain --no-daemon --max-workers=1
adb -s emulator-5554 install -r app\build\outputs\apk\debug\app-debug.apk
adb -s emulator-5556 install -r app\build\outputs\apk\debug\app-debug.apkThen test only cross-account messaging:
- On
emulator-5554(+15551234701), start a chat with+15551234702. - On
emulator-5556(+15551234702), start a chat with+15551234701. - Do not test by entering the account's own phone number.
Useful receive-path log filter:
adb -s emulator-5556 logcat -d -v time | Select-String -Pattern "IncomingMessageObserver|ForegroundService|WebSocket|Retrieved|FATAL|MessageSender|IndividualSendJob"- Telegram Android — UI source
- Signal Android — Backend source
- Signal Protocol — Protocol documentation
- libsignal — Crypto library
- RingRTC — Calling library