commit 9951d8367f9b1788b69d985a4bb54181a5deb467 Author: Andrey K. Choi Date: Mon Sep 29 22:04:14 2025 +0900 init commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..aa724b7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +*.iml +.gradle +/local.properties +/.idea/caches +/.idea/libraries +/.idea/modules.xml +/.idea/workspace.xml +/.idea/navEditor.xml +/.idea/assetWizardSettings.xml +.DS_Store +/build +/captures +.externalNativeBuild +.cxx +local.properties diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 0000000..42afabf --- /dev/null +++ b/app/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/app/build.gradle.kts b/app/build.gradle.kts new file mode 100644 index 0000000..b8453d7 --- /dev/null +++ b/app/build.gradle.kts @@ -0,0 +1,105 @@ +plugins { + alias(libs.plugins.android.application) + alias(libs.plugins.kotlin.android) + alias(libs.plugins.kotlin.compose) +} + +android { + namespace = "com.example.godeye" + compileSdk = 36 + + defaultConfig { + applicationId = "com.example.godeye" + minSdk = 24 + targetSdk = 36 + versionCode = 1 + versionName = "1.0" + + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + } + + buildTypes { + release { + isMinifyEnabled = false + proguardFiles( + getDefaultProguardFile("proguard-android-optimize.txt"), + "proguard-rules.pro" + ) + } + } + compileOptions { + sourceCompatibility = JavaVersion.VERSION_17 + targetCompatibility = JavaVersion.VERSION_17 + } + kotlinOptions { + jvmTarget = "17" + } + buildFeatures { + compose = true + viewBinding = true + } + + // Исправляем проблему с Java toolchain + java { + toolchain { + languageVersion.set(JavaLanguageVersion.of(17)) + } + } +} + +dependencies { + // Core Android + implementation(libs.androidx.core.ktx) + implementation(libs.androidx.lifecycle.runtime.ktx) + implementation(libs.androidx.activity.compose) + implementation(platform(libs.androidx.compose.bom)) + implementation(libs.androidx.compose.ui) + implementation(libs.androidx.compose.ui.graphics) + implementation(libs.androidx.compose.ui.tooling.preview) + implementation(libs.androidx.compose.material3) + + // ViewModel and LiveData + implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0") + implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.7.0") + implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.7.0") + implementation("androidx.activity:activity-ktx:1.8.2") + + // Socket.IO для WebSocket соединения + implementation("io.socket:socket.io-client:2.1.2") + + // Пока уберем WebRTC зависимость - создадим заглушку для демонстрации + // В реальном проекте нужно будет настроить правильную WebRTC библиотеку + + // Camera2 API + implementation("androidx.camera:camera-core:1.3.1") + implementation("androidx.camera:camera-camera2:1.3.1") + implementation("androidx.camera:camera-lifecycle:1.3.1") + implementation("androidx.camera:camera-view:1.3.1") + + // JSON парсинг + implementation("com.google.code.gson:gson:2.10.1") + + // Корутины + implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3") + + // RecyclerView + implementation("androidx.recyclerview:recyclerview:1.3.2") + + // Work Manager для фоновых задач + implementation("androidx.work:work-runtime-ktx:2.9.0") + + // Permissions + implementation("androidx.activity:activity-compose:1.8.2") + + // Navigation + implementation("androidx.navigation:navigation-compose:2.7.6") + + // Testing + testImplementation(libs.junit) + androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.androidx.espresso.core) + androidTestImplementation(platform(libs.androidx.compose.bom)) + androidTestImplementation(libs.androidx.compose.ui.test.junit4) + debugImplementation(libs.androidx.compose.ui.tooling) + debugImplementation(libs.androidx.compose.ui.test.manifest) +} \ No newline at end of file diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro new file mode 100644 index 0000000..481bb43 --- /dev/null +++ b/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/app/src/androidTest/java/com/example/godeye/ExampleInstrumentedTest.kt b/app/src/androidTest/java/com/example/godeye/ExampleInstrumentedTest.kt new file mode 100644 index 0000000..1668532 --- /dev/null +++ b/app/src/androidTest/java/com/example/godeye/ExampleInstrumentedTest.kt @@ -0,0 +1,24 @@ +package com.example.godeye + +import androidx.test.platform.app.InstrumentationRegistry +import androidx.test.ext.junit.runners.AndroidJUnit4 + +import org.junit.Test +import org.junit.runner.RunWith + +import org.junit.Assert.* + +/** + * Instrumented test, which will execute on an Android device. + * + * See [testing documentation](http://d.android.com/tools/testing). + */ +@RunWith(AndroidJUnit4::class) +class ExampleInstrumentedTest { + @Test + fun useAppContext() { + // Context of the app under test. + val appContext = InstrumentationRegistry.getInstrumentation().targetContext + assertEquals("com.example.godeye", appContext.packageName) + } +} \ No newline at end of file diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..5e388e4 --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,57 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/java/com/example/godeye/MainActivity.kt b/app/src/main/java/com/example/godeye/MainActivity.kt new file mode 100644 index 0000000..fce2244 --- /dev/null +++ b/app/src/main/java/com/example/godeye/MainActivity.kt @@ -0,0 +1,118 @@ +package com.example.godeye + +import android.Manifest +import android.content.pm.PackageManager +import android.os.Bundle +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.activity.result.contract.ActivityResultContracts +import androidx.activity.viewModels +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.SnackbarHostState +import androidx.compose.material3.Surface +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.Modifier +import androidx.core.content.ContextCompat +import com.example.godeye.managers.PermissionManager +import com.example.godeye.ui.screens.MainScreen +import com.example.godeye.ui.theme.GodEyeTheme +import com.example.godeye.ui.viewmodels.MainViewModel +import com.example.godeye.utils.Logger +import kotlinx.coroutines.launch + +class MainActivity : ComponentActivity() { + + private val viewModel: MainViewModel by viewModels() + private lateinit var permissionManager: PermissionManager + + // Launcher для запроса разрешений + private val permissionsLauncher = registerForActivityResult( + ActivityResultContracts.RequestMultiplePermissions() + ) { permissions -> + val allGranted = permissions.values.all { it } + if (allGranted) { + Logger.d("All permissions granted") + viewModel.startServices() // Запуск сервисов после получения разрешений + } else { + Logger.w("Some permissions were denied") + val deniedPermissions = permissions.filterValues { !it }.keys + Logger.w("Denied permissions: ${deniedPermissions.joinToString(", ")}") + } + + // Логируем статус разрешений + permissionManager.logPermissionsStatus() + } + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + Logger.d("MainActivity created") + permissionManager = PermissionManager(this) + + // Проверяем разрешения при запуске + checkAndRequestPermissions() + if (permissionManager.hasAllRequiredPermissions()) { + viewModel.startServices() // Запуск сервисов если разрешения уже есть + } + + setContent { + GodEyeTheme { + val snackbarHostState = remember { SnackbarHostState() } + val coroutineScope = rememberCoroutineScope() + + Surface( + modifier = Modifier.fillMaxSize(), + color = MaterialTheme.colorScheme.background + ) { + Scaffold( + snackbarHost = { SnackbarHost(snackbarHostState) } + ) { paddingValues -> + MainScreen( + viewModel = viewModel, + onRequestPermissions = { + requestMissingPermissions() + }, + onShowError = { message -> + coroutineScope.launch { + snackbarHostState.showSnackbar(message) + } + } + ) + } + } + } + } + } + + /** + * Проверить и запросить недостающие разрешения + */ + private fun checkAndRequestPermissions() { + if (!permissionManager.hasAllRequiredPermissions()) { + Logger.d("Some permissions are missing, requesting...") + requestMissingPermissions() + } else { + Logger.d("All required permissions are granted") + } + } + + /** + * Запросить недостающие разрешения + */ + private fun requestMissingPermissions() { + val missingPermissions = permissionManager.getMissingPermissions() + if (missingPermissions.isNotEmpty()) { + Logger.d("Requesting permissions: ${missingPermissions.joinToString(", ")}") + permissionsLauncher.launch(missingPermissions.toTypedArray()) + } + } + + override fun onDestroy() { + super.onDestroy() + Logger.d("MainActivity destroyed") + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/godeye/managers/CameraManager.kt b/app/src/main/java/com/example/godeye/managers/CameraManager.kt new file mode 100644 index 0000000..b2eb7e4 --- /dev/null +++ b/app/src/main/java/com/example/godeye/managers/CameraManager.kt @@ -0,0 +1,245 @@ +package com.example.godeye.managers + +import android.annotation.SuppressLint +import android.content.Context +import android.graphics.SurfaceTexture +import android.hardware.camera2.* +import android.media.MediaRecorder +import android.os.Handler +import android.os.HandlerThread +import android.util.Size +import android.view.Surface +import com.example.godeye.models.AppError +import com.example.godeye.utils.Constants +import com.example.godeye.utils.Logger +import com.example.godeye.utils.getCameraIdForType +import com.example.godeye.utils.getAvailableCameraTypes +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow + +/** + * Менеджер для управления камерами устройства + */ +class CameraManager(private val context: Context) { + + private val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as android.hardware.camera2.CameraManager + private var currentCameraId: String? = null + private var captureSession: CameraCaptureSession? = null + private var cameraDevice: CameraDevice? = null + private var backgroundThread: HandlerThread? = null + private var backgroundHandler: Handler? = null + + private val _isRecording = MutableStateFlow(false) + val isRecording: StateFlow = _isRecording.asStateFlow() + + private val _currentCameraType = MutableStateFlow(null) + val currentCameraType: StateFlow = _currentCameraType.asStateFlow() + + private val _error = MutableStateFlow(null) + val error: StateFlow = _error.asStateFlow() + + /** + * Инициализация фонового потока для камеры + */ + private fun startBackgroundThread() { + backgroundThread = HandlerThread("CameraBackground").also { it.start() } + backgroundHandler = Handler(backgroundThread?.looper!!) + } + + /** + * Остановка фонового потока + */ + private fun stopBackgroundThread() { + backgroundThread?.quitSafely() + try { + backgroundThread?.join() + backgroundThread = null + backgroundHandler = null + } catch (e: InterruptedException) { + Logger.e("Error stopping background thread", e) + } + } + + /** + * Получить список доступных типов камер + */ + fun getAvailableCameraTypes(): List { + return cameraManager.getAvailableCameraTypes() + } + + /** + * Открыть камеру указанного типа + */ + @SuppressLint("MissingPermission") + fun openCamera(cameraType: String, surface: Surface, onSuccess: () -> Unit = {}, onError: (AppError) -> Unit = {}) { + try { + val cameraId = cameraManager.getCameraIdForType(cameraType) + if (cameraId == null) { + val error = AppError.CameraError("Camera type $cameraType not available") + _error.value = error + onError(error) + return + } + + startBackgroundThread() + + cameraManager.openCamera(cameraId, object : CameraDevice.StateCallback() { + override fun onOpened(camera: CameraDevice) { + Logger.d("Camera opened: $cameraId") + cameraDevice = camera + currentCameraId = cameraId + _currentCameraType.value = cameraType + createCameraPreviewSession(surface, onSuccess, onError) + } + + override fun onDisconnected(camera: CameraDevice) { + Logger.d("Camera disconnected: $cameraId") + camera.close() + cameraDevice = null + currentCameraId = null + _currentCameraType.value = null + } + + override fun onError(camera: CameraDevice, error: Int) { + Logger.e("Camera error: $error") + camera.close() + cameraDevice = null + currentCameraId = null + _currentCameraType.value = null + val appError = AppError.CameraError("Camera error: $error") + _error.value = appError + onError(appError) + } + }, backgroundHandler) + + } catch (e: Exception) { + Logger.e("Error opening camera", e) + val error = AppError.CameraError("Failed to open camera: ${e.message}") + _error.value = error + onError(error) + } + } + + /** + * Создать сессию предварительного просмотра камеры + */ + private fun createCameraPreviewSession(surface: Surface, onSuccess: () -> Unit, onError: (AppError) -> Unit) { + try { + val cameraDevice = this.cameraDevice ?: run { + val error = AppError.CameraError("Camera device is null") + _error.value = error + onError(error) + return + } + + val captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW) + captureRequestBuilder.addTarget(surface) + + // Используем совместимый подход для всех версий Android + @Suppress("DEPRECATION") + cameraDevice.createCaptureSession( + listOf(surface), + object : CameraCaptureSession.StateCallback() { + override fun onConfigured(session: CameraCaptureSession) { + captureSession = session + try { + captureRequestBuilder.set( + CaptureRequest.CONTROL_AF_MODE, + CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE + ) + + val captureRequest = captureRequestBuilder.build() + session.setRepeatingRequest(captureRequest, null, backgroundHandler) + _isRecording.value = true + Logger.d("Camera preview session created successfully") + onSuccess() + } catch (e: Exception) { + Logger.e("Error starting camera preview", e) + val error = AppError.CameraError("Failed to start preview: ${e.message}") + _error.value = error + onError(error) + } + } + + override fun onConfigureFailed(session: CameraCaptureSession) { + Logger.e("Camera capture session configuration failed") + val error = AppError.CameraError("Failed to configure capture session") + _error.value = error + onError(error) + } + }, + backgroundHandler + ) + } catch (e: Exception) { + Logger.e("Error creating camera preview session", e) + val error = AppError.CameraError("Failed to create preview session: ${e.message}") + _error.value = error + onError(error) + } + } + + /** + * Переключить на другой тип камеры + */ + fun switchCamera(newCameraType: String, surface: Surface, onSuccess: () -> Unit = {}, onError: (AppError) -> Unit = {}) { + Logger.d("Switching camera from ${_currentCameraType.value} to $newCameraType") + closeCamera() + openCamera(newCameraType, surface, onSuccess, onError) + } + + /** + * Получить оптимальный размер для предварительного просмотра + */ + fun getOptimalPreviewSize(cameraType: String): Size? { + return try { + val cameraId = cameraManager.getCameraIdForType(cameraType) ?: return null + val characteristics = cameraManager.getCameraCharacteristics(cameraId) + val map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP) + val outputSizes = map?.getOutputSizes(SurfaceTexture::class.java) + + // Выбираем размер близкий к 1080p, но не превышающий его + outputSizes?.find { it.width <= 1920 && it.height <= 1080 } + ?: outputSizes?.minByOrNull { it.width * it.height } + } catch (e: Exception) { + Logger.e("Error getting optimal preview size", e) + null + } + } + + /** + * Закрыть текущую камеру + */ + fun closeCamera() { + try { + captureSession?.close() + captureSession = null + + cameraDevice?.close() + cameraDevice = null + + currentCameraId = null + _currentCameraType.value = null + _isRecording.value = false + + stopBackgroundThread() + Logger.d("Camera closed successfully") + } catch (e: Exception) { + Logger.e("Error closing camera", e) + } + } + + /** + * Проверить, открыта ли камера + */ + fun isCameraOpen(): Boolean { + return cameraDevice != null + } + + /** + * Очистить ошибку + */ + fun clearError() { + _error.value = null + } +} diff --git a/app/src/main/java/com/example/godeye/managers/PermissionManager.kt b/app/src/main/java/com/example/godeye/managers/PermissionManager.kt new file mode 100644 index 0000000..9fd5ca0 --- /dev/null +++ b/app/src/main/java/com/example/godeye/managers/PermissionManager.kt @@ -0,0 +1,102 @@ +package com.example.godeye.managers + +import android.Manifest +import android.content.Context +import android.content.pm.PackageManager +import androidx.core.content.ContextCompat +import com.example.godeye.utils.Logger + +/** + * Менеджер для управления разрешениями приложения + */ +class PermissionManager(private val context: Context) { + + companion object { + val REQUIRED_PERMISSIONS = arrayOf( + Manifest.permission.CAMERA, + Manifest.permission.RECORD_AUDIO, + Manifest.permission.INTERNET, + Manifest.permission.ACCESS_NETWORK_STATE, + Manifest.permission.WAKE_LOCK, + Manifest.permission.FOREGROUND_SERVICE, + Manifest.permission.POST_NOTIFICATIONS + ) + + val CAMERA_PERMISSIONS = arrayOf( + Manifest.permission.CAMERA, + Manifest.permission.RECORD_AUDIO + ) + } + + /** + * Проверить, есть ли все необходимые разрешения + */ + fun hasAllRequiredPermissions(): Boolean { + return REQUIRED_PERMISSIONS.all { permission -> + ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED + } + } + + /** + * Проверить разрешения для камеры + */ + fun hasCameraPermissions(): Boolean { + return CAMERA_PERMISSIONS.all { permission -> + ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED + } + } + + /** + * Проверить конкретное разрешение + */ + fun hasPermission(permission: String): Boolean { + return ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED + } + + /** + * Получить список отсутствующих разрешений + */ + fun getMissingPermissions(): List { + return REQUIRED_PERMISSIONS.filter { permission -> + ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED + } + } + + /** + * Получить список отсутствующих разрешений для камеры + */ + fun getMissingCameraPermissions(): List { + return CAMERA_PERMISSIONS.filter { permission -> + ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED + } + } + + /** + * Проверить критические разрешения для основной функциональности + */ + fun hasCriticalPermissions(): Boolean { + val criticalPermissions = arrayOf( + Manifest.permission.CAMERA, + Manifest.permission.RECORD_AUDIO, + Manifest.permission.INTERNET + ) + + return criticalPermissions.all { permission -> + ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED + } + } + + /** + * Логирование состояния разрешений + */ + fun logPermissionsStatus() { + Logger.d("=== Permission Status ===") + REQUIRED_PERMISSIONS.forEach { permission -> + val granted = hasPermission(permission) + Logger.d("$permission: ${if (granted) "GRANTED" else "DENIED"}") + } + Logger.d("All required permissions: ${hasAllRequiredPermissions()}") + Logger.d("Camera permissions: ${hasCameraPermissions()}") + Logger.d("Critical permissions: ${hasCriticalPermissions()}") + } +} diff --git a/app/src/main/java/com/example/godeye/managers/SessionManager.kt b/app/src/main/java/com/example/godeye/managers/SessionManager.kt new file mode 100644 index 0000000..ed5e776 --- /dev/null +++ b/app/src/main/java/com/example/godeye/managers/SessionManager.kt @@ -0,0 +1,152 @@ +package com.example.godeye.managers + +import com.example.godeye.models.CameraSession +import com.example.godeye.utils.Logger +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow + +/** + * Менеджер для управления активными сессиями с операторами + */ +class SessionManager { + + private val _activeSessions = MutableStateFlow>(emptyList()) + val activeSessions: StateFlow> = _activeSessions.asStateFlow() + + /** + * Добавить новую сессию + */ + fun addSession(sessionId: String, operatorId: String, cameraType: String) { + val newSession = CameraSession( + sessionId = sessionId, + operatorId = operatorId, + cameraType = cameraType, + startTime = System.currentTimeMillis(), + isActive = true, + webRTCConnected = false + ) + + val currentSessions = _activeSessions.value.toMutableList() + // Удаляем существующую сессию с тем же ID, если есть + currentSessions.removeAll { it.sessionId == sessionId } + currentSessions.add(newSession) + _activeSessions.value = currentSessions + + Logger.d("Session added: $sessionId, operator: $operatorId, camera: $cameraType") + } + + /** + * Обновить статус WebRTC соединения для сессии + */ + fun updateWebRTCStatus(sessionId: String, connected: Boolean) { + val currentSessions = _activeSessions.value.toMutableList() + val sessionIndex = currentSessions.indexOfFirst { it.sessionId == sessionId } + + if (sessionIndex != -1) { + currentSessions[sessionIndex] = currentSessions[sessionIndex].copy( + webRTCConnected = connected + ) + _activeSessions.value = currentSessions + Logger.d("WebRTC status updated for session $sessionId: $connected") + } + } + + /** + * Переключить камеру для сессии + */ + fun switchCameraForSession(sessionId: String, newCameraType: String) { + val currentSessions = _activeSessions.value.toMutableList() + val sessionIndex = currentSessions.indexOfFirst { it.sessionId == sessionId } + + if (sessionIndex != -1) { + currentSessions[sessionIndex] = currentSessions[sessionIndex].copy( + cameraType = newCameraType + ) + _activeSessions.value = currentSessions + Logger.d("Camera switched for session $sessionId to $newCameraType") + } + } + + /** + * Завершить сессию + */ + fun endSession(sessionId: String) { + val currentSessions = _activeSessions.value.toMutableList() + val removed = currentSessions.removeAll { it.sessionId == sessionId } + + if (removed) { + _activeSessions.value = currentSessions + Logger.d("Session ended: $sessionId") + } + } + + /** + * Получить сессию по ID + */ + fun getSession(sessionId: String): CameraSession? { + return _activeSessions.value.find { it.sessionId == sessionId } + } + + /** + * Проверить, есть ли активные сессии + */ + fun hasActiveSessions(): Boolean { + return _activeSessions.value.isNotEmpty() + } + + /** + * Получить количество активных сессий + */ + fun getActiveSessionCount(): Int { + return _activeSessions.value.size + } + + /** + * Завершить все сессии + */ + fun endAllSessions() { + val sessionIds = _activeSessions.value.map { it.sessionId } + _activeSessions.value = emptyList() + Logger.d("All sessions ended: ${sessionIds.joinToString(", ")}") + } + + /** + * Получить текущий тип камеры для активной сессии + */ + fun getCurrentCameraType(): String? { + return _activeSessions.value.firstOrNull()?.cameraType + } + + /** + * Проверить, подключен ли WebRTC для сессии + */ + fun isWebRTCConnected(sessionId: String): Boolean { + return getSession(sessionId)?.webRTCConnected ?: false + } + + /** + * Получить статистику сессий + */ + fun getSessionStats(): SessionStats { + val sessions = _activeSessions.value + return SessionStats( + totalSessions = sessions.size, + connectedSessions = sessions.count { it.webRTCConnected }, + activeSessions = sessions.count { it.isActive }, + oldestSessionTime = sessions.minOfOrNull { it.startTime }, + newestSessionTime = sessions.maxOfOrNull { it.startTime } + ) + } +} + +/** + * Статистика сессий + */ +data class SessionStats( + val totalSessions: Int, + val connectedSessions: Int, + val activeSessions: Int, + val oldestSessionTime: Long?, + val newestSessionTime: Long? +) diff --git a/app/src/main/java/com/example/godeye/managers/WebRTCManager.kt b/app/src/main/java/com/example/godeye/managers/WebRTCManager.kt new file mode 100644 index 0000000..34eb98a --- /dev/null +++ b/app/src/main/java/com/example/godeye/managers/WebRTCManager.kt @@ -0,0 +1,145 @@ +package com.example.godeye.managers + +import android.content.Context +import com.example.godeye.models.AppError +import com.example.godeye.models.WebRTCConnectionState +import com.example.godeye.utils.Constants +import com.example.godeye.utils.Logger +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow + +/** + * Менеджер для управления WebRTC соединениями (заглушка) + * В реальном проекте здесь будет полная реализация с WebRTC библиотекой + */ +class WebRTCManager(private val context: Context) { + + private val _connectionState = MutableStateFlow(WebRTCConnectionState.NEW) + val connectionState: StateFlow = _connectionState.asStateFlow() + + private val _error = MutableStateFlow(null) + val error: StateFlow = _error.asStateFlow() + + // Callback для передачи событий WebRTC + private var onOfferCreated: ((String) -> Unit)? = null + private var onAnswerCreated: ((String) -> Unit)? = null + private var onIceCandidateCreated: ((String, String, Int) -> Unit)? = null + + /** + * Инициализация WebRTC (заглушка) + */ + fun initialize() { + try { + Logger.d("WebRTC initialized (stub implementation)") + } catch (e: Exception) { + Logger.e("Error initializing WebRTC", e) + _error.value = AppError.WebRTCConnectionFailed + } + } + + /** + * Создать PeerConnection (заглушка) + */ + fun createPeerConnection( + onOfferCreated: (String) -> Unit, + onAnswerCreated: (String) -> Unit, + onIceCandidateCreated: (String, String, Int) -> Unit + ) { + try { + this.onOfferCreated = onOfferCreated + this.onAnswerCreated = onAnswerCreated + this.onIceCandidateCreated = onIceCandidateCreated + + Logger.d("PeerConnection created (stub implementation)") + } catch (e: Exception) { + Logger.e("Error creating PeerConnection", e) + _error.value = AppError.WebRTCConnectionFailed + } + } + + /** + * Создать локальные медиа треки (заглушка) + */ + fun createLocalMediaTracks(cameraType: String) { + try { + Logger.d("Local media tracks created for $cameraType (stub implementation)") + } catch (e: Exception) { + Logger.e("Error creating local media tracks", e) + _error.value = AppError.WebRTCConnectionFailed + } + } + + /** + * Создать Offer (заглушка) + */ + fun createOffer() { + try { + // Симулируем создание offer + val mockOffer = "v=0\r\no=- 123456 2 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\nm=video 9 UDP/TLS/RTP/SAVPF 96\r\nc=IN IP4 127.0.0.1\r\na=rtcp:9 IN IP4 127.0.0.1" + onOfferCreated?.invoke(mockOffer) + Logger.d("Offer created (stub implementation)") + + // Симулируем успешное соединение через некоторое время + _connectionState.value = WebRTCConnectionState.CONNECTED + } catch (e: Exception) { + Logger.e("Error creating offer", e) + _error.value = AppError.WebRTCConnectionFailed + } + } + + /** + * Обработать Answer (заглушка) + */ + fun handleAnswer(answerSdp: String) { + try { + Logger.d("Answer processed (stub implementation): ${answerSdp.take(50)}...") + _connectionState.value = WebRTCConnectionState.CONNECTED + } catch (e: Exception) { + Logger.e("Error handling answer", e) + _error.value = AppError.WebRTCConnectionFailed + } + } + + /** + * Добавить ICE candidate (заглушка) + */ + fun addIceCandidate(candidateSdp: String, sdpMid: String, sdpMLineIndex: Int) { + try { + Logger.d("ICE candidate added (stub implementation): $candidateSdp") + } catch (e: Exception) { + Logger.e("Error adding ICE candidate", e) + } + } + + /** + * Переключить камеру (заглушка) + */ + fun switchCamera(newCameraType: String) { + try { + Logger.d("Camera switched to: $newCameraType (stub implementation)") + } catch (e: Exception) { + Logger.e("Error switching camera", e) + _error.value = AppError.CameraError("Failed to switch camera: ${e.message}") + } + } + + /** + * Закрыть WebRTC соединение (заглушка) + */ + fun close() { + try { + _connectionState.value = WebRTCConnectionState.CLOSED + Logger.d("WebRTC connection closed (stub implementation)") + } catch (e: Exception) { + Logger.e("Error closing WebRTC connection", e) + } + } + + /** + * Очистить ошибку + */ + fun clearError() { + _error.value = null + } +} diff --git a/app/src/main/java/com/example/godeye/models/Models.kt b/app/src/main/java/com/example/godeye/models/Models.kt new file mode 100644 index 0000000..caa27f1 --- /dev/null +++ b/app/src/main/java/com/example/godeye/models/Models.kt @@ -0,0 +1,154 @@ +package com.example.godeye.models + +import android.os.Build + +/** + * Информация об устройстве для регистрации на сервере + */ +data class DeviceInfo( + val model: String = Build.MODEL, + val androidVersion: String = Build.VERSION.RELEASE, + val appVersion: String = "1.0.0", // Заменяем BuildConfig на хардкод для упрощения + val availableCameras: List +) + +/** + * Активная сессия с оператором + */ +data class CameraSession( + val sessionId: String, + val operatorId: String, + val cameraType: String, + val startTime: Long, + var isActive: Boolean = true, + var webRTCConnected: Boolean = false +) + +/** + * Запрос доступа к камере от оператора + */ +data class CameraRequest( + val sessionId: String, + val operatorId: String, + val cameraType: String, + val timestamp: Long = System.currentTimeMillis() +) + +/** + * Ответ на запрос доступа к камере + */ +data class CameraResponse( + val sessionId: String, + val accepted: Boolean, + val reason: String? = null +) + +/** + * WebRTC Offer/Answer данные + */ +data class WebRTCMessage( + val sessionId: String, + val type: String, // "offer", "answer", "ice-candidate" + val sdp: String? = null, + val candidate: String? = null, + val sdpMid: String? = null, + val sdpMLineIndex: Int? = null +) + +/** + * События Socket.IO + */ +sealed class SocketEvent { + data class RegisterAndroid( + val deviceId: String, + val deviceInfo: DeviceInfo + ) : SocketEvent() + + data class CameraRequest( + val sessionId: String, + val operatorId: String, + val cameraType: String + ) : SocketEvent() + + data class CameraResponse( + val sessionId: String, + val accepted: Boolean, + val reason: String? = null + ) : SocketEvent() + + data class CameraDisconnect( + val sessionId: String + ) : SocketEvent() + + data class CameraSwitch( + val sessionId: String, + val newCameraType: String + ) : SocketEvent() + + data class WebRTCOffer( + val sessionId: String, + val offer: String + ) : SocketEvent() + + data class WebRTCAnswer( + val sessionId: String, + val answer: String + ) : SocketEvent() + + data class WebRTCIceCandidate( + val sessionId: String, + val candidate: String, + val sdpMid: String, + val sdpMLineIndex: Int + ) : SocketEvent() +} + +/** + * Состояния подключения + */ +enum class ConnectionState { + DISCONNECTED, + CONNECTING, + CONNECTED, + ERROR, + RECONNECTING +} + +/** + * Состояния WebRTC соединения + */ +enum class WebRTCConnectionState { + NEW, + CONNECTING, + CONNECTED, + DISCONNECTED, + FAILED, + CLOSED +} + +/** + * Типы ошибок приложения + */ +sealed class AppError { + object NetworkError : AppError() + object CameraPermissionDenied : AppError() + object AudioPermissionDenied : AppError() + object CameraNotAvailable : AppError() + object WebRTCConnectionFailed : AppError() + data class SocketError(val message: String) : AppError() + data class CameraError(val message: String) : AppError() + data class UnknownError(val throwable: Throwable) : AppError() +} + +/** + * UI состояние главного экрана + */ +data class MainScreenState( + val deviceId: String = "", + val serverUrl: String = "", + val connectionState: ConnectionState = ConnectionState.DISCONNECTED, + val activeSessions: List = emptyList(), + val isLoading: Boolean = false, + val error: AppError? = null, + val showCameraRequest: CameraRequest? = null +) diff --git a/app/src/main/java/com/example/godeye/services/CameraService.kt b/app/src/main/java/com/example/godeye/services/CameraService.kt new file mode 100644 index 0000000..25b3ac1 --- /dev/null +++ b/app/src/main/java/com/example/godeye/services/CameraService.kt @@ -0,0 +1,425 @@ +package com.example.godeye.services + +import android.app.* +import android.content.Intent +import android.graphics.SurfaceTexture +import android.os.Binder +import android.os.IBinder +import android.view.Surface +import androidx.core.app.NotificationCompat +import com.example.godeye.MainActivity +import com.example.godeye.R +import com.example.godeye.managers.CameraManager +import com.example.godeye.managers.SessionManager +import com.example.godeye.managers.WebRTCManager +import com.example.godeye.models.AppError +import com.example.godeye.models.WebRTCConnectionState +import com.example.godeye.utils.Constants +import com.example.godeye.utils.Logger +import kotlinx.coroutines.* +import kotlinx.coroutines.flow.* + +/** + * Сервис для управления камерой и WebRTC соединениями + */ +class CameraService : Service() { + + private val binder = LocalBinder() + private val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.Main) + + private lateinit var cameraManager: CameraManager + private lateinit var webRTCManager: WebRTCManager + private lateinit var sessionManager: SessionManager + + // Surface для WebRTC видео + private var webRTCSurface: Surface? = null + private var surfaceTexture: SurfaceTexture? = null + + // StateFlows для отслеживания состояния + private val _isActive = MutableStateFlow(false) + val isActive: StateFlow = _isActive.asStateFlow() + + private val _error = MutableStateFlow(null) + val error: StateFlow = _error.asStateFlow() + + // Callbacks для передачи WebRTC событий + private var onWebRTCOfferCreated: ((String, String) -> Unit)? = null // sessionId, offer + private var onWebRTCIceCandidateCreated: ((String, String, String, Int) -> Unit)? = null // sessionId, candidate, sdpMid, sdpMLineIndex + + inner class LocalBinder : Binder() { + fun getService(): CameraService = this@CameraService + } + + override fun onCreate() { + super.onCreate() + Logger.d("CameraService created") + + cameraManager = CameraManager(this) + webRTCManager = WebRTCManager(this) + sessionManager = SessionManager() + + // Инициализация WebRTC + webRTCManager.initialize() + + createNotificationChannel() + observeManagerStates() + } + + override fun onBind(intent: Intent?): IBinder = binder + + override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { + startForeground(Constants.FOREGROUND_SERVICE_ID + 1, createNotification()) + return START_STICKY + } + + /** + * Установить callbacks для WebRTC событий + */ + fun setWebRTCCallbacks( + onOfferCreated: (String, String) -> Unit, + onIceCandidateCreated: (String, String, String, Int) -> Unit + ) { + this.onWebRTCOfferCreated = onOfferCreated + this.onWebRTCIceCandidateCreated = onIceCandidateCreated + } + + /** + * Начать камера сессию + */ + fun startCameraSession(sessionId: String, operatorId: String, cameraType: String) { + serviceScope.launch { + try { + Logger.d("Starting camera session: $sessionId, camera: $cameraType") + + // Добавляем сессию в менеджер + sessionManager.addSession(sessionId, operatorId, cameraType) + + // Создаем Surface для WebRTC + setupWebRTCSurface() + + // Создаем WebRTC соединение + webRTCManager.createPeerConnection( + onOfferCreated = { offer -> + onWebRTCOfferCreated?.invoke(sessionId, offer) + }, + onAnswerCreated = { answer -> + // Ответ не используется, так как мы создаем offer + }, + onIceCandidateCreated = { candidate, sdpMid, sdpMLineIndex -> + onWebRTCIceCandidateCreated?.invoke(sessionId, candidate, sdpMid, sdpMLineIndex) + } + ) + + // Создаем локальные медиа треки + webRTCManager.createLocalMediaTracks(cameraType) + + // Открываем камеру + webRTCSurface?.let { surface -> + cameraManager.openCamera( + cameraType = cameraType, + surface = surface, + onSuccess = { + Logger.d("Camera opened successfully for session: $sessionId") + _isActive.value = true + + // Создаем WebRTC offer + webRTCManager.createOffer() + }, + onError = { error -> + Logger.e("Failed to open camera for session: $sessionId") + _error.value = error + sessionManager.endSession(sessionId) + } + ) + } ?: run { + val error = AppError.CameraError("WebRTC surface not available") + _error.value = error + sessionManager.endSession(sessionId) + } + + } catch (e: Exception) { + Logger.e("Error starting camera session", e) + _error.value = AppError.UnknownError(e) + sessionManager.endSession(sessionId) + } + } + } + + /** + * Обработать WebRTC answer + */ + fun handleWebRTCAnswer(sessionId: String, answer: String) { + serviceScope.launch { + try { + Logger.d("Handling WebRTC answer for session: $sessionId") + webRTCManager.handleAnswer(answer) + sessionManager.updateWebRTCStatus(sessionId, true) + } catch (e: Exception) { + Logger.e("Error handling WebRTC answer", e) + _error.value = AppError.WebRTCConnectionFailed + } + } + } + + /** + * Добавить ICE candidate + */ + fun addIceCandidate(sessionId: String, candidate: String, sdpMid: String, sdpMLineIndex: Int) { + serviceScope.launch { + try { + Logger.d("Adding ICE candidate for session: $sessionId") + webRTCManager.addIceCandidate(candidate, sdpMid, sdpMLineIndex) + } catch (e: Exception) { + Logger.e("Error adding ICE candidate", e) + } + } + } + + /** + * Переключить камеру + */ + fun switchCamera(sessionId: String, newCameraType: String) { + serviceScope.launch { + try { + Logger.d("Switching camera for session $sessionId to $newCameraType") + + // Обновляем тип камеры в сессии + sessionManager.switchCameraForSession(sessionId, newCameraType) + + // Переключаем камеру в WebRTC + webRTCManager.switchCamera(newCameraType) + + // Переключаем физическую камеру + webRTCSurface?.let { surface -> + cameraManager.switchCamera( + newCameraType = newCameraType, + surface = surface, + onSuccess = { + Logger.d("Camera switched successfully to: $newCameraType") + }, + onError = { error -> + Logger.e("Failed to switch camera to: $newCameraType") + _error.value = error + } + ) + } + + } catch (e: Exception) { + Logger.e("Error switching camera", e) + _error.value = AppError.CameraError("Failed to switch camera: ${e.message}") + } + } + } + + /** + * Завершить сессию + */ + fun endSession(sessionId: String) { + serviceScope.launch { + try { + Logger.d("Ending session: $sessionId") + + // Закрываем камеру + cameraManager.closeCamera() + + // Закрываем WebRTC соединение + webRTCManager.close() + + // Удаляем сессию + sessionManager.endSession(sessionId) + + // Очищаем Surface + cleanupWebRTCSurface() + + _isActive.value = false + Logger.d("Session ended successfully: $sessionId") + + // Если нет активных сессий, останавливаем сервис + if (!sessionManager.hasActiveSessions()) { + stopSelf() + } + + } catch (e: Exception) { + Logger.e("Error ending session", e) + } + } + } + + /** + * Завершить все сессии + */ + fun endAllSessions() { + serviceScope.launch { + try { + Logger.d("Ending all sessions") + + // Закрываем камеру + cameraManager.closeCamera() + + // Закрываем WebRTC соединение + webRTCManager.close() + + // Удаляем все сессии + sessionManager.endAllSessions() + + // Очищаем Surface + cleanupWebRTCSurface() + + _isActive.value = false + Logger.d("All sessions ended successfully") + + stopSelf() + + } catch (e: Exception) { + Logger.e("Error ending all sessions", e) + } + } + } + + /** + * Настроить Surface для WebRTC + */ + private fun setupWebRTCSurface() { + try { + // Создаем SurfaceTexture для WebRTC + surfaceTexture = SurfaceTexture(0).apply { + setDefaultBufferSize(1280, 720) + } + webRTCSurface = Surface(surfaceTexture) + Logger.d("WebRTC surface created successfully") + } catch (e: Exception) { + Logger.e("Error creating WebRTC surface", e) + _error.value = AppError.CameraError("Failed to create WebRTC surface: ${e.message}") + } + } + + /** + * Очистить WebRTC Surface + */ + private fun cleanupWebRTCSurface() { + try { + webRTCSurface?.release() + webRTCSurface = null + + surfaceTexture?.release() + surfaceTexture = null + + Logger.d("WebRTC surface cleaned up") + } catch (e: Exception) { + Logger.e("Error cleaning up WebRTC surface", e) + } + } + + /** + * Наблюдать за состояниями менеджеров + */ + private fun observeManagerStates() { + serviceScope.launch { + // Наблюдаем за ошибками камеры + cameraManager.error.collect { error -> + error?.let { + _error.value = it + Logger.e("Camera manager error: $it") + } + } + } + + serviceScope.launch { + // Наблюдаем за ошибками WebRTC + webRTCManager.error.collect { error -> + error?.let { + _error.value = it + Logger.e("WebRTC manager error: $it") + } + } + } + + serviceScope.launch { + // Наблюдаем за состоянием WebRTC соединения + webRTCManager.connectionState.collect { state -> + Logger.d("WebRTC connection state: $state") + when (state) { + WebRTCConnectionState.CONNECTED -> { + // Обновляем статус всех активных сессий + sessionManager.activeSessions.value.forEach { session -> + sessionManager.updateWebRTCStatus(session.sessionId, true) + } + } + WebRTCConnectionState.FAILED, + WebRTCConnectionState.DISCONNECTED -> { + // Обновляем статус всех активных сессий + sessionManager.activeSessions.value.forEach { session -> + sessionManager.updateWebRTCStatus(session.sessionId, false) + } + } + else -> { /* Игнорируем другие состояния */ } + } + } + } + } + + /** + * Получить менеджер сессий + */ + fun getSessionManager(): SessionManager = sessionManager + + /** + * Создать канал уведомлений + */ + private fun createNotificationChannel() { + val channel = NotificationChannel( + "${Constants.NOTIFICATION_CHANNEL_ID}_camera", + "GodEye Camera Service", + NotificationManager.IMPORTANCE_LOW + ).apply { + description = "Уведомления о работе камеры GodEye" + setShowBadge(false) + } + + val notificationManager = getSystemService(NotificationManager::class.java) + notificationManager.createNotificationChannel(channel) + } + + /** + * Создать уведомление для foreground service + */ + private fun createNotification(): Notification { + val intent = Intent(this, MainActivity::class.java) + val pendingIntent = PendingIntent.getActivity( + this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE + ) + + val activeSessionsCount = sessionManager.getActiveSessionCount() + val statusText = if (activeSessionsCount > 0) { + "Активных сессий: $activeSessionsCount" + } else { + "Камера готова к работе" + } + + return NotificationCompat.Builder(this, "${Constants.NOTIFICATION_CHANNEL_ID}_camera") + .setContentTitle("GodEye Camera") + .setContentText(statusText) + .setSmallIcon(R.drawable.ic_launcher_foreground) + .setContentIntent(pendingIntent) + .setOngoing(true) + .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE) + .build() + } + + /** + * Очистить ошибку + */ + fun clearError() { + _error.value = null + cameraManager.clearError() + webRTCManager.clearError() + } + + override fun onDestroy() { + super.onDestroy() + serviceScope.launch { + endAllSessions() + } + Logger.d("CameraService destroyed") + } +} diff --git a/app/src/main/java/com/example/godeye/services/SocketService.kt b/app/src/main/java/com/example/godeye/services/SocketService.kt new file mode 100644 index 0000000..1050e9d --- /dev/null +++ b/app/src/main/java/com/example/godeye/services/SocketService.kt @@ -0,0 +1,430 @@ +package com.example.godeye.services + +import android.app.* +import android.content.Context +import android.content.Intent +import android.os.Binder +import android.os.IBinder +import androidx.core.app.NotificationCompat +import com.example.godeye.MainActivity +import com.example.godeye.R +import com.example.godeye.managers.PermissionManager +import com.example.godeye.models.* +import com.example.godeye.utils.Constants +import com.example.godeye.utils.Logger +import com.example.godeye.utils.generateDeviceId +import com.example.godeye.utils.getAvailableCameraTypes +import com.google.gson.Gson +import com.google.gson.JsonObject +import io.socket.client.IO +import io.socket.client.Socket +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch +import org.json.JSONObject +import java.net.URI + +/** + * Сервис для управления WebSocket соединением с backend сервером + */ +class SocketService : Service() { + + private val binder = LocalBinder() + private var socket: Socket? = null + private val gson = Gson() + private val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.IO) + + private lateinit var permissionManager: PermissionManager + + // StateFlows для отслеживания состояния + private val _connectionState = MutableStateFlow(ConnectionState.DISCONNECTED) + val connectionState: StateFlow = _connectionState.asStateFlow() + + private val _deviceId = MutableStateFlow("") + val deviceId: StateFlow = _deviceId.asStateFlow() + + private val _error = MutableStateFlow(null) + val error: StateFlow = _error.asStateFlow() + + // События для UI + private val _cameraRequest = MutableStateFlow(null) + val cameraRequest: StateFlow = _cameraRequest.asStateFlow() + + private val _webrtcOffer = MutableStateFlow(null) + val webrtcOffer: StateFlow = _webrtcOffer.asStateFlow() + + private val _webrtcAnswer = MutableStateFlow(null) + val webrtcAnswer: StateFlow = _webrtcAnswer.asStateFlow() + + private val _webrtcIceCandidate = MutableStateFlow(null) + val webrtcIceCandidate: StateFlow = _webrtcIceCandidate.asStateFlow() + + private val _cameraSwitchRequest = MutableStateFlow?>(null) // sessionId, newCameraType + val cameraSwitchRequest: StateFlow?> = _cameraSwitchRequest.asStateFlow() + + private val _sessionDisconnect = MutableStateFlow(null) // sessionId + val sessionDisconnect: StateFlow = _sessionDisconnect.asStateFlow() + + inner class LocalBinder : Binder() { + fun getService(): SocketService = this@SocketService + } + + override fun onCreate() { + super.onCreate() + Logger.d("SocketService created") + permissionManager = PermissionManager(this) + _deviceId.value = generateDeviceId() + createNotificationChannel() + } + + override fun onBind(intent: Intent?): IBinder = binder + + override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { + startForeground(Constants.FOREGROUND_SERVICE_ID, createNotification()) + return START_STICKY + } + + /** + * Подключиться к серверу + */ + fun connect(serverUrl: String) { + serviceScope.launch { + try { + _connectionState.value = ConnectionState.CONNECTING + Logger.d("Connecting to server: $serverUrl") + + // Дополнительная проверка URL + if (serverUrl.isBlank()) { + Logger.e("Server URL is empty") + _connectionState.value = ConnectionState.ERROR + _error.value = AppError.NetworkError + return@launch + } + + Logger.d("Creating URI from: $serverUrl") + val uri = URI.create(serverUrl) + Logger.d("URI created successfully: $uri") + + Logger.d("Creating Socket.IO client") + val options = IO.Options().apply { + timeout = 10000 // Увеличиваем таймаут до 10 секунд + reconnection = true + reconnectionDelay = 2000 // Увеличиваем задержку между попытками + reconnectionAttempts = 3 // Уменьшаем количество попыток + forceNew = true // Принудительно создаваем новое соединение + } + + socket = IO.socket(uri, options).apply { + Logger.d("Socket.IO client created, setting up listeners") + setupEventListeners() + Logger.d("Listeners set up, initiating connection") + connect() + Logger.d("Connection initiated") + } + + // Добавляем таймаут для проверки подключения + launch { + kotlinx.coroutines.delay(15000) // Ждем 15 секунд + if (_connectionState.value == ConnectionState.CONNECTING) { + Logger.w("Connection timeout after 15 seconds") + _connectionState.value = ConnectionState.ERROR + _error.value = AppError.SocketError("Connection timeout - server may be unreachable") + socket?.disconnect() + } + } + + } catch (e: Exception) { + Logger.e("Error connecting to server: ${e.message}", e) + _connectionState.value = ConnectionState.ERROR + _error.value = AppError.SocketError("Connection failed: ${e.message}") + } + } + } + + /** + * Отключиться от сервера + */ + fun disconnect() { + serviceScope.launch { + try { + socket?.disconnect() + socket?.close() + socket = null + _connectionState.value = ConnectionState.DISCONNECTED + Logger.d("Disconnected from server") + } catch (e: Exception) { + Logger.e("Error disconnecting from server", e) + } + } + } + + /** + * Настроить обработчики событий Socket.IO + */ + private fun setupEventListeners() { + socket?.apply { + Logger.d("Setting up Socket.IO event listeners") + + on(Socket.EVENT_CONNECT) { + Logger.d("✅ Socket connected successfully") + _connectionState.value = ConnectionState.CONNECTED + registerDevice() + } + + on(Socket.EVENT_DISCONNECT) { args -> + val reason = args.firstOrNull()?.toString() ?: "unknown" + Logger.d("❌ Socket disconnected: $reason") + _connectionState.value = ConnectionState.DISCONNECTED + } + + on(Socket.EVENT_CONNECT_ERROR) { args -> + val error = args.firstOrNull()?.toString() ?: "Unknown connection error" + Logger.e("🔥 Socket connection error: $error") + _connectionState.value = ConnectionState.ERROR + _error.value = AppError.SocketError(error) + } + + on(Constants.SocketEvents.REGISTER_SUCCESS) { args -> + Logger.d("Device registered successfully") + val data = args.firstOrNull()?.toString() + Logger.d("Registration response: $data") + } + + on(Constants.SocketEvents.REGISTER_ERROR) { args -> + val error = args.firstOrNull()?.toString() ?: "Registration failed" + Logger.e("Device registration error: $error") + _error.value = AppError.SocketError(error) + } + + on(Constants.SocketEvents.CAMERA_REQUEST) { args -> + try { + val data = JSONObject(args[0].toString()) + val request = CameraRequest( + sessionId = data.getString("sessionId"), + operatorId = data.getString("operatorId"), + cameraType = data.getString("cameraType") + ) + Logger.d("Camera request received: $request") + _cameraRequest.value = request + } catch (e: Exception) { + Logger.e("Error parsing camera request", e) + } + } + + on(Constants.SocketEvents.CAMERA_DISCONNECT) { args -> + try { + val data = JSONObject(args[0].toString()) + val sessionId = data.getString("sessionId") + Logger.d("Camera disconnect received for session: $sessionId") + _sessionDisconnect.value = sessionId + } catch (e: Exception) { + Logger.e("Error parsing camera disconnect", e) + } + } + + on(Constants.SocketEvents.CAMERA_SWITCH) { args -> + try { + val data = JSONObject(args[0].toString()) + val sessionId = data.getString("sessionId") + val newCameraType = data.getString("newCameraType") + Logger.d("Camera switch request: $sessionId -> $newCameraType") + _cameraSwitchRequest.value = Pair(sessionId, newCameraType) + } catch (e: Exception) { + Logger.e("Error parsing camera switch", e) + } + } + + on(Constants.SocketEvents.WEBRTC_OFFER) { args -> + try { + val data = JSONObject(args[0].toString()) + val message = WebRTCMessage( + sessionId = data.getString("sessionId"), + type = "offer", + sdp = data.getString("offer") + ) + Logger.d("WebRTC offer received for session: ${message.sessionId}") + _webrtcOffer.value = message + } catch (e: Exception) { + Logger.e("Error parsing WebRTC offer", e) + } + } + + on(Constants.SocketEvents.WEBRTC_ICE_CANDIDATE) { args -> + try { + val data = JSONObject(args[0].toString()) + val message = WebRTCMessage( + sessionId = data.getString("sessionId"), + type = "ice-candidate", + candidate = data.getString("candidate"), + sdpMid = data.getString("sdpMid"), + sdpMLineIndex = data.getInt("sdpMLineIndex") + ) + Logger.d("WebRTC ICE candidate received for session: ${message.sessionId}") + _webrtcIceCandidate.value = message + } catch (e: Exception) { + Logger.e("Error parsing WebRTC ICE candidate", e) + } + } + } + } + + /** + * Зарегистрировать устройство на сервере + */ + private fun registerDevice() { + try { + val cameraManager = getSystemService(Context.CAMERA_SERVICE) as android.hardware.camera2.CameraManager + val deviceInfo = DeviceInfo( + availableCameras = cameraManager.getAvailableCameraTypes() + ) + + val registrationData = JsonObject().apply { + addProperty("deviceId", _deviceId.value) + add("deviceInfo", gson.toJsonTree(deviceInfo)) + } + + socket?.emit(Constants.SocketEvents.REGISTER_ANDROID, registrationData) + Logger.d("Device registration sent: $registrationData") + + } catch (e: Exception) { + Logger.e("Error registering device", e) + _error.value = AppError.SocketError("Failed to register device: ${e.message}") + } + } + + /** + * Отправить ответ на запрос камеры + */ + fun sendCameraResponse(sessionId: String, accepted: Boolean, reason: String? = null) { + try { + val response = JsonObject().apply { + addProperty("sessionId", sessionId) + addProperty("accepted", accepted) + reason?.let { addProperty("reason", it) } + } + + socket?.emit(Constants.SocketEvents.CAMERA_RESPONSE, response) + Logger.d("Camera response sent: $response") + + } catch (e: Exception) { + Logger.e("Error sending camera response", e) + _error.value = AppError.SocketError("Failed to send camera response: ${e.message}") + } + } + + /** + * Отправить WebRTC answer + */ + fun sendWebRTCAnswer(sessionId: String, answer: String) { + try { + val data = JsonObject().apply { + addProperty("sessionId", sessionId) + addProperty("answer", answer) + } + + socket?.emit(Constants.SocketEvents.WEBRTC_ANSWER, data) + Logger.d("WebRTC answer sent for session: $sessionId") + + } catch (e: Exception) { + Logger.e("Error sending WebRTC answer", e) + _error.value = AppError.SocketError("Failed to send WebRTC answer: ${e.message}") + } + } + + /** + * Отправить ICE candidate + */ + fun sendIceCandidate(sessionId: String, candidate: String, sdpMid: String, sdpMLineIndex: Int) { + try { + val data = JsonObject().apply { + addProperty("sessionId", sessionId) + addProperty("candidate", candidate) + addProperty("sdpMid", sdpMid) + addProperty("sdpMLineIndex", sdpMLineIndex) + } + + socket?.emit(Constants.SocketEvents.WEBRTC_ICE_CANDIDATE, data) + Logger.d("ICE candidate sent for session: $sessionId") + + } catch (e: Exception) { + Logger.e("Error sending ICE candidate", e) + } + } + + /** + * Создать канал уведомлений + */ + private fun createNotificationChannel() { + val channel = NotificationChannel( + Constants.NOTIFICATION_CHANNEL_ID, + "GodEye Service", + NotificationManager.IMPORTANCE_LOW + ).apply { + description = "Уведомления о состоянии подключения GodEye" + setShowBadge(false) + } + + val notificationManager = getSystemService(NotificationManager::class.java) + notificationManager.createNotificationChannel(channel) + } + + /** + * Создать уведомление для foreground service + */ + private fun createNotification(): Notification { + val intent = Intent(this, MainActivity::class.java) + val pendingIntent = PendingIntent.getActivity( + this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE + ) + + val statusText = when (_connectionState.value) { + ConnectionState.CONNECTED -> "Подключено" + ConnectionState.CONNECTING -> "Подключение..." + ConnectionState.RECONNECTING -> "Переподключение..." + ConnectionState.DISCONNECTED -> "Отключено" + ConnectionState.ERROR -> "Ошибка подключения" + } + + return NotificationCompat.Builder(this, Constants.NOTIFICATION_CHANNEL_ID) + .setContentTitle("GodEye Signal Center") + .setContentText("Статус: $statusText") + .setSmallIcon(R.drawable.ic_launcher_foreground) + .setContentIntent(pendingIntent) + .setOngoing(true) + .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE) + .build() + } + + /** + * Обновить уведомление + */ + private fun updateNotification() { + val notificationManager = getSystemService(NotificationManager::class.java) + notificationManager.notify(Constants.FOREGROUND_SERVICE_ID, createNotification()) + } + + /** + * Очистить события + */ + fun clearCameraRequest() { + _cameraRequest.value = null + } + + fun clearWebRTCOffer() { + _webrtcOffer.value = null + } + + fun clearError() { + _error.value = null + } + + override fun onDestroy() { + super.onDestroy() + disconnect() + Logger.d("SocketService destroyed") + } +} diff --git a/app/src/main/java/com/example/godeye/ui/components/CameraRequestDialog.kt b/app/src/main/java/com/example/godeye/ui/components/CameraRequestDialog.kt new file mode 100644 index 0000000..3d3ab11 --- /dev/null +++ b/app/src/main/java/com/example/godeye/ui/components/CameraRequestDialog.kt @@ -0,0 +1,164 @@ +package com.example.godeye.ui.components + +import android.util.Log +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Person +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.window.Dialog +import com.example.godeye.R +import com.example.godeye.models.CameraRequest +import com.example.godeye.utils.Constants + +/** + * Диалог запроса доступа к камере от оператора + */ +@Composable +fun CameraRequestDialog( + request: CameraRequest, + onAccept: () -> Unit, + onDeny: () -> Unit, + onDismiss: () -> Unit +) { + var rememberChoice by remember { mutableStateOf(false) } + + // Лог открытия диалога + LaunchedEffect(Unit) { + Log.d("GodEye", "CameraRequestDialog открыт: sessionId=${request.sessionId}, operatorId=${request.operatorId}, cameraType=${request.cameraType}") + } + + Dialog(onDismissRequest = { + Log.d("GodEye", "Диалог закрыт пользователем") + onDismiss() + }) { + Card( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp), + shape = RoundedCornerShape(16.dp), + elevation = CardDefaults.cardElevation(defaultElevation = 8.dp) + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(24.dp), + horizontalAlignment = Alignment.CenterHorizontally + ) { + // Иконка камеры + Icon( + imageVector = Icons.Default.Person, // Заменено с PhotoCamera на Person + contentDescription = null, + modifier = Modifier.size(48.dp), + tint = MaterialTheme.colorScheme.primary + ) + + Spacer(modifier = Modifier.height(16.dp)) + + // Заголовок + Text( + text = stringResource(R.string.camera_request_title), + style = MaterialTheme.typography.headlineSmall, + fontWeight = FontWeight.Bold, + textAlign = TextAlign.Center + ) + + Spacer(modifier = Modifier.height(16.dp)) + + // Основное сообщение + Text( + text = stringResource( + R.string.camera_request_message, + request.operatorId, + getCameraTypeName(request.cameraType) + ), + style = MaterialTheme.typography.bodyLarge, + textAlign = TextAlign.Center + ) + + Spacer(modifier = Modifier.height(8.dp)) + + // ID сессии + Text( + text = stringResource(R.string.session_id_label, request.sessionId), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + textAlign = TextAlign.Center + ) + + Spacer(modifier = Modifier.height(24.dp)) + + // Чекбокс "Запомнить выбор" + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically + ) { + Checkbox( + checked = rememberChoice, + onCheckedChange = { rememberChoice = it } + ) + Spacer(modifier = Modifier.width(8.dp)) + Text( + text = stringResource(R.string.remember_choice), + style = MaterialTheme.typography.bodyMedium + ) + } + + Spacer(modifier = Modifier.height(24.dp)) + + // Кнопки + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(12.dp) + ) { + // Кнопка "Отклонить" + OutlinedButton( + onClick = { + Log.d("GodEye", "Пользователь отклонил запрос камеры") + onDeny() + }, + modifier = Modifier + .weight(1f) + .height(48.dp) + ) { + Text(stringResource(R.string.deny_button)) + } + + // Кнопка "Разрешить" + Button( + onClick = { + Log.d("GodEye", "Пользователь разрешил доступ к камере") + onAccept() + }, + modifier = Modifier + .weight(1f) + .height(48.dp) + ) { + Text(stringResource(R.string.allow_button)) + } + } + } + } + } +} + +/** + * Получить локализованное название типа камеры + */ +@Composable +private fun getCameraTypeName(cameraType: String): String { + return when (cameraType) { + Constants.CameraTypes.BACK -> stringResource(R.string.camera_type_back) + Constants.CameraTypes.FRONT -> stringResource(R.string.camera_type_front) + Constants.CameraTypes.WIDE -> stringResource(R.string.camera_type_wide) + Constants.CameraTypes.TELEPHOTO -> stringResource(R.string.camera_type_telephoto) + else -> cameraType + } +} diff --git a/app/src/main/java/com/example/godeye/ui/components/ConnectionStatusCard.kt b/app/src/main/java/com/example/godeye/ui/components/ConnectionStatusCard.kt new file mode 100644 index 0000000..c4147ca --- /dev/null +++ b/app/src/main/java/com/example/godeye/ui/components/ConnectionStatusCard.kt @@ -0,0 +1,146 @@ +package com.example.godeye.ui.components + +import androidx.compose.animation.core.* +import androidx.compose.foundation.layout.* +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.rotate +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import com.example.godeye.R +import com.example.godeye.models.ConnectionState + +/** + * Компонент для отображения статуса подключения к серверу + */ +@Composable +fun ConnectionStatusCard( + connectionState: ConnectionState, + modifier: Modifier = Modifier +) { + val (icon, color, statusText) = getConnectionStateInfo(connectionState) + + Card( + modifier = modifier.fillMaxWidth(), + shape = RoundedCornerShape(12.dp), + elevation = CardDefaults.cardElevation(defaultElevation = 4.dp), + colors = CardDefaults.cardColors( + containerColor = color.copy(alpha = 0.1f) + ) + ) { + Row( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp), + verticalAlignment = Alignment.CenterVertically + ) { + // Иконка с анимацией для состояний загрузки + ConnectionIcon( + icon = icon, + color = color, + isAnimated = connectionState == ConnectionState.CONNECTING || + connectionState == ConnectionState.RECONNECTING + ) + + Spacer(modifier = Modifier.width(12.dp)) + + // Текст статуса + Column { + Text( + text = stringResource(R.string.connection_status_label), + style = MaterialTheme.typography.labelMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant + ) + Text( + text = statusText, + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.Bold, + color = color + ) + } + } + } +} + +/** + * Анимированная иконка подключения + */ +@Composable +private fun ConnectionIcon( + icon: ImageVector, + color: androidx.compose.ui.graphics.Color, + isAnimated: Boolean, + modifier: Modifier = Modifier +) { + if (isAnimated) { + val infiniteTransition = rememberInfiniteTransition(label = "connection_animation") + val rotation by infiniteTransition.animateFloat( + initialValue = 0f, + targetValue = 360f, + animationSpec = infiniteRepeatable( + animation = tween(1000, easing = LinearEasing), + repeatMode = RepeatMode.Restart + ), + label = "rotation" + ) + + Icon( + imageVector = icon, + contentDescription = null, + modifier = modifier + .size(24.dp) + .rotate(rotation), + tint = color + ) + } else { + Icon( + imageVector = icon, + contentDescription = null, + modifier = modifier.size(24.dp), + tint = color + ) + } +} + +/** + * Получить информацию о состоянии подключения + */ +@Composable +private fun getConnectionStateInfo( + connectionState: ConnectionState +): Triple { + return when (connectionState) { + ConnectionState.DISCONNECTED -> Triple( + Icons.Default.Close, + MaterialTheme.colorScheme.onSurfaceVariant, + stringResource(R.string.status_disconnected) + ) + ConnectionState.CONNECTING -> Triple( + Icons.Default.Refresh, + MaterialTheme.colorScheme.primary, + stringResource(R.string.status_connecting) + ) + ConnectionState.CONNECTED -> Triple( + Icons.Default.CheckCircle, + MaterialTheme.colorScheme.primary, + stringResource(R.string.status_connected) + ) + ConnectionState.ERROR -> Triple( + Icons.Default.Warning, + MaterialTheme.colorScheme.error, + stringResource(R.string.status_error) + ) + ConnectionState.RECONNECTING -> Triple( + Icons.Default.Refresh, + MaterialTheme.colorScheme.secondary, + stringResource(R.string.status_reconnecting) + ) + } +} diff --git a/app/src/main/java/com/example/godeye/ui/components/SessionsList.kt b/app/src/main/java/com/example/godeye/ui/components/SessionsList.kt new file mode 100644 index 0000000..6b0a0f9 --- /dev/null +++ b/app/src/main/java/com/example/godeye/ui/components/SessionsList.kt @@ -0,0 +1,237 @@ +package com.example.godeye.ui.components + +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Person +import androidx.compose.material.icons.filled.Close +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import com.example.godeye.R +import com.example.godeye.models.CameraSession +import com.example.godeye.utils.Constants +import kotlinx.coroutines.delay +import java.text.SimpleDateFormat +import java.util.* + +/** + * Компонент для отображения списка активных сессий + */ +@Composable +fun SessionsList( + sessions: List, + onEndSession: (String) -> Unit, + modifier: Modifier = Modifier +) { + if (sessions.isEmpty()) { + // Пустое состояние + Box( + modifier = modifier.fillMaxWidth(), + contentAlignment = Alignment.Center + ) { + Text( + text = stringResource(R.string.no_active_sessions), + style = MaterialTheme.typography.bodyLarge, + color = MaterialTheme.colorScheme.onSurfaceVariant + ) + } + } else { + LazyColumn( + modifier = modifier.fillMaxWidth(), + verticalArrangement = Arrangement.spacedBy(8.dp), + contentPadding = PaddingValues(vertical = 8.dp) + ) { + items(sessions, key = { it.sessionId }) { session -> + SessionItem( + session = session, + onEndSession = { onEndSession(session.sessionId) } + ) + } + } + } +} + +/** + * Элемент списка сессий + */ +@Composable +fun SessionItem( + session: CameraSession, + onEndSession: () -> Unit, + modifier: Modifier = Modifier +) { + Card( + modifier = modifier.fillMaxWidth(), + shape = RoundedCornerShape(12.dp), + elevation = CardDefaults.cardElevation(defaultElevation = 4.dp) + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp) + ) { + // Заголовок с оператором + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Row(verticalAlignment = Alignment.CenterVertically) { + Icon( + imageVector = Icons.Default.Person, + contentDescription = null, + modifier = Modifier.size(20.dp), + tint = MaterialTheme.colorScheme.primary + ) + Spacer(modifier = Modifier.width(8.dp)) + Text( + text = "${stringResource(R.string.session_operator_label)} ${session.operatorId}", + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.Bold + ) + } + + // Статус WebRTC + WebRTCStatusChip(isConnected = session.webRTCConnected) + } + + Spacer(modifier = Modifier.height(12.dp)) + + // Информация о камере + Row(verticalAlignment = Alignment.CenterVertically) { + Icon( + imageVector = Icons.Default.Person, // Заменено с Camera на Person + contentDescription = null, + modifier = Modifier.size(18.dp), + tint = MaterialTheme.colorScheme.onSurfaceVariant + ) + Spacer(modifier = Modifier.width(8.dp)) + Text( + text = "${stringResource(R.string.session_camera_label)} ${getCameraTypeName(session.cameraType)}", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant + ) + } + + Spacer(modifier = Modifier.height(8.dp)) + + // Длительность сессии + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + SessionDuration(startTime = session.startTime) + + // Кнопка завершения сессии + FilledTonalButton( + onClick = onEndSession, + colors = ButtonDefaults.filledTonalButtonColors( + containerColor = MaterialTheme.colorScheme.errorContainer, + contentColor = MaterialTheme.colorScheme.onErrorContainer + ) + ) { + Icon( + imageVector = Icons.Default.Close, + contentDescription = null, + modifier = Modifier.size(18.dp) + ) + Spacer(modifier = Modifier.width(4.dp)) + Text(stringResource(R.string.end_session_button)) + } + } + } + } +} + +/** + * Компонент для отображения статуса WebRTC соединения + */ +@Composable +fun WebRTCStatusChip( + isConnected: Boolean, + modifier: Modifier = Modifier +) { + val backgroundColor = if (isConnected) { + MaterialTheme.colorScheme.primaryContainer + } else { + MaterialTheme.colorScheme.errorContainer + } + + val contentColor = if (isConnected) { + MaterialTheme.colorScheme.onPrimaryContainer + } else { + MaterialTheme.colorScheme.onErrorContainer + } + + val statusText = if (isConnected) { + stringResource(R.string.webrtc_connected) + } else { + stringResource(R.string.webrtc_disconnected) + } + + Surface( + modifier = modifier, + shape = RoundedCornerShape(16.dp), + color = backgroundColor + ) { + Text( + text = stringResource(R.string.session_webrtc_status, statusText), + style = MaterialTheme.typography.labelSmall, + color = contentColor, + modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp) + ) + } +} + +/** + * Компонент для отображения длительности сессии + */ +@Composable +fun SessionDuration( + startTime: Long, + modifier: Modifier = Modifier +) { + var currentTime by remember { mutableStateOf(System.currentTimeMillis()) } + + // Обновляем время каждую секунду + LaunchedEffect(startTime) { + while (true) { + currentTime = System.currentTimeMillis() + delay(1000) + } + } + + val duration = currentTime - startTime + val hours = (duration / (1000 * 60 * 60)) % 24 + val minutes = (duration / (1000 * 60)) % 60 + val seconds = (duration / 1000) % 60 + + Text( + text = "${stringResource(R.string.session_duration_label)} ${String.format("%02d:%02d:%02d", hours, minutes, seconds)}", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = modifier + ) +} + +/** + * Получить локализованное название типа камеры + */ +@Composable +private fun getCameraTypeName(cameraType: String): String { + return when (cameraType) { + Constants.CameraTypes.BACK -> stringResource(R.string.camera_type_back) + Constants.CameraTypes.FRONT -> stringResource(R.string.camera_type_front) + Constants.CameraTypes.WIDE -> stringResource(R.string.camera_type_wide) + Constants.CameraTypes.TELEPHOTO -> stringResource(R.string.camera_type_telephoto) + else -> cameraType + } +} diff --git a/app/src/main/java/com/example/godeye/ui/screens/MainScreen.kt b/app/src/main/java/com/example/godeye/ui/screens/MainScreen.kt new file mode 100644 index 0000000..e872d7f --- /dev/null +++ b/app/src/main/java/com/example/godeye/ui/screens/MainScreen.kt @@ -0,0 +1,318 @@ +package com.example.godeye.ui.screens + +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Settings +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.KeyboardType +import androidx.compose.ui.unit.dp +import androidx.lifecycle.viewmodel.compose.viewModel +import com.example.godeye.R +import com.example.godeye.models.ConnectionState +import com.example.godeye.models.MainScreenState +import com.example.godeye.ui.components.CameraRequestDialog +import com.example.godeye.ui.components.ConnectionStatusCard +import com.example.godeye.ui.components.SessionsList +import com.example.godeye.ui.viewmodels.MainViewModel +import com.example.godeye.ui.viewmodels.UiEvent +import com.example.godeye.utils.collectAsEffect + +/** + * Главный экран приложения + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun MainScreen( + viewModel: MainViewModel = viewModel(), + onRequestPermissions: () -> Unit, + onShowError: (String) -> Unit +) { + val uiState by viewModel.uiState.collectAsState() + var serverUrl by remember { mutableStateOf("") } + + // Синхронизируем локальное состояние с ViewModel + LaunchedEffect(uiState.serverUrl) { + serverUrl = uiState.serverUrl + } + + // Обработка UI событий + LaunchedEffect(viewModel) { + viewModel.events.collect { event -> + when (event) { + is UiEvent.RequestPermissions -> onRequestPermissions() + is UiEvent.ShowError -> { + // Получаем текст ошибки внутри LaunchedEffect + val errorMessage = when (event.error) { + is com.example.godeye.models.AppError.NetworkError -> "Ошибка сети" + is com.example.godeye.models.AppError.CameraPermissionDenied -> "Нет разрешения на камеру" + is com.example.godeye.models.AppError.AudioPermissionDenied -> "Нет разрешения на микрофон" + is com.example.godeye.models.AppError.CameraNotAvailable -> "Камера недоступна" + is com.example.godeye.models.AppError.WebRTCConnectionFailed -> "Ошибка WebRTC соединения" + is com.example.godeye.models.AppError.SocketError -> "Ошибка WebSocket: ${event.error.message}" + is com.example.godeye.models.AppError.CameraError -> "Ошибка камеры: ${event.error.message}" + is com.example.godeye.models.AppError.UnknownError -> "Неизвестная ошибка" + } + onShowError(errorMessage) + } + is UiEvent.ShowMessage -> onShowError(event.message) + is UiEvent.ShowCameraRequestDialog -> { + // Диалог будет показан через состояние showCameraRequest + } + } + } + } + + Scaffold( + topBar = { + TopAppBar( + title = { + Text( + text = stringResource(R.string.app_name), + fontWeight = FontWeight.Bold + ) + }, + actions = { + IconButton(onClick = { /* TODO: Настройки */ }) { + Icon(Icons.Default.Settings, contentDescription = stringResource(R.string.settings)) + } + } + ) + } + ) { paddingValues -> + Box(modifier = Modifier.fillMaxSize()) { + MainContent( + uiState = uiState, + serverUrl = serverUrl, + onServerUrlChange = { serverUrl = it }, + onConnect = { + viewModel.updateServerUrl(serverUrl) + viewModel.connect() + }, + onDisconnect = viewModel::disconnect, + onEndSession = viewModel::endSession, + modifier = Modifier.padding(paddingValues) + ) + + // Диалог запроса камеры + uiState.showCameraRequest?.let { request -> + CameraRequestDialog( + request = request, + onAccept = { viewModel.respondToCameraRequest(request.sessionId, true) }, + onDeny = { viewModel.respondToCameraRequest(request.sessionId, false) }, + onDismiss = { viewModel.respondToCameraRequest(request.sessionId, false) } + ) + } + + // Индикатор загрузки + if (uiState.isLoading) { + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center + ) { + Card( + elevation = CardDefaults.cardElevation(defaultElevation = 8.dp) + ) { + Row( + modifier = Modifier.padding(16.dp), + verticalAlignment = Alignment.CenterVertically + ) { + CircularProgressIndicator(modifier = Modifier.size(24.dp)) + Spacer(modifier = Modifier.width(12.dp)) + Text(stringResource(R.string.loading)) + } + } + } + } + } + } +} + +/** + * Основное содержимое экрана + */ +@Composable +private fun MainContent( + uiState: MainScreenState, + serverUrl: String, + onServerUrlChange: (String) -> Unit, + onConnect: () -> Unit, + onDisconnect: () -> Unit, + onEndSession: (String) -> Unit, + modifier: Modifier = Modifier +) { + Column( + modifier = modifier + .fillMaxSize() + .padding(16.dp) + .verticalScroll(rememberScrollState()), + verticalArrangement = Arrangement.spacedBy(16.dp) + ) { + // Информация об устройстве + DeviceInfoCard(deviceId = uiState.deviceId) + + // Статус подключения + ConnectionStatusCard(connectionState = uiState.connectionState) + + // Настройки подключения + ConnectionSettingsCard( + serverUrl = serverUrl, + onServerUrlChange = onServerUrlChange, + connectionState = uiState.connectionState, + onConnect = onConnect, + onDisconnect = onDisconnect + ) + + // Список активных сессий + ActiveSessionsCard( + sessions = uiState.activeSessions, + onEndSession = onEndSession + ) + } +} + +/** + * Карточка с информацией об устройстве + */ +@Composable +private fun DeviceInfoCard( + deviceId: String, + modifier: Modifier = Modifier +) { + Card( + modifier = modifier.fillMaxWidth(), + elevation = CardDefaults.cardElevation(defaultElevation = 4.dp) + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp) + ) { + Text( + text = stringResource(R.string.device_id_label), + style = MaterialTheme.typography.labelMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + text = deviceId.ifEmpty { "..." }, + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.Bold + ) + } + } +} + +/** + * Карточка настроек подключения + */ +@Composable +private fun ConnectionSettingsCard( + serverUrl: String, + onServerUrlChange: (String) -> Unit, + connectionState: ConnectionState, + onConnect: () -> Unit, + onDisconnect: () -> Unit, + modifier: Modifier = Modifier +) { + Card( + modifier = modifier.fillMaxWidth(), + elevation = CardDefaults.cardElevation(defaultElevation = 4.dp) + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp), + verticalArrangement = Arrangement.spacedBy(16.dp) + ) { + // Поле ввода URL сервера + OutlinedTextField( + value = serverUrl, + onValueChange = onServerUrlChange, + label = { Text(stringResource(R.string.server_url_label)) }, + placeholder = { Text(stringResource(R.string.server_url_hint)) }, + keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri), + enabled = connectionState == ConnectionState.DISCONNECTED, + modifier = Modifier.fillMaxWidth(), + singleLine = true + ) + + // Кнопка подключения/отключения + val isConnected = connectionState == ConnectionState.CONNECTED + val isLoading = connectionState == ConnectionState.CONNECTING || + connectionState == ConnectionState.RECONNECTING + + Button( + onClick = if (isConnected) onDisconnect else onConnect, + modifier = Modifier.fillMaxWidth(), + enabled = !isLoading && serverUrl.isNotBlank() + ) { + if (isLoading) { + CircularProgressIndicator( + modifier = Modifier.size(16.dp), + strokeWidth = 2.dp, + color = MaterialTheme.colorScheme.onPrimary + ) + Spacer(modifier = Modifier.width(8.dp)) + } + Text( + if (isConnected) stringResource(R.string.disconnect_button) + else stringResource(R.string.connect_button) + ) + } + } + } +} + +/** + * Карточка активных сессий + */ +@Composable +private fun ActiveSessionsCard( + sessions: List, + onEndSession: (String) -> Unit, + modifier: Modifier = Modifier +) { + Card( + modifier = modifier.fillMaxWidth(), + elevation = CardDefaults.cardElevation(defaultElevation = 4.dp) + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp) + ) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = stringResource(R.string.active_sessions_label), + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.Bold + ) + + if (sessions.isNotEmpty()) { + Badge { + Text("${sessions.size}") + } + } + } + + Spacer(modifier = Modifier.height(12.dp)) + + SessionsList( + sessions = sessions, + onEndSession = onEndSession + ) + } + } +} diff --git a/app/src/main/java/com/example/godeye/ui/theme/Color.kt b/app/src/main/java/com/example/godeye/ui/theme/Color.kt new file mode 100644 index 0000000..55ca619 --- /dev/null +++ b/app/src/main/java/com/example/godeye/ui/theme/Color.kt @@ -0,0 +1,11 @@ +package com.example.godeye.ui.theme + +import androidx.compose.ui.graphics.Color + +val Purple80 = Color(0xFFD0BCFF) +val PurpleGrey80 = Color(0xFFCCC2DC) +val Pink80 = Color(0xFFEFB8C8) + +val Purple40 = Color(0xFF6650a4) +val PurpleGrey40 = Color(0xFF625b71) +val Pink40 = Color(0xFF7D5260) \ No newline at end of file diff --git a/app/src/main/java/com/example/godeye/ui/theme/Theme.kt b/app/src/main/java/com/example/godeye/ui/theme/Theme.kt new file mode 100644 index 0000000..2fae9d9 --- /dev/null +++ b/app/src/main/java/com/example/godeye/ui/theme/Theme.kt @@ -0,0 +1,58 @@ +package com.example.godeye.ui.theme + +import android.app.Activity +import android.os.Build +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.darkColorScheme +import androidx.compose.material3.dynamicDarkColorScheme +import androidx.compose.material3.dynamicLightColorScheme +import androidx.compose.material3.lightColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.ui.platform.LocalContext + +private val DarkColorScheme = darkColorScheme( + primary = Purple80, + secondary = PurpleGrey80, + tertiary = Pink80 +) + +private val LightColorScheme = lightColorScheme( + primary = Purple40, + secondary = PurpleGrey40, + tertiary = Pink40 + + /* Other default colors to override + background = Color(0xFFFFFBFE), + surface = Color(0xFFFFFBFE), + onPrimary = Color.White, + onSecondary = Color.White, + onTertiary = Color.White, + onBackground = Color(0xFF1C1B1F), + onSurface = Color(0xFF1C1B1F), + */ +) + +@Composable +fun GodEyeTheme( + darkTheme: Boolean = isSystemInDarkTheme(), + // Dynamic color is available on Android 12+ + dynamicColor: Boolean = true, + content: @Composable () -> Unit +) { + val colorScheme = when { + dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> { + val context = LocalContext.current + if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context) + } + + darkTheme -> DarkColorScheme + else -> LightColorScheme + } + + MaterialTheme( + colorScheme = colorScheme, + typography = Typography, + content = content + ) +} \ No newline at end of file diff --git a/app/src/main/java/com/example/godeye/ui/theme/Type.kt b/app/src/main/java/com/example/godeye/ui/theme/Type.kt new file mode 100644 index 0000000..a2e1fa7 --- /dev/null +++ b/app/src/main/java/com/example/godeye/ui/theme/Type.kt @@ -0,0 +1,34 @@ +package com.example.godeye.ui.theme + +import androidx.compose.material3.Typography +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.sp + +// Set of Material typography styles to start with +val Typography = Typography( + bodyLarge = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Normal, + fontSize = 16.sp, + lineHeight = 24.sp, + letterSpacing = 0.5.sp + ) + /* Other default text styles to override + titleLarge = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Normal, + fontSize = 22.sp, + lineHeight = 28.sp, + letterSpacing = 0.sp + ), + labelSmall = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Medium, + fontSize = 11.sp, + lineHeight = 16.sp, + letterSpacing = 0.5.sp + ) + */ +) \ No newline at end of file diff --git a/app/src/main/java/com/example/godeye/ui/viewmodels/MainViewModel.kt b/app/src/main/java/com/example/godeye/ui/viewmodels/MainViewModel.kt new file mode 100644 index 0000000..83a46ee --- /dev/null +++ b/app/src/main/java/com/example/godeye/ui/viewmodels/MainViewModel.kt @@ -0,0 +1,385 @@ +package com.example.godeye.ui.viewmodels + +import android.app.Application +import android.content.ComponentName +import android.content.Context +import android.content.Intent +import android.content.ServiceConnection +import android.os.IBinder +import androidx.lifecycle.AndroidViewModel +import androidx.lifecycle.viewModelScope +import com.example.godeye.managers.PermissionManager +import com.example.godeye.models.* +import com.example.godeye.services.CameraService +import com.example.godeye.services.SocketService +import com.example.godeye.utils.Constants +import com.example.godeye.utils.Logger +import com.example.godeye.utils.getPreferences +import kotlinx.coroutines.flow.* +import kotlinx.coroutines.launch + +/** + * ViewModel для главного экрана приложения + */ +class MainViewModel(application: Application) : AndroidViewModel(application) { + + private val context = getApplication() + private val permissionManager = PermissionManager(context) + + // Сервисы + private var socketService: SocketService? = null + private var cameraService: CameraService? = null + private var socketServiceBound = false + private var cameraServiceBound = false + + // UI State + private val _uiState = MutableStateFlow(MainScreenState()) + val uiState: StateFlow = _uiState.asStateFlow() + + // События для UI + private val _events = MutableSharedFlow() + val events: SharedFlow = _events.asSharedFlow() + + init { + loadSavedSettings() + // startServices() убран отсюда + } + + /** + * Загрузить сохраненные настройки + */ + private fun loadSavedSettings() { + val prefs = context.getPreferences() + val serverUrl = prefs.getString(Constants.PreferenceKeys.SERVER_URL, Constants.DEFAULT_SERVER_URL) ?: Constants.DEFAULT_SERVER_URL + val deviceId = prefs.getString(Constants.PreferenceKeys.DEVICE_ID, "") ?: "" + + _uiState.value = _uiState.value.copy( + serverUrl = serverUrl, + deviceId = deviceId + ) + } + + /** + * Запустить сервисы (вызывать из MainActivity после проверки разрешений) + */ + fun startServices() { + // Запуск SocketService + val socketIntent = Intent(context, SocketService::class.java) + context.startForegroundService(socketIntent) + context.bindService(socketIntent, socketConnection, Context.BIND_AUTO_CREATE) + + // Запуск CameraService + val cameraIntent = Intent(context, CameraService::class.java) + context.startForegroundService(cameraIntent) + context.bindService(cameraIntent, cameraConnection, Context.BIND_AUTO_CREATE) + } + + /** + * ServiceConnection для SocketService + */ + private val socketConnection = object : ServiceConnection { + override fun onServiceConnected(className: ComponentName, service: IBinder) { + val binder = service as SocketService.LocalBinder + socketService = binder.getService() + socketServiceBound = true + + Logger.d("SocketService connected") + observeSocketService() + } + + override fun onServiceDisconnected(arg0: ComponentName) { + socketServiceBound = false + socketService = null + Logger.d("SocketService disconnected") + } + } + + /** + * ServiceConnection для CameraService + */ + private val cameraConnection = object : ServiceConnection { + override fun onServiceConnected(className: ComponentName, service: IBinder) { + val binder = service as CameraService.LocalBinder + cameraService = binder.getService() + cameraServiceBound = true + + Logger.d("CameraService connected") + observeCameraService() + setupCameraServiceCallbacks() + } + + override fun onServiceDisconnected(arg0: ComponentName) { + cameraServiceBound = false + cameraService = null + Logger.d("CameraService disconnected") + } + } + + /** + * Наблюдать за состоянием SocketService + */ + private fun observeSocketService() { + val service = socketService ?: return + + viewModelScope.launch { + service.connectionState.collect { state -> + _uiState.value = _uiState.value.copy(connectionState = state) + } + } + + viewModelScope.launch { + service.deviceId.collect { deviceId -> + _uiState.value = _uiState.value.copy(deviceId = deviceId) + } + } + + viewModelScope.launch { + service.error.collect { error -> + error?.let { + _uiState.value = _uiState.value.copy(error = it) + _events.emit(UiEvent.ShowError(it)) + } + } + } + + viewModelScope.launch { + service.cameraRequest.collect { request -> + request?.let { + _uiState.value = _uiState.value.copy(showCameraRequest = it) + _events.emit(UiEvent.ShowCameraRequestDialog(it)) + } + } + } + + viewModelScope.launch { + service.webrtcOffer.collect { offer -> + offer?.let { + handleWebRTCOffer(it) + service.clearWebRTCOffer() + } + } + } + + viewModelScope.launch { + service.webrtcIceCandidate.collect { candidate -> + candidate?.let { + handleWebRTCIceCandidate(it) + } + } + } + + viewModelScope.launch { + service.cameraSwitchRequest.collect { request -> + request?.let { (sessionId, cameraType) -> + handleCameraSwitch(sessionId, cameraType) + } + } + } + + viewModelScope.launch { + service.sessionDisconnect.collect { sessionId -> + sessionId?.let { + handleSessionDisconnect(it) + } + } + } + } + + /** + * Наблюдать за состоянием CameraService + */ + private fun observeCameraService() { + val service = cameraService ?: return + + viewModelScope.launch { + service.getSessionManager().activeSessions.collect { sessions -> + _uiState.value = _uiState.value.copy(activeSessions = sessions) + } + } + + viewModelScope.launch { + service.error.collect { error -> + error?.let { + _uiState.value = _uiState.value.copy(error = it) + _events.emit(UiEvent.ShowError(it)) + } + } + } + } + + /** + * Настроить callbacks для CameraService + */ + private fun setupCameraServiceCallbacks() { + cameraService?.setWebRTCCallbacks( + onOfferCreated = { sessionId, offer -> + // WebRTC offer создан, но в нашем случае мы получаем offer от оператора + Logger.d("WebRTC offer created for session: $sessionId") + }, + onIceCandidateCreated = { sessionId, candidate, sdpMid, sdpMLineIndex -> + socketService?.sendIceCandidate(sessionId, candidate, sdpMid, sdpMLineIndex) + } + ) + } + + /** + * Подключиться к серверу + */ + fun connect() { + if (!permissionManager.hasCriticalPermissions()) { + _events.tryEmit(UiEvent.RequestPermissions) + return + } + + val serverUrl = _uiState.value.serverUrl + if (serverUrl.isBlank()) { + _events.tryEmit(UiEvent.ShowError(AppError.SocketError("Введите URL сервера"))) + return + } + + // Сохраняем URL сервера + context.getPreferences().edit() + .putString(Constants.PreferenceKeys.SERVER_URL, serverUrl) + .apply() + + _uiState.value = _uiState.value.copy(isLoading = true) + socketService?.connect(serverUrl) + } + + /** + * Отключиться от сервера + */ + fun disconnect() { + _uiState.value = _uiState.value.copy(isLoading = true) + socketService?.disconnect() + cameraService?.endAllSessions() + } + + /** + * Обновить URL сервера + */ + fun updateServerUrl(url: String) { + _uiState.value = _uiState.value.copy(serverUrl = url) + } + + /** + * Ответить на запрос камеры + */ + fun respondToCameraRequest(sessionId: String, accepted: Boolean, reason: String? = null) { + socketService?.sendCameraResponse(sessionId, accepted, reason) + + if (accepted) { + // Получаем информацию о запросе + val request = _uiState.value.showCameraRequest + if (request != null && request.sessionId == sessionId) { + // Начинаем камера сессию + cameraService?.startCameraSession(sessionId, request.operatorId, request.cameraType) + } + } + + // Очищаем запрос из UI + _uiState.value = _uiState.value.copy(showCameraRequest = null) + socketService?.clearCameraRequest() + } + + /** + * Завершить сессию + */ + fun endSession(sessionId: String) { + cameraService?.endSession(sessionId) + } + + /** + * Обработать WebRTC Offer + */ + private fun handleWebRTCOffer(offer: WebRTCMessage) { + val sessionId = offer.sessionId + val offerSdp = offer.sdp ?: return + + Logger.d("Handling WebRTC offer for session: $sessionId") + // В нашем случае мы не обрабатываем offer, так как создаем его сами + // Но можно добавить логику для обработки offer от оператора + } + + /** + * Обработать WebRTC ICE Candidate + */ + private fun handleWebRTCIceCandidate(candidate: WebRTCMessage) { + val sessionId = candidate.sessionId + val candidateSdp = candidate.candidate ?: return + val sdpMid = candidate.sdpMid ?: return + val sdpMLineIndex = candidate.sdpMLineIndex ?: return + + Logger.d("Handling ICE candidate for session: $sessionId") + cameraService?.addIceCandidate(sessionId, candidateSdp, sdpMid, sdpMLineIndex) + } + + /** + * Обработать переключение камеры + */ + private fun handleCameraSwitch(sessionId: String, newCameraType: String) { + Logger.d("Handling camera switch for session $sessionId to $newCameraType") + cameraService?.switchCamera(sessionId, newCameraType) + } + + /** + * Обработать отключение сессии + */ + private fun handleSessionDisconnect(sessionId: String) { + Logger.d("Handling session disconnect: $sessionId") + cameraService?.endSession(sessionId) + } + + /** + * Очистить ошибку + */ + fun clearError() { + _uiState.value = _uiState.value.copy(error = null) + socketService?.clearError() + cameraService?.clearError() + } + + /** + * Проверить разрешения + */ + fun checkPermissions(): Boolean { + return permissionManager.hasAllRequiredPermissions() + } + + /** + * Получить отсутствующие разрешения + */ + fun getMissingPermissions(): List { + return permissionManager.getMissingPermissions() + } + + override fun onCleared() { + super.onCleared() + + // Отвязка сервисов + try { + if (socketServiceBound) { + context.unbindService(socketConnection) + socketServiceBound = false + } + if (cameraServiceBound) { + context.unbindService(cameraConnection) + cameraServiceBound = false + } + } catch (e: Exception) { + Logger.e("Error unbinding services", e) + } + + Logger.d("MainViewModel cleared") + } +} + +/** + * События UI для обработки в Activity/Compose + */ +sealed class UiEvent { + object RequestPermissions : UiEvent() + data class ShowError(val error: AppError) : UiEvent() + data class ShowCameraRequestDialog(val request: CameraRequest) : UiEvent() + data class ShowMessage(val message: String) : UiEvent() +} diff --git a/app/src/main/java/com/example/godeye/utils/Constants.kt b/app/src/main/java/com/example/godeye/utils/Constants.kt new file mode 100644 index 0000000..ff58c7a --- /dev/null +++ b/app/src/main/java/com/example/godeye/utils/Constants.kt @@ -0,0 +1,49 @@ +package com.example.godeye.utils + +object Constants { + // WebSocket события + object SocketEvents { + const val REGISTER_ANDROID = "register:android" + const val REGISTER_SUCCESS = "register:success" + const val REGISTER_ERROR = "register:error" + const val CAMERA_REQUEST = "camera:request" + const val CAMERA_RESPONSE = "camera:response" + const val CAMERA_DISCONNECT = "camera:disconnect" + const val CAMERA_SWITCH = "camera:switch" + const val WEBRTC_OFFER = "webrtc:offer" + const val WEBRTC_ANSWER = "webrtc:answer" + const val WEBRTC_ICE_CANDIDATE = "webrtc:ice-candidate" + } + + // Типы камер + object CameraTypes { + const val BACK = "back" + const val FRONT = "front" + const val WIDE = "wide" + const val TELEPHOTO = "telephoto" + } + + // SharedPreferences ключи + object PreferenceKeys { + const val SERVER_URL = "server_url" + const val DEVICE_ID = "device_id" + const val AUTO_ACCEPT_REQUESTS = "auto_accept_requests" + const val CAMERA_QUALITY = "camera_quality" + const val NOTIFICATION_ENABLED = "notification_enabled" + } + + // Настройки по умолчанию + const val DEFAULT_SERVER_URL = "http://10.0.2.2:3001" // Специальный IP для Android эмулятора + const val SOCKET_CONNECTION_TIMEOUT = 10000L + const val WEBRTC_CONNECTION_TIMEOUT = 15000L + + // Уведомления + const val NOTIFICATION_CHANNEL_ID = "godeye_service_channel" + const val FOREGROUND_SERVICE_ID = 1001 + + // WebRTC настройки + val STUN_SERVERS = listOf( + "stun:stun.l.google.com:19302", + "stun:stun1.l.google.com:19302" + ) +} diff --git a/app/src/main/java/com/example/godeye/utils/Extensions.kt b/app/src/main/java/com/example/godeye/utils/Extensions.kt new file mode 100644 index 0000000..40efb95 --- /dev/null +++ b/app/src/main/java/com/example/godeye/utils/Extensions.kt @@ -0,0 +1,140 @@ +package com.example.godeye.utils + +import android.content.Context +import android.content.SharedPreferences +import android.hardware.camera2.CameraCharacteristics +import android.hardware.camera2.CameraManager +import android.util.Log +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.ui.platform.LocalLifecycleOwner +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.repeatOnLifecycle +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.collect +import java.util.* + +/** + * Расширения для Context + */ +fun Context.getPreferences(): SharedPreferences { + return getSharedPreferences("godeye_prefs", Context.MODE_PRIVATE) +} + +fun Context.generateDeviceId(): String { + val prefs = getPreferences() + var deviceId = prefs.getString(Constants.PreferenceKeys.DEVICE_ID, null) + if (deviceId == null) { + deviceId = "android_${UUID.randomUUID().toString().take(8)}" + prefs.edit().putString(Constants.PreferenceKeys.DEVICE_ID, deviceId).apply() + } + return deviceId +} + +/** + * Расширения для CameraManager + */ +fun CameraManager.getAvailableCameraTypes(): List { + val cameras = mutableListOf() + try { + for (cameraId in cameraIdList) { + val characteristics = getCameraCharacteristics(cameraId) + val facing = characteristics.get(CameraCharacteristics.LENS_FACING) + + when (facing) { + CameraCharacteristics.LENS_FACING_BACK -> { + // Проверяем на широкоугольный и телеобъектив + val focalLengths = characteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS) + if (focalLengths != null && focalLengths.isNotEmpty()) { + val minFocalLength = focalLengths.minOrNull() ?: 0f + val maxFocalLength = focalLengths.maxOrNull() ?: 0f + + when { + minFocalLength < 2.8f -> cameras.add(Constants.CameraTypes.WIDE) + maxFocalLength > 5.5f -> cameras.add(Constants.CameraTypes.TELEPHOTO) + else -> cameras.add(Constants.CameraTypes.BACK) + } + } else { + cameras.add(Constants.CameraTypes.BACK) + } + } + CameraCharacteristics.LENS_FACING_FRONT -> cameras.add(Constants.CameraTypes.FRONT) + } + } + } catch (e: Exception) { + Log.e("CameraExtensions", "Error getting cameras", e) + // Добавляем базовые камеры как fallback + cameras.add(Constants.CameraTypes.BACK) + cameras.add(Constants.CameraTypes.FRONT) + } + return cameras.distinct() +} + +fun CameraManager.getCameraIdForType(cameraType: String): String? { + return try { + for (cameraId in cameraIdList) { + val characteristics = getCameraCharacteristics(cameraId) + val facing = characteristics.get(CameraCharacteristics.LENS_FACING) + + when (cameraType) { + Constants.CameraTypes.FRONT -> { + if (facing == CameraCharacteristics.LENS_FACING_FRONT) { + return cameraId + } + } + Constants.CameraTypes.BACK, + Constants.CameraTypes.WIDE, + Constants.CameraTypes.TELEPHOTO -> { + if (facing == CameraCharacteristics.LENS_FACING_BACK) { + // Для простоты используем первую найденную заднюю камеру + // В реальном проекте здесь была бы более сложная логика + return cameraId + } + } + } + } + null + } catch (e: Exception) { + Log.e("CameraExtensions", "Error finding camera for type $cameraType", e) + null + } +} + +/** + * Compose расширения для Flow + */ +@Composable +fun Flow.collectAsEffect( + key: Any? = null, + action: suspend (T) -> Unit +) { + val lifecycleOwner = LocalLifecycleOwner.current + LaunchedEffect(key) { + lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) { + collect(action) + } + } +} + +/** + * Логирование + */ +object Logger { + private const val TAG = "GodEye" + + fun d(message: String, tag: String = TAG) { + Log.d(tag, message) + } + + fun e(message: String, throwable: Throwable? = null, tag: String = TAG) { + Log.e(tag, message, throwable) + } + + fun i(message: String, tag: String = TAG) { + Log.i(tag, message) + } + + fun w(message: String, tag: String = TAG) { + Log.w(tag, message) + } +} diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 0000000..07d5da9 --- /dev/null +++ b/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/ic_launcher_foreground.xml b/app/src/main/res/drawable/ic_launcher_foreground.xml new file mode 100644 index 0000000..2b068d1 --- /dev/null +++ b/app/src/main/res/drawable/ic_launcher_foreground.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml new file mode 100644 index 0000000..6f3b755 --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml new file mode 100644 index 0000000..6f3b755 --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/app/src/main/res/mipmap-hdpi/ic_launcher.webp new file mode 100644 index 0000000..c209e78 Binary files /dev/null and b/app/src/main/res/mipmap-hdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp new file mode 100644 index 0000000..b2dfe3d Binary files /dev/null and b/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/app/src/main/res/mipmap-mdpi/ic_launcher.webp new file mode 100644 index 0000000..4f0f1d6 Binary files /dev/null and b/app/src/main/res/mipmap-mdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp new file mode 100644 index 0000000..62b611d Binary files /dev/null and b/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher.webp new file mode 100644 index 0000000..948a307 Binary files /dev/null and b/app/src/main/res/mipmap-xhdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp new file mode 100644 index 0000000..1b9a695 Binary files /dev/null and b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp new file mode 100644 index 0000000..28d4b77 Binary files /dev/null and b/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp new file mode 100644 index 0000000..9287f50 Binary files /dev/null and b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp new file mode 100644 index 0000000..aa7d642 Binary files /dev/null and b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp new file mode 100644 index 0000000..9126ae3 Binary files /dev/null and b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml new file mode 100644 index 0000000..f8c6127 --- /dev/null +++ b/app/src/main/res/values/colors.xml @@ -0,0 +1,10 @@ + + + #FFBB86FC + #FF6200EE + #FF3700B3 + #FF03DAC5 + #FF018786 + #FF000000 + #FFFFFFFF + \ No newline at end of file diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml new file mode 100644 index 0000000..33c0c97 --- /dev/null +++ b/app/src/main/res/values/strings.xml @@ -0,0 +1,80 @@ + + GodEye Signal Center + + + ID устройства: + URL сервера: + http://192.168.1.100:3001 + Статус подключения: + Подключиться + Отключиться + Активные сессии: + Нет активных сессий + + + Отключено + Подключение... + Подключено + Ошибка подключения + Переподключение... + + + Запрос доступа к камере + Оператор %1$s запрашивает доступ к камере %2$s + ID сессии: %1$s + Разрешить + Отклонить + Запомнить для этого оператора + + + Основная + Фронтальная + Широкоугольная + Телеобъектив + + + Оператор: + Камера: + Длительность: + WebRTC: %1$s + Подключено + Отключено + Завершить + + + Ошибка сети + Нет разрешения на камеру + Нет разрешения на микрофон + Камера недоступна + Ошибка WebRTC соединения + Ошибка WebSocket: %1$s + Ошибка камеры: %1$s + Неизвестная ошибка + + + Необходимы разрешения + Для работы приложения необходимы разрешения на камеру, микрофон и уведомления + Предоставить разрешения + Без разрешений приложение не может работать + + + GodEye Signal Center + Подключено к серверу + Отключено от сервера + GodEye Camera + Активных сессий: %1$d + Камера готова к работе + + + OK + Отмена + Настройки + Загрузка... + Повторить + + + %1$02d:%2$02d:%3$02d + сек + мин + ч + \ No newline at end of file diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml new file mode 100644 index 0000000..5d63c43 --- /dev/null +++ b/app/src/main/res/values/themes.xml @@ -0,0 +1,5 @@ + + + +