Compare commits
5 Commits
fb37ca747a
...
1c51df039f
| Author | SHA1 | Date |
|---|---|---|
evgeny
|
1c51df039f | 24 hours ago |
|
evgeny
|
9e3a417059 | 1 day ago |
|
evgeny
|
e914a1bdc1 | 1 day ago |
|
evgeny
|
b36c685cfa | 1 day ago |
|
evgeny
|
3c5c9604b3 | 1 day ago |
32 changed files with 1406 additions and 714 deletions
@ -0,0 +1,180 @@ |
|||||||
|
/* Проверка режима и фаз standby на реальных keepalive-пакетах до шифрования.
|
||||||
|
* Управляемая отправка исключает сеть; отказ таймера проверяет сохранение рабочего режима. */ |
||||||
|
#include <assert.h> |
||||||
|
#include <string.h> |
||||||
|
#include "utun_instance.h" |
||||||
|
#include "etcp.h" |
||||||
|
#include "etcp_keepalive.h" |
||||||
|
#include "standby.h" |
||||||
|
#include "debug_config.h" |
||||||
|
|
||||||
|
static struct UASYNC* ua; |
||||||
|
static struct UTUN_INSTANCE inst; |
||||||
|
static struct ETCP_CONN udp, tcp; |
||||||
|
static struct ETCP_LINK links[3]; |
||||||
|
static struct ll_queue udp_queue, tcp_queue; |
||||||
|
static struct ll_entry *udp_entry, *tcp_entry; |
||||||
|
static struct { unsigned count; uint8_t flags; uint16_t active, sleep; } sent[3]; |
||||||
|
static int fail_phase_timer, activity_events, wait_calls; |
||||||
|
static unsigned wait_after_packets; |
||||||
|
|
||||||
|
/* Перехватывает сформированный keepalive, сохраняя его реальные флаги и тайминг. */ |
||||||
|
int __wrap_etcp_encrypt_send(struct ETCP_DGRAM* pkt) { |
||||||
|
assert(pkt && pkt->data[0] == ETCP_KEEPALIVE && pkt->data_len >= 4); |
||||||
|
int i; |
||||||
|
for (i = 0; i < 3 && pkt->link != &links[i]; i++); |
||||||
|
assert(i < 3); |
||||||
|
sent[i].count++; |
||||||
|
sent[i].flags = pkt->data[1]; |
||||||
|
sent[i].active = pkt->data_len >= 6 ? pkt->data[4] | ((uint16_t)pkt->data[5] << 8) : 0; |
||||||
|
sent[i].sleep = pkt->data_len >= 8 ? pkt->data[6] | ((uint16_t)pkt->data[7] << 8) : 0; |
||||||
|
return pkt->data_len; |
||||||
|
} |
||||||
|
|
||||||
|
void* __real_uasync_set_timeout(struct UASYNC* ua, int tb, void* arg, timeout_callback_t cb, const char* name); |
||||||
|
|
||||||
|
/* Отказывает только фазовому таймеру, остальные таймеры выполняются настоящим uasync. */ |
||||||
|
void* __wrap_uasync_set_timeout(struct UASYNC* loop, int tb, void* arg, timeout_callback_t cb, const char* name) { |
||||||
|
if (fail_phase_timer && name && !strcmp(name, "standby_phase")) { |
||||||
|
DEBUG_WARN(DEBUG_CATEGORY_GENERAL, "[TEST] injected standby phase timer failure"); |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
return __real_uasync_set_timeout(loop, tb, arg, cb, name); |
||||||
|
} |
||||||
|
|
||||||
|
/* Подписчики активности видят уже согласованные режимы, без промежуточного состояния. */ |
||||||
|
static void activity_changed(struct UTUN_INSTANCE* owner, int active, void* arg) { |
||||||
|
(void)arg; |
||||||
|
assert(owner == &inst && inst.client_activity == active); |
||||||
|
assert(standby_is_enabled() == !active); |
||||||
|
for (int i = 0; i < 3; i++) assert(links[i].ka_my_sleeping == !active); |
||||||
|
activity_events++; |
||||||
|
} |
||||||
|
|
||||||
|
/* Работа возобновляется после отправки новой фазы пирам или выхода из standby. */ |
||||||
|
static void waited(void* arg) { |
||||||
|
(void)arg; |
||||||
|
assert(sent[0].count > wait_after_packets); |
||||||
|
if (standby_is_enabled()) { |
||||||
|
assert(standby_get_active_remaining_tb() > 0 && sent[0].flags == KA_FLAG_SLEEP && sent[0].active > 0); |
||||||
|
} else { |
||||||
|
assert(inst.client_activity == CLIENT_ACTIVITY_ACTIVE && !links[0].ka_my_sleeping && sent[0].flags == 0); |
||||||
|
} |
||||||
|
wait_calls++; |
||||||
|
} |
||||||
|
|
||||||
|
/* Мобильный узел с исходящим UDP, входящим UDP и TCP линками. */ |
||||||
|
static void setup(void) { |
||||||
|
ua = uasync_create(); assert(ua); |
||||||
|
memset(&inst, 0, sizeof(inst)); memset(&udp, 0, sizeof(udp)); memset(&tcp, 0, sizeof(tcp)); |
||||||
|
memset(links, 0, sizeof(links)); memset(sent, 0, sizeof(sent)); |
||||||
|
activity_events = wait_calls = fail_phase_timer = 0; |
||||||
|
inst.ua = ua; inst.client_type = CLIENT_TYPE_MOBILE; inst.client_activity = CLIENT_ACTIVITY_STANDBY; |
||||||
|
udp.instance = tcp.instance = &inst; |
||||||
|
strcpy(udp.log_name, "standby-test-udp"); strcpy(tcp.log_name, "standby-test-tcp"); |
||||||
|
for (int i = 0; i < 3; i++) { |
||||||
|
links[i].etcp = i == 2 ? &tcp : &udp; |
||||||
|
links[i].local_link_id = i + 1; links[i].initialized = links[i].link_status = 1; |
||||||
|
links[i].keepalive_interval = links[i].ka_period_ms = 2000; |
||||||
|
links[i].keepalive_timeout = 20000; links[i].last_recv_local_time = get_time_tb(); |
||||||
|
} |
||||||
|
links[0].next = &links[1]; links[1].is_server = 1; links[2].is_tcp = 1; |
||||||
|
udp.links = &links[0]; tcp.links = &links[2]; |
||||||
|
udp_entry = queue_entry_new(sizeof(struct conn_queue_entry)); assert(udp_entry); |
||||||
|
tcp_entry = queue_entry_new(sizeof(struct tcp_conn_entry)); assert(tcp_entry); |
||||||
|
((struct conn_queue_entry*)udp_entry->data)->conn = &udp; |
||||||
|
((struct tcp_conn_entry*)tcp_entry->data)->etcp_conn = &tcp; |
||||||
|
memset(&udp_queue, 0, sizeof(udp_queue)); memset(&tcp_queue, 0, sizeof(tcp_queue)); |
||||||
|
udp_queue.head = udp_entry; tcp_queue.head = tcp_entry; |
||||||
|
inst.connections = &udp_queue; inst.tcp_connections = &tcp_queue; |
||||||
|
standby_set_intervals_ms(200, 300, 0); |
||||||
|
standby_init(ua); etcp_keepalive_register(&inst); |
||||||
|
utun_add_activity_cbk(&inst, activity_changed, NULL); |
||||||
|
for (int i = 0; i < 3; i++) etcp_keepalive_link_ready(&links[i]); |
||||||
|
} |
||||||
|
|
||||||
|
/* Отменяет таймеры и подписки перед повторной инициализацией ядра. */ |
||||||
|
static void teardown(void) { |
||||||
|
standby_deinit(); |
||||||
|
for (int i = 0; i < 3; i++) { |
||||||
|
if (links[i].keepalive_timer) uasync_cancel_timeout(ua, links[i].keepalive_timer); |
||||||
|
if (links[i].ka_sleep_announce_timer) uasync_cancel_timeout(ua, links[i].ka_sleep_announce_timer); |
||||||
|
} |
||||||
|
while (inst.activity_cbks) utun_remove_activity_cbk(&inst, inst.activity_cbks->fn, inst.activity_cbks->arg); |
||||||
|
queue_entry_free(udp_entry); queue_entry_free(tcp_entry); |
||||||
|
uasync_poll(ua, 0); |
||||||
|
assert(ua->timer_alloc_count == ua->timer_free_count); |
||||||
|
uasync_destroy(ua, 0); |
||||||
|
} |
||||||
|
|
||||||
|
/* Первый фон при начальном STANDBY, повторы, новые линки, обе причины wake и выход в ACTIVE. */ |
||||||
|
static void check_transitions(void) { |
||||||
|
setup(); |
||||||
|
assert(!standby_is_enabled()); |
||||||
|
for (int i = 0; i < 3; i++) assert(sent[i].count == 1 && sent[i].flags == 0 && links[i].keepalive_timer); |
||||||
|
assert(utun_set_client_activity(&inst, 0) == 0 && standby_is_enabled() && activity_events == 0); |
||||||
|
for (int i = 0; i < 3; i++) { |
||||||
|
assert(links[i].ka_my_sleeping && !links[i].keepalive_timer); |
||||||
|
assert(sent[i].count == 2 && sent[i].flags == KA_FLAG_SLEEP && sent[i].active > 0 && sent[i].sleep == 3); |
||||||
|
} |
||||||
|
uint64_t timers = ua->timer_alloc_count; |
||||||
|
assert(utun_set_client_activity(&inst, 0) == 0 && ua->timer_alloc_count == timers); |
||||||
|
assert(sent[0].count == 2 && sent[1].count == 2 && sent[2].count == 2); |
||||||
|
uasync_poll(ua, -1); assert(standby_get_sleep_tb() > 0); |
||||||
|
for (int i = 0; i < 3; i++) { |
||||||
|
etcp_keepalive_link_ready(&links[i]); |
||||||
|
assert(sent[i].flags == KA_FLAG_SLEEP && sent[i].active == 0 && sent[i].sleep > 0 && !links[i].keepalive_timer); |
||||||
|
} |
||||||
|
assert(links[0].ka_sleep_announce_timer && links[1].ka_sleep_announce_timer && !links[2].ka_sleep_announce_timer); |
||||||
|
timers = ua->timer_alloc_count; wait_after_packets = sent[0].count; |
||||||
|
assert(standby_wait(NULL, waited)); assert(ua->timer_alloc_count == timers); |
||||||
|
fail_phase_timer = 1; |
||||||
|
standby_notify_network_activity(); |
||||||
|
assert(standby_get_sleep_tb() > 0 && wait_calls == 0 && sent[0].count == wait_after_packets); |
||||||
|
fail_phase_timer = 0; |
||||||
|
standby_notify_network_activity(); assert(wait_calls == 1); |
||||||
|
uasync_poll(ua, -1); assert(standby_get_sleep_tb() > 0); |
||||||
|
wait_after_packets = sent[0].count; |
||||||
|
void* cancelled = standby_wait(NULL, waited); assert(cancelled); |
||||||
|
standby_wait_cancel(cancelled); |
||||||
|
assert(standby_wait(NULL, waited)); |
||||||
|
uasync_poll(ua, -1); assert(wait_calls == 2 && standby_get_active_remaining_tb() > 0); |
||||||
|
uasync_poll(ua, -1); assert(standby_get_sleep_tb() > 0); |
||||||
|
wait_after_packets = sent[0].count; assert(standby_wait(NULL, waited)); |
||||||
|
links[0].ka_peer_sleeping = 1; |
||||||
|
assert(utun_set_client_activity(&inst, 1) == 0 && activity_events == 1 && wait_calls == 3); |
||||||
|
for (int i = 0; i < 3; i++) { |
||||||
|
assert(!links[i].ka_my_sleeping && sent[i].flags == 0 && !links[i].ka_sleep_announce_timer); |
||||||
|
} |
||||||
|
assert(!links[0].keepalive_timer && links[1].keepalive_timer && links[2].keepalive_timer); |
||||||
|
timers = ua->timer_alloc_count; unsigned packets = sent[0].count; |
||||||
|
assert(utun_set_client_activity(&inst, 1) == 0 && ua->timer_alloc_count == timers); |
||||||
|
assert(activity_events == 1 && sent[0].count == packets); |
||||||
|
assert(utun_set_client_activity(&inst, 0) == 0 && activity_events == 2); |
||||||
|
teardown(); |
||||||
|
DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "[PASS] first background, repeated commands, UDP/TCP ready, phase-before-work, peer sleep and cleanup"); |
||||||
|
} |
||||||
|
|
||||||
|
/* Ошибка ENTER сохраняет normal; потеря фазового таймера возвращает normal, без зависания сна. */ |
||||||
|
static void check_timer_failures(void) { |
||||||
|
setup(); assert(utun_set_client_activity(&inst, 1) == 0); |
||||||
|
fail_phase_timer = 1; |
||||||
|
assert(utun_set_client_activity(&inst, 0) < 0); |
||||||
|
assert(inst.client_activity == CLIENT_ACTIVITY_ACTIVE && !standby_is_enabled() && activity_events == 1); |
||||||
|
for (int i = 0; i < 3; i++) assert(!links[i].ka_my_sleeping && links[i].keepalive_timer); |
||||||
|
fail_phase_timer = 0; |
||||||
|
assert(utun_set_client_activity(&inst, 0) == 0); |
||||||
|
fail_phase_timer = 1; |
||||||
|
uasync_poll(ua, -1); |
||||||
|
assert(!standby_is_enabled() && inst.client_activity == CLIENT_ACTIVITY_ACTIVE && activity_events == 3); |
||||||
|
for (int i = 0; i < 3; i++) assert(!links[i].ka_my_sleeping && links[i].keepalive_timer); |
||||||
|
fail_phase_timer = 0; teardown(); |
||||||
|
DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "[PASS] timer failure rollback and safe normal fallback"); |
||||||
|
} |
||||||
|
|
||||||
|
int main(void) { |
||||||
|
debug_config_init(); debug_set_level(DEBUG_LEVEL_INFO); |
||||||
|
check_transitions(); check_transitions(); check_timer_failures(); |
||||||
|
DEBUG_INFO(DEBUG_CATEGORY_KEEPALIVE, "PASS: standby transport regression tests"); |
||||||
|
return 0; |
||||||
|
} |
||||||
@ -0,0 +1,358 @@ |
|||||||
|
package com.utun.chat.data |
||||||
|
|
||||||
|
import android.content.Intent |
||||||
|
import android.os.Looper |
||||||
|
import android.os.SystemClock |
||||||
|
import com.utun.chat.ChatApplication |
||||||
|
import com.utun.chat.MainActivity |
||||||
|
import kotlinx.coroutines.CoroutineScope |
||||||
|
import kotlinx.coroutines.Dispatchers |
||||||
|
import kotlinx.coroutines.SupervisorJob |
||||||
|
import kotlinx.coroutines.delay |
||||||
|
import kotlinx.coroutines.flow.MutableStateFlow |
||||||
|
import kotlinx.coroutines.flow.StateFlow |
||||||
|
import kotlinx.coroutines.launch |
||||||
|
import java.nio.ByteBuffer |
||||||
|
import java.nio.ByteOrder |
||||||
|
|
||||||
|
/** |
||||||
|
* Единственный владелец звонковой сессии в процессе приложения. Все операции — main thread. |
||||||
|
* Сервис владеет аудио и wake lock, ядро — сигналингом, ViewModel только читает StateFlow. |
||||||
|
* События поступают напрямую из AppEventHandler без replay старых звонков новым подписчикам. |
||||||
|
*/ |
||||||
|
object CallController : TelecomCallManager.Listener { |
||||||
|
private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) |
||||||
|
private val _state = MutableStateFlow<CallState?>(null) |
||||||
|
val state: StateFlow<CallState?> = _state |
||||||
|
private val _muted = MutableStateFlow(false) |
||||||
|
val muted: StateFlow<Boolean> = _muted |
||||||
|
private val _route = MutableStateFlow(AudioRoute.SPEAKER) |
||||||
|
val route: StateFlow<AudioRoute> = _route |
||||||
|
private val _headset = MutableStateFlow(false) |
||||||
|
val headset: StateFlow<Boolean> = _headset |
||||||
|
private val _earpiece = MutableStateFlow(true) |
||||||
|
val earpiece: StateFlow<Boolean> = _earpiece |
||||||
|
private val proximity = ProximityManager(ChatApplication.instance) |
||||||
|
val proximityNear: StateFlow<Boolean> = proximity.near |
||||||
|
|
||||||
|
private var service: CallService? = null |
||||||
|
private var serviceRequested = false |
||||||
|
private var accepting = false |
||||||
|
private var acceptSent = false |
||||||
|
private var answerWhenVisible = 0L |
||||||
|
private var activityVisible = false |
||||||
|
private var coreReady = false |
||||||
|
private var incomingAt = 0L |
||||||
|
private var initialized = false |
||||||
|
|
||||||
|
fun init() { |
||||||
|
checkMain() |
||||||
|
if (initialized) return |
||||||
|
initialized = true |
||||||
|
TelecomCallManager.setListener(this) |
||||||
|
scope.launch { |
||||||
|
while (true) { |
||||||
|
delay(500) |
||||||
|
val st = _state.value ?: continue |
||||||
|
val now = SystemClock.elapsedRealtime() |
||||||
|
if (st.phase == CallPhase.ACTIVE) { |
||||||
|
_state.value = st.copy(durationSeconds = ((now - st.startedAtElapsedRealtime) / 1000).toInt()) |
||||||
|
} else if (st.phase == CallPhase.INCOMING && now - incomingAt > 50_000) { |
||||||
|
LogManager.addLog("WARN", "Call", "incoming timeout id=${st.callId}; declining") |
||||||
|
end(st.callId) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
LogManager.addLog("INFO", "Call", "controller initialized; session independent of UI") |
||||||
|
} |
||||||
|
|
||||||
|
fun setActivityVisible(visible: Boolean) { |
||||||
|
checkMain() |
||||||
|
activityVisible = visible |
||||||
|
syncCoreActivity() |
||||||
|
if (visible && answerWhenVisible != 0L) { |
||||||
|
val id = answerWhenVisible |
||||||
|
answerWhenVisible = 0L |
||||||
|
if (_state.value?.callId == id && _state.value?.phase == CallPhase.INCOMING) accept() |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private fun syncCoreActivity() { |
||||||
|
val ongoing = _state.value?.ongoing == true |
||||||
|
val active = activityVisible || ongoing |
||||||
|
LogManager.addLog("INFO", "Call", "core activity=$active visible=$activityVisible call=$ongoing") |
||||||
|
if (coreReady && NativeLib.isReady()) NativeLib.setActive(active) |
||||||
|
} |
||||||
|
|
||||||
|
fun start(channelId: String, peerNodeId: Long, peerName: String) { |
||||||
|
checkMain() |
||||||
|
if (channelId.isEmpty() || peerNodeId == 0L) { |
||||||
|
LogManager.addLog("ERROR", "Call", "invalid outgoing call channel=$channelId peer=$peerNodeId") |
||||||
|
return |
||||||
|
} |
||||||
|
if (_state.value?.ongoing == true || !coreReady || !NativeLib.isReady()) { |
||||||
|
LogManager.addLog("WARN", "Call", "start rejected: busy=${_state.value?.ongoing} core=$coreReady native=${NativeLib.isReady()}") |
||||||
|
return |
||||||
|
} |
||||||
|
var id = java.security.SecureRandom().nextLong() |
||||||
|
if (id == 0L) id = 1 |
||||||
|
_state.value = CallState(id, channelId, peerNodeId, peerName.ifEmpty { "0x%016x".format(peerNodeId) }, CallPhase.OUTGOING) |
||||||
|
syncCoreActivity() |
||||||
|
requestService(id) |
||||||
|
} |
||||||
|
|
||||||
|
fun accept() { |
||||||
|
checkMain() |
||||||
|
val st = _state.value ?: return |
||||||
|
if (st.phase != CallPhase.INCOMING || accepting) { |
||||||
|
LogManager.addLog("WARN", "Call", "accept ignored id=${st.callId} phase=${st.phase} accepting=$accepting") |
||||||
|
return |
||||||
|
} |
||||||
|
accepting = true |
||||||
|
requestService(st.callId) |
||||||
|
} |
||||||
|
|
||||||
|
private fun requestService(id: Long) { |
||||||
|
serviceRequested = true |
||||||
|
try { |
||||||
|
CallService.start(ChatApplication.instance, id) |
||||||
|
} catch (e: Exception) { |
||||||
|
LogManager.addLog("ERROR", "Call", "service request failed id=$id: ${e.message}") |
||||||
|
end(id, 7) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** Вызывается сервисом после startForeground и приобретения wake lock, до запуска сигналинга/микрофона. */ |
||||||
|
fun serviceReady(id: Long, owner: CallService): Boolean { |
||||||
|
checkMain() |
||||||
|
val st = _state.value |
||||||
|
if (st == null || st.callId != id || !st.ongoing || !serviceRequested) { |
||||||
|
LogManager.addLog("WARN", "Call", "discard stale service start id=$id current=${st?.callId}") |
||||||
|
return false |
||||||
|
} |
||||||
|
if (service != null) { |
||||||
|
if (service !== owner) LogManager.addLog("ERROR", "Call", "service owner conflict id=$id") |
||||||
|
return service === owner |
||||||
|
} |
||||||
|
service = owner |
||||||
|
LogManager.addLog("INFO", "Call", "service ready id=$id phase=${st.phase}") |
||||||
|
if (st.phase == CallPhase.OUTGOING) { |
||||||
|
NativeLib.callStart(st.channelId, st.peerNodeId, id) |
||||||
|
TelecomCallManager.placeCall(id, st.peerNodeId, st.peerName) |
||||||
|
CallRingback.startConnecting() |
||||||
|
} else if (st.phase == CallPhase.INCOMING && accepting) { |
||||||
|
IncomingCallManager.stopRinging() |
||||||
|
acceptSent = true |
||||||
|
NativeLib.callAccept(id) |
||||||
|
} |
||||||
|
return true |
||||||
|
} |
||||||
|
|
||||||
|
fun wantsService(id: Long): Boolean = _state.value?.let { it.callId == id && it.ongoing && serviceRequested } == true |
||||||
|
|
||||||
|
fun serviceLost(id: Long, owner: CallService) { |
||||||
|
checkMain() |
||||||
|
if (service !== owner) return |
||||||
|
service = null |
||||||
|
LogManager.addLog("ERROR", "Call", "service destroyed during call id=$id") |
||||||
|
end(id, 7) |
||||||
|
} |
||||||
|
|
||||||
|
fun audioFailed(id: Long, detail: String) { |
||||||
|
checkMain() |
||||||
|
if (_state.value?.callId != id || _state.value?.ongoing != true) return |
||||||
|
LogManager.addLog("ERROR", "Call", "audio failed id=$id: $detail") |
||||||
|
end(id, 7) |
||||||
|
} |
||||||
|
|
||||||
|
/** Завершение из UI, Telecom и уведомления; идентификатор защищает от действий старого звонка. */ |
||||||
|
fun end(id: Long = _state.value?.callId ?: 0L, reason: Int = 0) { |
||||||
|
checkMain() |
||||||
|
val st = _state.value ?: return |
||||||
|
if (st.callId != id || !st.ongoing) { |
||||||
|
LogManager.addLog("WARN", "Call", "end ignored id=$id current=${st.callId} phase=${st.phase}") |
||||||
|
return |
||||||
|
} |
||||||
|
if (NativeLib.isReady()) { |
||||||
|
if (st.phase == CallPhase.INCOMING && !acceptSent) NativeLib.callDecline(id) else NativeLib.callHangup(id) |
||||||
|
} |
||||||
|
finish(id, reason) |
||||||
|
} |
||||||
|
|
||||||
|
private fun finish(id: Long, reason: Int) { |
||||||
|
val st = _state.value ?: return |
||||||
|
if (st.callId != id || !st.ongoing) return |
||||||
|
val owner = service |
||||||
|
service = null |
||||||
|
serviceRequested = false |
||||||
|
accepting = false |
||||||
|
acceptSent = false |
||||||
|
answerWhenVisible = 0L |
||||||
|
owner?.shutdown() |
||||||
|
proximity.stop() |
||||||
|
TelecomCallManager.setDisconnected(id, reason) |
||||||
|
TelecomCallManager.removeConnection(id) |
||||||
|
CallRingback.stop() |
||||||
|
IncomingCallManager.stopRinging() |
||||||
|
_muted.value = false |
||||||
|
_route.value = AudioRoute.SPEAKER |
||||||
|
_headset.value = false |
||||||
|
_earpiece.value = true |
||||||
|
_state.value = st.copy(phase = CallPhase.ENDED, reason = reason) |
||||||
|
syncCoreActivity() |
||||||
|
LogManager.addLog("INFO", "Call", "finished id=$id reason=$reason; audio/service/proximity released") |
||||||
|
scope.launch { |
||||||
|
delay(2500) |
||||||
|
if (_state.value?.callId == id && _state.value?.phase == CallPhase.ENDED) _state.value = null |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
fun dismiss() { |
||||||
|
checkMain() |
||||||
|
if (_state.value?.ongoing == true) end() |
||||||
|
_state.value = null |
||||||
|
} |
||||||
|
|
||||||
|
/** Перед stop/restart ядра освобождаем аудио, чтобы workers больше не обращались к native-ресурсам. */ |
||||||
|
fun reset() { |
||||||
|
checkMain() |
||||||
|
coreReady = false |
||||||
|
end() |
||||||
|
_state.value = null |
||||||
|
} |
||||||
|
|
||||||
|
fun toggleMute() { |
||||||
|
checkMain() |
||||||
|
val audio = service?.audio ?: return |
||||||
|
if (!audio.isActive()) return |
||||||
|
audio.setMuted(!audio.isMuted()) |
||||||
|
_muted.value = audio.isMuted() |
||||||
|
} |
||||||
|
|
||||||
|
fun setRoute(route: AudioRoute) { |
||||||
|
checkMain() |
||||||
|
service?.audio?.router?.setRoute(route) |
||||||
|
_state.value?.let { TelecomCallManager.setRoute(it.callId, route) } |
||||||
|
scope.launch { ChatApplication.instance.configProvider.setCallAudioRoute(route) } |
||||||
|
} |
||||||
|
|
||||||
|
private fun routeChanged(route: AudioRoute, headset: Boolean) { |
||||||
|
_route.value = route |
||||||
|
_headset.value = headset |
||||||
|
if (route == AudioRoute.EARPIECE && _state.value?.phase == CallPhase.ACTIVE) proximity.start() else proximity.stop() |
||||||
|
service?.audio?.syncAecForRoute(route) |
||||||
|
} |
||||||
|
|
||||||
|
/** Только живые события ядра, сериализованные AppEventHandler на main thread. */ |
||||||
|
fun onEvent(type: Int, data: ByteArray?) { |
||||||
|
checkMain() |
||||||
|
if (type == 12) { |
||||||
|
coreReady = NativeLib.isReady() |
||||||
|
syncCoreActivity() |
||||||
|
LogManager.addLog("INFO", "Call", "core started ready=$coreReady") |
||||||
|
return |
||||||
|
} |
||||||
|
if (type == 13) { reset(); return } |
||||||
|
if (type !in 34..40 && type != 42) return |
||||||
|
if (!coreReady || !NativeLib.isReady()) { |
||||||
|
LogManager.addLog("WARN", "Call", "ignore event=$type while core stopped/restarting") |
||||||
|
return |
||||||
|
} |
||||||
|
if (type == 34) { |
||||||
|
if (data == null || data.size < 17) { badEvent(type, data); return } |
||||||
|
val len = data[0].toInt() and 0xFF |
||||||
|
if (len == 0 || data.size < 17 + len) { badEvent(type, data); return } |
||||||
|
val channel = String(data, 1, len) |
||||||
|
val buf = ByteBuffer.wrap(data, 1 + len, 16).order(ByteOrder.LITTLE_ENDIAN) |
||||||
|
val peer = buf.long |
||||||
|
val id = buf.long |
||||||
|
if (peer == 0L || id == 0L) { badEvent(type, data); return } |
||||||
|
val current = _state.value |
||||||
|
if (current?.callId == id) return |
||||||
|
if (current?.ongoing == true) { |
||||||
|
LogManager.addLog("WARN", "Call", "busy; decline incoming id=$id current=${current.callId}") |
||||||
|
NativeLib.callDecline(id) |
||||||
|
return |
||||||
|
} |
||||||
|
incomingAt = SystemClock.elapsedRealtime() |
||||||
|
// Однократное чтение на main завершается до reset; фоновый JNI-запрос не переживает ядро. |
||||||
|
val name = ChatRepository().getMembers(channel).firstOrNull { it.nodeId == peer }?.name |
||||||
|
?.takeIf { it.isNotEmpty() } ?: "0x%016x".format(peer) |
||||||
|
_state.value = CallState(id, channel, peer, name, CallPhase.INCOMING) |
||||||
|
syncCoreActivity() |
||||||
|
IncomingCallManager.show(id, channel, peer) |
||||||
|
TelecomCallManager.addIncomingCall(id, peer, name) |
||||||
|
return |
||||||
|
} |
||||||
|
if (data == null || data.size < 8 || ((type == 37 || type == 38 || type == 40 || type == 42) && data.size < 9) || |
||||||
|
(type == 39 && data.size != 24)) { badEvent(type, data); return } |
||||||
|
val id = ByteBuffer.wrap(data, 0, 8).order(ByteOrder.LITTLE_ENDIAN).long |
||||||
|
val st = _state.value |
||||||
|
if (st == null || st.callId != id || !st.ongoing) { |
||||||
|
LogManager.addLog("DEBUG", "Call", "ignore event=$type id=$id current=${st?.callId} phase=${st?.phase}") |
||||||
|
return |
||||||
|
} |
||||||
|
when (type) { |
||||||
|
35 -> if (st.phase == CallPhase.OUTGOING) { |
||||||
|
_state.value = st.copy(phase = CallPhase.RINGING) |
||||||
|
CallRingback.startRinging() |
||||||
|
service?.updateNotification() |
||||||
|
} |
||||||
|
36 -> { |
||||||
|
if (st.phase == CallPhase.ACTIVE) return |
||||||
|
val owner = service |
||||||
|
if (owner == null || !owner.startAudio(id)) { |
||||||
|
LogManager.addLog("ERROR", "Call", "accepted without working audio/service id=$id") |
||||||
|
end(id, 7) |
||||||
|
return |
||||||
|
} |
||||||
|
accepting = false |
||||||
|
CallRingback.stop() |
||||||
|
IncomingCallManager.stopRinging() |
||||||
|
TelecomCallManager.setActive(id) |
||||||
|
_state.value = st.copy(phase = CallPhase.ACTIVE, durationSeconds = 0, startedAtElapsedRealtime = SystemClock.elapsedRealtime()) |
||||||
|
owner.audio.router.onChanged = { route, headset -> routeChanged(route, headset) } |
||||||
|
_earpiece.value = owner.audio.router.hasEarpiece |
||||||
|
routeChanged(owner.audio.router.route, owner.audio.router.headsetAvailable) |
||||||
|
owner.updateNotification() |
||||||
|
LogManager.addLog("INFO", "Call", "active id=$id; service owns audio and CPU wake lock") |
||||||
|
} |
||||||
|
37, 38 -> finish(id, data[8].toInt() and 0xFF) |
||||||
|
40 -> { |
||||||
|
LogManager.addLog("ERROR", "Call", "native error id=$id code=${data[8]} ${String(data, 9, data.size - 9)}") |
||||||
|
finish(id, 7) |
||||||
|
} |
||||||
|
39 -> if (st.phase == CallPhase.ACTIVE) { |
||||||
|
val buf = ByteBuffer.wrap(data, 8, 16).order(ByteOrder.BIG_ENDIAN) |
||||||
|
fun metric() = buf.short.toInt() and 0xFFFF |
||||||
|
_state.value = st.copy(stats = CallStats(metric(), metric(), metric(), metric(), metric(), metric(), metric(), metric())) |
||||||
|
} |
||||||
|
42 -> _state.value = st.copy(bgpPath = String(data, 8, data.size - 8)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private fun badEvent(type: Int, data: ByteArray?) { |
||||||
|
LogManager.addLog("WARN", "Call", "invalid event=$type size=${data?.size ?: 0}") |
||||||
|
} |
||||||
|
|
||||||
|
override fun onAnswer(callId: Long) { |
||||||
|
if (_state.value?.callId != callId || _state.value?.phase != CallPhase.INCOMING) return |
||||||
|
if (activityVisible) { accept(); return } |
||||||
|
// Ответ гарнитурой в фоне: сначала видимый UI, затем разрешённый запуск microphone FGS. |
||||||
|
answerWhenVisible = callId |
||||||
|
try { |
||||||
|
ChatApplication.instance.startActivity(Intent(ChatApplication.instance, MainActivity::class.java).apply { |
||||||
|
addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP) |
||||||
|
putExtra(IncomingCallManager.EXTRA_CALL_ID, callId) |
||||||
|
}) |
||||||
|
LogManager.addLog("INFO", "Call", "Telecom answer id=$callId; waiting for visible Activity before microphone service") |
||||||
|
} catch (e: Exception) { |
||||||
|
answerWhenVisible = 0L |
||||||
|
LogManager.addLog("ERROR", "Call", "cannot show incoming UI for Telecom answer id=$callId: ${e.message}") |
||||||
|
} |
||||||
|
} |
||||||
|
override fun onReject(callId: Long) { end(callId, 2) } |
||||||
|
override fun onDisconnect(callId: Long) { end(callId) } |
||||||
|
|
||||||
|
private fun checkMain() = check(Looper.myLooper() == Looper.getMainLooper()) { "CallController requires main thread" } |
||||||
|
} |
||||||
@ -0,0 +1,229 @@ |
|||||||
|
package com.utun.chat.data |
||||||
|
|
||||||
|
import android.app.Notification |
||||||
|
import android.app.NotificationChannel |
||||||
|
import android.app.NotificationManager |
||||||
|
import android.app.PendingIntent |
||||||
|
import android.app.Service |
||||||
|
import android.content.Context |
||||||
|
import android.content.BroadcastReceiver |
||||||
|
import android.content.Intent |
||||||
|
import android.content.IntentFilter |
||||||
|
import android.content.pm.ServiceInfo |
||||||
|
import android.net.Uri |
||||||
|
import android.os.Build |
||||||
|
import android.os.IBinder |
||||||
|
import android.os.PowerManager |
||||||
|
import android.os.SystemClock |
||||||
|
import androidx.core.app.NotificationCompat |
||||||
|
import androidx.core.app.Person |
||||||
|
import androidx.core.app.ServiceCompat |
||||||
|
import androidx.core.content.ContextCompat |
||||||
|
import com.utun.chat.ChatApplication |
||||||
|
import com.utun.chat.MainActivity |
||||||
|
|
||||||
|
/** |
||||||
|
* Владелец аудиодвижка и PARTIAL_WAKE_LOCK на время исходящего/принятого звонка. |
||||||
|
* Сервис запускается действием пользователя до сигналинга и захвата микрофона. |
||||||
|
* Не восстанавливает звонок после смерти процесса: native-сессия тогда тоже утрачена. |
||||||
|
*/ |
||||||
|
class CallService : Service() { |
||||||
|
companion object { |
||||||
|
// У старого low-канала Android не позволяет повысить importance после создания. |
||||||
|
private const val CHANNEL = "ongoing_call_lockscreen" |
||||||
|
private const val NOTIFICATION_ID = 1002 |
||||||
|
private const val EXTRA_ID = "call_id" |
||||||
|
private const val ACTION_END = "com.utun.chat.action.END_CALL" |
||||||
|
|
||||||
|
fun start(context: Context, callId: Long) { |
||||||
|
ContextCompat.startForegroundService(context, |
||||||
|
Intent(context, CallService::class.java).putExtra(EXTRA_ID, callId)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
val audio = CallAudioEngine() |
||||||
|
private var callId = 0L |
||||||
|
private var wakeLock: PowerManager.WakeLock? = null |
||||||
|
private var powerEventsRegistered = false |
||||||
|
private val powerEvents = object : BroadcastReceiver() { |
||||||
|
override fun onReceive(context: Context, intent: Intent) { |
||||||
|
val pm = getSystemService(Context.POWER_SERVICE) as PowerManager |
||||||
|
LogManager.addLog("INFO", "CallService", |
||||||
|
"power event=${intent.action} id=$callId interactive=${pm.isInteractive} " + |
||||||
|
"idle=${pm.isDeviceIdleMode} save=${pm.isPowerSaveMode} lock=${wakeLock?.isHeld} ${audio.diagnostics}") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
override fun onCreate() { |
||||||
|
super.onCreate() |
||||||
|
val manager = getSystemService(NotificationManager::class.java) |
||||||
|
manager.createNotificationChannel( |
||||||
|
NotificationChannel(CHANNEL, "Текущий звонок", NotificationManager.IMPORTANCE_DEFAULT).apply { |
||||||
|
description = "Собеседник, длительность и завершение звонка на экране блокировки" |
||||||
|
setSound(null, null) |
||||||
|
enableVibration(false) |
||||||
|
lockscreenVisibility = Notification.VISIBILITY_PUBLIC |
||||||
|
}) |
||||||
|
val channel = manager.getNotificationChannel(CHANNEL) |
||||||
|
LogManager.addLog("INFO", "CallService", |
||||||
|
"notification channel=$CHANNEL enabled=${manager.areNotificationsEnabled()} " + |
||||||
|
"importance=${channel.importance} lockscreenVisibility=${channel.lockscreenVisibility}") |
||||||
|
audio.onFailure = { id, detail -> CallController.audioFailed(id, detail) } |
||||||
|
LogManager.addLog("INFO", "CallService", "created") |
||||||
|
} |
||||||
|
|
||||||
|
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { |
||||||
|
val id = intent?.getLongExtra(EXTRA_ID, 0L) ?: 0L |
||||||
|
if (intent?.action == ACTION_END) { |
||||||
|
CallController.end(id) |
||||||
|
return START_NOT_STICKY |
||||||
|
} |
||||||
|
if (!CallController.wantsService(id)) { |
||||||
|
LogManager.addLog("WARN", "CallService", "stale start id=$id owned=$callId") |
||||||
|
if (callId == 0L) { |
||||||
|
// Даже отменённый startForegroundService должен завершить foreground-handshake. |
||||||
|
try { |
||||||
|
promote(false) |
||||||
|
} catch (e: Exception) { |
||||||
|
LogManager.addLog("ERROR", "CallService", "cancelled foreground handshake failed id=$id: ${e.message}") |
||||||
|
} finally { |
||||||
|
stopForeground(STOP_FOREGROUND_REMOVE) |
||||||
|
stopSelf(startId) |
||||||
|
} |
||||||
|
} |
||||||
|
return START_NOT_STICKY |
||||||
|
} |
||||||
|
if (callId == id) return START_NOT_STICKY |
||||||
|
if (callId != 0L) { |
||||||
|
LogManager.addLog("ERROR", "CallService", "start conflicts id=$id owned=$callId") |
||||||
|
CallController.audioFailed(id, "service already owns another call") |
||||||
|
return START_NOT_STICKY |
||||||
|
} |
||||||
|
callId = id |
||||||
|
try { |
||||||
|
promote(true) |
||||||
|
val pm = getSystemService(Context.POWER_SERVICE) as PowerManager |
||||||
|
wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "utun:ongoing_call").apply { |
||||||
|
setReferenceCounted(false) |
||||||
|
} |
||||||
|
wakeLock!!.acquire() |
||||||
|
LogManager.addLog("INFO", "CallService", |
||||||
|
"foreground phoneCall|microphone; CPU lock acquired id=$id held=${wakeLock?.isHeld}") |
||||||
|
val filter = IntentFilter().apply { |
||||||
|
addAction(Intent.ACTION_SCREEN_OFF) |
||||||
|
addAction(Intent.ACTION_SCREEN_ON) |
||||||
|
addAction(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED) |
||||||
|
addAction(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED) |
||||||
|
} |
||||||
|
ContextCompat.registerReceiver(this, powerEvents, filter, ContextCompat.RECEIVER_NOT_EXPORTED) |
||||||
|
powerEventsRegistered = true |
||||||
|
if (!CallController.serviceReady(id, this)) shutdown() |
||||||
|
} catch (e: Exception) { |
||||||
|
LogManager.addLog("ERROR", "CallService", "start failed id=$id: ${e.message}") |
||||||
|
CallController.audioFailed(id, "foreground/wake lock failed: ${e.message}") |
||||||
|
shutdown() |
||||||
|
} |
||||||
|
return START_NOT_STICKY |
||||||
|
} |
||||||
|
|
||||||
|
private fun promote(microphone: Boolean) { |
||||||
|
val micType = if (microphone && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) |
||||||
|
ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE else 0 |
||||||
|
val types = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { |
||||||
|
ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL or micType |
||||||
|
} else 0 |
||||||
|
ServiceCompat.startForeground(this, NOTIFICATION_ID, notification(), types) |
||||||
|
LogManager.addLog("INFO", "CallService", "foreground notification id=$callId phase=${CallController.state.value?.phase}") |
||||||
|
} |
||||||
|
|
||||||
|
fun startAudio(id: Long): Boolean { |
||||||
|
if (id != callId || wakeLock?.isHeld != true) { |
||||||
|
LogManager.addLog("ERROR", "CallService", "audio start rejected id=$id owned=$callId lock=${wakeLock?.isHeld}") |
||||||
|
return false |
||||||
|
} |
||||||
|
audio.router.setPreferredRoute(ChatApplication.instance.configProvider.getCallAudioRoute()) |
||||||
|
return audio.start(id) |
||||||
|
} |
||||||
|
|
||||||
|
fun updateNotification() { |
||||||
|
getSystemService(NotificationManager::class.java).notify(NOTIFICATION_ID, notification()) |
||||||
|
LogManager.addLog("INFO", "CallService", "notification updated id=$callId phase=${CallController.state.value?.phase}") |
||||||
|
} |
||||||
|
|
||||||
|
private fun notification(): Notification { |
||||||
|
val st = CallController.state.value?.takeIf { it.callId == callId } |
||||||
|
val active = st?.phase == CallPhase.ACTIVE |
||||||
|
val person = Person.Builder().setName(st?.peerName?.takeIf { it.isNotBlank() } ?: "vibechat") |
||||||
|
.setKey("node:${st?.peerNodeId}").build() |
||||||
|
val open = PendingIntent.getActivity(this, 0, Intent(this, MainActivity::class.java), |
||||||
|
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE) |
||||||
|
val end = PendingIntent.getService(this, 0, |
||||||
|
Intent(this, CallService::class.java).setAction(ACTION_END) |
||||||
|
.setData(Uri.parse("utun-call:$callId")).putExtra(EXTRA_ID, callId), |
||||||
|
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE) |
||||||
|
val builder = NotificationCompat.Builder(this, CHANNEL) |
||||||
|
.setSmallIcon(android.R.drawable.ic_menu_call) |
||||||
|
.setContentTitle(person.name) |
||||||
|
.setContentText(when (st?.phase) { |
||||||
|
CallPhase.ACTIVE -> "Разговор" |
||||||
|
CallPhase.RINGING -> "Звоним…" |
||||||
|
else -> "Установка звонка" |
||||||
|
}) |
||||||
|
.setCategory(NotificationCompat.CATEGORY_CALL) |
||||||
|
.setVisibility(NotificationCompat.VISIBILITY_PUBLIC) |
||||||
|
.setOngoing(true) |
||||||
|
.setOnlyAlertOnce(true) |
||||||
|
.setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE) |
||||||
|
.setContentIntent(open) |
||||||
|
.setStyle(NotificationCompat.CallStyle.forOngoingCall(person, end)) |
||||||
|
.addPerson(person) |
||||||
|
.setShowWhen(active) |
||||||
|
.setUsesChronometer(active) |
||||||
|
if (active && st != null) { |
||||||
|
// Один источник начала разговора для UI и системного таймера; уведомление не обновляется каждую секунду. |
||||||
|
builder.setWhen(System.currentTimeMillis() - (SystemClock.elapsedRealtime() - st.startedAtElapsedRealtime)) |
||||||
|
} |
||||||
|
return builder.build() |
||||||
|
} |
||||||
|
|
||||||
|
/** Идемпотентное освобождение до остановки сервиса; выполняется в main thread. */ |
||||||
|
fun shutdown() { |
||||||
|
releaseResources() |
||||||
|
stopForeground(STOP_FOREGROUND_REMOVE) |
||||||
|
stopSelf() |
||||||
|
} |
||||||
|
|
||||||
|
private fun releaseResources() { |
||||||
|
val id = callId |
||||||
|
if (powerEventsRegistered) { |
||||||
|
try { unregisterReceiver(powerEvents) } |
||||||
|
catch (e: Exception) { LogManager.addLog("WARN", "CallService", "power receiver cleanup failed id=$id: ${e.message}") } |
||||||
|
powerEventsRegistered = false |
||||||
|
} |
||||||
|
audio.router.onChanged = null |
||||||
|
try { |
||||||
|
audio.stop() |
||||||
|
} finally { |
||||||
|
wakeLock?.let { lock -> |
||||||
|
try { |
||||||
|
if (lock.isHeld) lock.release() |
||||||
|
} catch (e: Exception) { |
||||||
|
LogManager.addLog("ERROR", "CallService", "wake lock release failed id=$id: ${e.message}") |
||||||
|
} |
||||||
|
} |
||||||
|
wakeLock = null |
||||||
|
callId = 0L |
||||||
|
if (id != 0L) LogManager.addLog("INFO", "CallService", "resources released id=$id; CPU lock cleared") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
override fun onDestroy() { |
||||||
|
val id = callId |
||||||
|
releaseResources() |
||||||
|
CallController.serviceLost(id, this) |
||||||
|
LogManager.addLog("INFO", "CallService", "destroyed id=$id") |
||||||
|
super.onDestroy() |
||||||
|
} |
||||||
|
|
||||||
|
override fun onBind(intent: Intent?): IBinder? = null |
||||||
|
} |
||||||
@ -0,0 +1,24 @@ |
|||||||
|
package com.utun.chat.data |
||||||
|
|
||||||
|
/** Состояние единственной звонковой сессии; не зависит от Activity или ViewModel. */ |
||||||
|
enum class CallPhase { NONE, OUTGOING, RINGING, INCOMING, ACTIVE, ENDED } |
||||||
|
|
||||||
|
data class CallStats( |
||||||
|
val rttMs: Int, val bufferMs: Int, val tempoX100: Int, val dropped: Int, |
||||||
|
val underruns: Int, val minMs: Int, val maxMs: Int, val reserveMs: Int |
||||||
|
) |
||||||
|
|
||||||
|
data class CallState( |
||||||
|
val callId: Long = 0, |
||||||
|
val channelId: String = "", |
||||||
|
val peerNodeId: Long = 0, |
||||||
|
val peerName: String = "", |
||||||
|
val phase: CallPhase = CallPhase.NONE, |
||||||
|
val reason: Int = -1, |
||||||
|
val durationSeconds: Int = 0, |
||||||
|
val bgpPath: String = "", |
||||||
|
val stats: CallStats? = null, |
||||||
|
val startedAtElapsedRealtime: Long = 0 |
||||||
|
) { |
||||||
|
val ongoing: Boolean get() = phase != CallPhase.NONE && phase != CallPhase.ENDED |
||||||
|
} |
||||||
Loading…
Reference in new issue