Приложение

2026-04-14 01:15:54 +03:00
parent 8399d32490
commit 1fb1be47dd
126 changed files with 6145 additions and 0 deletions
@@ -0,0 +1,43 @@
+package calls.data.remote
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.os.Build
+
+class CallAudioManager(private val context: Context) {
+    private val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    private var originalMode: Int = AudioManager.MODE_NORMAL
+    private var originalIsSpeakerphoneOn: Boolean = false
+
+    fun startCallMode(isVideoCall: Boolean) {
+        originalMode = audioManager.mode
+        originalIsSpeakerphoneOn = audioManager.isSpeakerphoneOn
+
+        audioManager.mode = AudioManager.MODE_IN_COMMUNICATION
+        setSpeakerphoneOn(isVideoCall)
+
+        // Запрашиваем фокус аудио
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val playbackAttributes = AudioAttributes.Builder()
+                .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+                .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                .build()
+            val focusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
+                .setAudioAttributes(playbackAttributes)
+                .build()
+            audioManager.requestAudioFocus(focusRequest)
+        }
+    }
+
+    fun setSpeakerphoneOn(on: Boolean) {
+        audioManager.isSpeakerphoneOn = on
+    }
+
+    fun stopCallMode() {
+        audioManager.mode = originalMode
+        audioManager.isSpeakerphoneOn = originalIsSpeakerphoneOn
+        audioManager.abandonAudioFocus(null)
+    }
+}
@@ -0,0 +1,46 @@
+package calls.data.remote
+
+import android.content.Context
+import org.webrtc.*
+import java.util.concurrent.ConcurrentHashMap
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class GroupWebRtcManager @Inject constructor(private val context: Context) {
+    private val peerConnections = ConcurrentHashMap<String, PeerConnection>()
+    private val factory: PeerConnectionFactory by lazy { createFactory() }
+    
+    private fun createFactory(): PeerConnectionFactory {
+        PeerConnectionFactory.initialize(
+            PeerConnectionFactory.InitializationOptions.builder(context).createInitializationOptions()
+        )
+        return PeerConnectionFactory.builder()
+            .setVideoEncoderFactory(DefaultVideoEncoderFactory(EglBase.create().eglBaseContext, true, true))
+            .setVideoDecoderFactory(DefaultVideoDecoderFactory(EglBase.create().eglBaseContext))
+            .createPeerConnectionFactory()
+    }
+
+    fun addParticipant(userId: String, observer: PeerConnection.Observer): PeerConnection? {
+        val iceServers = listOf(
+            PeerConnection.IceServer.builder("stun:stun.l.google.com:19302").createIceServer()
+        )
+        val pc = factory.createPeerConnection(iceServers, observer)
+        if (pc != null) {
+            peerConnections[userId] = pc
+        }
+        return pc
+    }
+
+    fun removeParticipant(userId: String) {
+        peerConnections[userId]?.dispose()
+        peerConnections.remove(userId)
+    }
+
+    fun getPeerConnection(userId: String): PeerConnection? = peerConnections[userId]
+
+    fun closeAll() {
+        peerConnections.values.forEach { it.dispose() }
+        peerConnections.clear()
+    }
+}
@@ -0,0 +1,50 @@
+package calls.data.remote
+
+import android.content.Context
+import org.webrtc.*
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class WebRtcManager @Inject constructor(private val context: Context) {
+    private var peerConnection: PeerConnection? = null
+    private val factory: PeerConnectionFactory by lazy { createFactory() }
+    
+    // Аудио и видео источники
+    private val videoSource by lazy { factory.createVideoSource(false) }
+    private val audioSource by lazy { factory.createAudioSource(MediaConstraints()) }
+
+    private fun createFactory(): PeerConnectionFactory {
+        PeerConnectionFactory.initialize(
+            PeerConnectionFactory.InitializationOptions.builder(context).createInitializationOptions()
+        )
+        return PeerConnectionFactory.builder()
+            .setVideoEncoderFactory(DefaultVideoEncoderFactory(EglBase.create().eglBaseContext, true, true))
+            .setVideoDecoderFactory(DefaultVideoDecoderFactory(EglBase.create().eglBaseContext))
+            .createPeerConnectionFactory()
+    }
+
+    fun initializePeerConnection(observer: PeerConnection.Observer) {
+        val iceServers = listOf(
+            PeerConnection.IceServer.builder("stun:stun.l.google.com:19302").createIceServer()
+        )
+        peerConnection = factory.createPeerConnection(iceServers, observer)
+    }
+
+    fun createOffer(observer: SdpObserver) {
+        peerConnection?.createOffer(observer, MediaConstraints())
+    }
+
+    fun setRemoteDescription(sdp: String, type: SessionDescription.Type, observer: SdpObserver) {
+        peerConnection?.setRemoteDescription(observer, SessionDescription(type, sdp))
+    }
+
+    fun addIceCandidate(candidate: IceCandidate) {
+        peerConnection?.addIceCandidate(candidate)
+    }
+
+    fun close() {
+        peerConnection?.dispose()
+        peerConnection = null
+    }
+}
@@ -0,0 +1,148 @@
+package calls.presentation
+
+import androidx.compose.animation.*
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import coil.compose.AsyncImage
+import core.presentation.components.AppAvatar
+import ru.knot.messager.R
+
+@Composable
+fun CallScreen(
+    viewModel: CallViewModel,
+    onBack: () -> Unit
+) {
+    val state by viewModel.state.collectAsState()
+
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(
+                Brush.verticalGradient(
+                    colors = listOf(
+                        Color(0xFF0F0F10),
+                        Color(0xFF161618),
+                        Color(0xFF6366F1).copy(alpha = 0.2f)
+                    )
+                )
+            )
+    ) {
+        // Контент звонка (Аватар или Видео)
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(top = 100.dp),
+            horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+            AppAvatar(
+                url = state.callerAvatar,
+                name = state.callerName,
+                size = 140.dp
+            )
+            
+            Spacer(modifier = Modifier.height(24.dp))
+            
+            Text(
+                text = state.callerName,
+                style = MaterialTheme.typography.headlineMedium,
+                color = Color.White,
+                fontWeight = FontWeight.Bold
+            )
+            
+            Text(
+                text = when (state.status) {
+                    CallStatus.INCOMING -> "Входящий звонок..."
+                    CallStatus.OUTGOING -> "Вызов..."
+                    CallStatus.CONNECTED -> "00:00" // TODO: Timer
+                    CallStatus.ENDED -> "Звонок завершен"
+                    else -> ""
+                },
+                style = MaterialTheme.typography.bodyLarge,
+                color = Color.White.copy(alpha = 0.7f)
+            )
+        }
+
+        // Кнопки управления (Внизу)
+        Box(
+            modifier = Modifier
+                .align(Alignment.BottomCenter)
+                .padding(bottom = 60.dp)
+                .fillMaxWidth(),
+            contentAlignment = Alignment.Center
+        ) {
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(32.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                if (state.status == CallStatus.INCOMING) {
+                    // Кнопка отклонить
+                    CallActionButton(
+                        icon = Icons.Default.CallEnd,
+                        backgroundColor = Color.Red,
+                        onClick = { viewModel.endCall(); onBack() }
+                    )
+                    // Кнопка принять
+                    CallActionButton(
+                        icon = Icons.Default.Call,
+                        backgroundColor = Color(0xFF10B981), // Green
+                        onClick = { viewModel.acceptCall() }
+                    )
+                } else {
+                    // Стандартные кнопки во время разговора
+                    IconButton(
+                        onClick = { /* viewModel.toggleMic() */ },
+                        modifier = Modifier.size(56.dp).clip(CircleShape).background(Color.White.copy(alpha = 0.1f))
+                    ) {
+                        Icon(Icons.Default.Mic, contentDescription = null, tint = Color.White)
+                    }
+
+                    CallActionButton(
+                        icon = Icons.Default.CallEnd,
+                        backgroundColor = Color.Red,
+                        onClick = { viewModel.endCall(); onBack() }
+                    )
+
+                    IconButton(
+                        onClick = { /* viewModel.toggleSpeaker() */ },
+                        modifier = Modifier.size(56.dp).clip(CircleShape).background(Color.White.copy(alpha = 0.1f))
+                    ) {
+                        Icon(Icons.Default.VolumeUp, contentDescription = null, tint = Color.White)
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun CallActionButton(
+    icon: androidx.compose.ui.graphics.vector.ImageVector,
+    backgroundColor: Color,
+    onClick: () -> Unit
+) {
+    FloatingActionButton(
+        onClick = onClick,
+        containerColor = backgroundColor,
+        contentColor = Color.White,
+        shape = CircleShape,
+        modifier = Modifier.size(64.dp)
+    ) {
+        Icon(icon, contentDescription = null, modifier = Modifier.size(32.dp))
+    }
+}
@@ -0,0 +1,99 @@
+package calls.presentation
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import calls.data.remote.WebRtcManager
+import chats.data.remote.signalr.ChatEvent
+import chats.data.remote.signalr.ChatHubClient
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import org.webrtc.*
+import javax.inject.Inject
+
+enum class CallStatus { IDLE, INCOMING, OUTGOING, CONNECTED, ENDED }
+
+data class CallState(
+    val status: CallStatus = CallStatus.IDLE,
+    val chatId: String? = null,
+    val callerName: String = "",
+    val callerAvatar: String? = null,
+    val isMuted: Boolean = false,
+    val isSpeakerOn: Boolean = false,
+    val localVideoTrack: VideoTrack? = null,
+    val remoteVideoTrack: VideoTrack? = null
+)
+
+@HiltViewModel
+class CallViewModel @Inject constructor(
+    private val webRtcManager: WebRtcManager,
+    private val signalrClient: ChatHubClient
+) : ViewModel() {
+
+    private val _state = MutableStateFlow(CallState())
+    val state: StateFlow<CallState> = _state.asStateFlow()
+
+    init {
+        observeSignaling()
+    }
+
+    private fun observeSignaling() {
+        signalrClient.events
+            .onEach { event ->
+                when (event) {
+                    is ChatEvent.CallIncoming -> onIncomingCall(event)
+                    is ChatEvent.CallAnswered -> onCallAnswered(event)
+                    is ChatEvent.IceCandidateReceived -> onIceCandidate(event)
+                    is ChatEvent.CallEnded -> onCallEnded()
+                    else -> Unit
+                }
+            }
+            .launchIn(viewModelScope)
+    }
+
+    private fun onIncomingCall(event: ChatEvent.CallIncoming) {
+        _state.update { it.copy(
+            status = CallStatus.INCOMING,
+            chatId = event.chatId,
+            callerName = "User ${event.from}" // TODO: Load actual user info
+        ) }
+        // Set remote description from offer
+        webRtcManager.setRemoteDescription(event.offer, SessionDescription.Type.OFFER, object : SdpObserver {
+            override fun onCreateSuccess(p0: SessionDescription?) {}
+            override fun onSetSuccess() {}
+            override fun onCreateFailure(p0: String?) {}
+            override fun onSetFailure(p0: String?) {}
+        })
+    }
+
+    private fun onCallAnswered(event: ChatEvent.CallAnswered) {
+        _state.update { it.copy(status = CallStatus.CONNECTED) }
+        webRtcManager.setRemoteDescription(event.answer, SessionDescription.Type.ANSWER, object : SdpObserver {
+            override fun onCreateSuccess(p0: SessionDescription?) {}
+            override fun onSetSuccess() {}
+            override fun onCreateFailure(p0: String?) {}
+            override fun onSetFailure(p0: String?) {}
+        })
+    }
+
+    private fun onIceCandidate(event: ChatEvent.IceCandidateReceived) {
+        // Parse candidate JSON and add to peer connection
+        // webRtcManager.addIceCandidate(...)
+    }
+
+    private fun onCallEnded() {
+        _state.update { it.copy(status = CallStatus.ENDED) }
+        webRtcManager.close()
+    }
+
+    fun acceptCall() {
+        val chatId = _state.value.chatId ?: return
+        // Create answer and send via SignalR
+    }
+
+    fun endCall() {
+        val chatId = _state.value.chatId ?: return
+        // Send call_end via SignalR
+        onCallEnded()
+    }
+}
@@ -0,0 +1,87 @@
+package calls.presentation
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import chats.data.remote.signalr.ChatHubClient
+import chats.data.remote.signalr.ChatEvent
+import calls.data.remote.GroupWebRtcManager
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import org.webrtc.*
+import javax.inject.Inject
+
+data class ParticipantState(
+    val userId: String,
+    val videoTrack: VideoTrack? = null,
+    val isAudioMuted: Boolean = false,
+    val isVideoDisabled: Boolean = false
+)
+
+data class GroupCallState(
+    val chatId: String? = null,
+    val participants: Map<String, ParticipantState> = emptyMap(),
+    val isMicEnabled: Boolean = true,
+    val isCameraEnabled: Boolean = true
+)
+
+@HiltViewModel
+class GroupCallViewModel @Inject constructor(
+    private val webRtcManager: GroupWebRtcManager,
+    private val signalrClient: ChatHubClient
+) : ViewModel() {
+
+    private val _state = MutableStateFlow(GroupCallState())
+    val state: StateFlow<GroupCallState> = _state.asStateFlow()
+
+    init {
+        observeSignalREvents()
+    }
+
+    private fun observeSignalREvents() {
+        signalrClient.events.onEach { event ->
+            when (event) {
+                is ChatEvent.GroupCallUserJoined -> handleUserJoined(event.userId)
+                is ChatEvent.GroupCallUserLeft -> handleUserLeft(event.userId)
+                is ChatEvent.GroupCallOffer -> handleOffer(event.from, event.offer)
+                is ChatEvent.GroupCallAnswer -> handleAnswer(event.from, event.answer)
+                // Дополнительные обработчики ICE кандидатов и т.д.
+                else -> Unit
+            }
+        }.launchIn(viewModelScope)
+    }
+
+    private fun handleUserJoined(userId: String) {
+        // Создаем PeerConnection для нового участника
+        // Логика идентична портированному CallModal.tsx
+        _state.update { it.copy(participants = it.participants + (userId to ParticipantState(userId))) }
+    }
+
+    private fun handleUserLeft(userId: String) {
+        webRtcManager.removeParticipant(userId)
+        _state.update { it.copy(participants = it.participants - userId) }
+    }
+
+    private fun handleOffer(from: String, sdp: String) {
+        // Установка RemoteDescription и создание Answer
+    }
+
+    private fun handleAnswer(from: String, sdp: String) {
+        // Установка RemoteDescription
+    }
+
+    fun toggleMic() {
+        _state.update { it.copy(isMicEnabled = !it.isMicEnabled) }
+        // Логика управления AudioTrack
+    }
+
+    fun toggleCamera() {
+        _state.update { it.copy(isCameraEnabled = !it.isCameraEnabled) }
+        // Логика управления VideoTrack
+    }
+
+    override fun onCleared() {
+        super.onCleared()
+        webRtcManager.closeAll()
+    }
+}
@@ -0,0 +1,67 @@
+package calls.presentation.components
+
+import android.view.ViewGroup
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import org.webrtc.EglBase
+import org.webrtc.SurfaceViewRenderer
+import org.webrtc.VideoTrack
+
+@Composable
+fun VideoGrid(
+    participants: Map<String, VideoTrack?>,
+    localVideoTrack: VideoTrack?
+) {
+    val eglBaseContext = remember { EglBase.create().eglBaseContext }
+    val allVideoTracks = remember(participants, localVideoTrack) {
+        listOfNotNull(localVideoTrack) + participants.values.filterNotNull()
+    }
+
+    LazyVerticalGrid(
+        columns = GridCells.Fixed(if (allVideoTracks.size <= 2) 1 else 2),
+        modifier = Modifier.fillMaxSize(),
+        contentPadding = PaddingValues(8.dp)
+    ) {
+        items(allVideoTracks) { track ->
+            Box(
+                modifier = Modifier
+                    .padding(4.dp)
+                    .fillMaxWidth()
+                    .aspectRatio(if (allVideoTracks.size == 1) 0.6f else 1f)
+            ) {
+                VideoRenderer(videoTrack = track, eglBaseContext = eglBaseContext)
+            }
+        }
+    }
+}
+
+@Composable
+fun VideoRenderer(
+    videoTrack: VideoTrack,
+    eglBaseContext: EglBase.Context
+) {
+    AndroidView(
+        factory = { context ->
+            SurfaceViewRenderer(context).apply {
+                init(eglBaseContext, null)
+                layoutParams = ViewGroup.LayoutParams(
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                    ViewGroup.LayoutParams.MATCH_PARENT
+                )
+            }
+        },
+        update = { view ->
+            videoTrack.addSink(view)
+        },
+        onRelease = { view ->
+            videoTrack.removeSink(view)
+            view.release()
+        }
+    )
+}