Camera, Location, Sensors, Media and Connectivity

// feature/trails/src/main/kotlin/com/example/trailmate/feature/trails/photo/PhotoCaptureScreen.kt
@Composable
fun PhotoCaptureScreen(
    onPhotoSaved: (Uri) -> Unit,
    viewModel: PhotoCaptureViewModel = hiltViewModel()
) {
    val lifecycleOwner = LocalLifecycleOwner.current
    val surfaceRequest by viewModel.surfaceRequest.collectAsStateWithLifecycle()

    LaunchedEffect(lifecycleOwner) {
        // Suspends while bound; leaving the composition cancels it and unbinds the camera.
        viewModel.bindToCamera(lifecycleOwner)
    }

    Box(modifier = Modifier.fillMaxSize()) {
        surfaceRequest?.let { request ->
            CameraXViewfinder(
                surfaceRequest = request,
                modifier = Modifier.fillMaxSize()
            )
        }
        FloatingActionButton(
            onClick = {
                viewModel.capturePhoto { uri -> onPhotoSaved(uri) }
            },
            modifier = Modifier.align(Alignment.BottomCenter).padding(24.dp)
        ) {
            Icon(Icons.Default.PhotoCamera, contentDescription = "Take photo")
        }
    }
}

// feature/trails/src/main/kotlin/com/example/trailmate/feature/trails/photo/PhotoCaptureViewModel.kt
@HiltViewModel
class PhotoCaptureViewModel @Inject constructor(
    @ApplicationContext private val context: Context
) : ViewModel() {

    private val _surfaceRequest = MutableStateFlow<SurfaceRequest?>(null)
    val surfaceRequest: StateFlow<SurfaceRequest?> = _surfaceRequest.asStateFlow()

    private val preview = Preview.Builder().build().apply {
        setSurfaceProvider { request -> _surfaceRequest.value = request }
    }
    private val imageCapture = ImageCapture.Builder()
        .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
        .build()

    suspend fun bindToCamera(lifecycleOwner: LifecycleOwner) {
        val cameraProvider = ProcessCameraProvider.awaitInstance(context)
        cameraProvider.bindToLifecycle(
            lifecycleOwner,
            CameraSelector.DEFAULT_BACK_CAMERA,
            preview,
            imageCapture
        )
        try {
            awaitCancellation()
        } finally {
            cameraProvider.unbind(preview, imageCapture)
            _surfaceRequest.value = null
        }
    }

    fun capturePhoto(onSaved: (Uri) -> Unit) {
        val name = "TrailMate_${System.currentTimeMillis()}.jpg"
        val contentValues = ContentValues().apply {
            put(MediaStore.MediaColumns.DISPLAY_NAME, name)
            put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
            put(MediaStore.MediaColumns.RELATIVE_PATH, "Pictures/TrailMate")
        }
        val outputOptions = ImageCapture.OutputFileOptions.Builder(
            context.contentResolver,
            MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
            contentValues
        ).build()

        imageCapture.takePicture(
            outputOptions,
            ContextCompat.getMainExecutor(context),
            object : ImageCapture.OnImageSavedCallback {
                override fun onImageSaved(output: ImageCapture.OutputFileResults) {
                    output.savedUri?.let(onSaved)
                }
                override fun onError(exception: ImageCaptureException) {
                    // surface exception through UiState, as elsewhere in TrailMate
                }
            }
        )
    }
}

// core/data/src/main/kotlin/com/example/trailmate/core/data/location/LocationSource.kt
class LocationSource @Inject constructor(
    @ApplicationContext private val context: Context
) {
    private val client = LocationServices.getFusedLocationProviderClient(context)

    suspend fun currentLocation(): Location? {
        val cancellationTokenSource = CancellationTokenSource()
        return client.getCurrentLocation(
            Priority.PRIORITY_BALANCED_POWER_ACCURACY,
            cancellationTokenSource.token
        ).await()
    }
}

// core/data/src/main/kotlin/com/example/trailmate/core/data/location/LocationSource.kt
fun locationUpdates(intervalMillis: Long = 5_000L): Flow<Location> = callbackFlow {
    val request = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, intervalMillis).build()
    val callback = object : LocationCallback() {
        override fun onLocationResult(result: LocationResult) {
            result.lastLocation?.let { trySend(it) }
        }
    }
    client.requestLocationUpdates(request, callback, Looper.getMainLooper())
    awaitClose { client.removeLocationUpdates(callback) }
}

// core/data/src/main/kotlin/com/example/trailmate/core/data/location/TrailheadGeofences.kt
fun registerTrailheadGeofence(
    context: Context,
    client: GeofencingClient,
    trail: Trail,
    latitude: Double,
    longitude: Double
) {
    val geofence = Geofence.Builder()
        .setRequestId(trail.id)
        .setCircularRegion(latitude, longitude, /* radiusMeters = */ 200f)
        .setExpirationDuration(Geofence.NEVER_EXPIRE)
        .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER)
        .build()
    val request = GeofencingRequest.Builder()
        .addGeofence(geofence)
        .setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER)
        .build()
    val pendingIntent = PendingIntent.getBroadcast(
        context, 0, Intent(context, GeofenceBroadcastReceiver::class.java),
        // Play services fills in the transition data, so the intent must be mutable on API 31+.
        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
    )
    client.addGeofences(request, pendingIntent)
}

// feature/trails/src/main/kotlin/com/example/trailmate/feature/trails/audio/TrailAudioGuideScreen.kt
@Composable
fun TrailAudioGuideScreen(audioUrl: String, viewModel: TrailAudioGuideViewModel = hiltViewModel()) {
    val exoPlayer = viewModel.player
    LaunchedEffect(audioUrl) {
        exoPlayer.setMediaItem(MediaItem.fromUri(audioUrl))
        exoPlayer.prepare()
        exoPlayer.play()
    }
    AndroidView(
        modifier = Modifier.fillMaxWidth(),
        factory = { context -> PlayerView(context).apply { player = exoPlayer } }
    )
}

// feature/trails/src/main/kotlin/com/example/trailmate/feature/trails/audio/TrailAudioGuideViewModel.kt
@HiltViewModel
class TrailAudioGuideViewModel @Inject constructor(
    @ApplicationContext context: Context
) : ViewModel() {
    val player: ExoPlayer = ExoPlayer.Builder(context).build()

    override fun onCleared() {
        player.release()
    }
}

// feature/trails/src/main/kotlin/com/example/trailmate/feature/trails/audio/TrailAudioPlaybackService.kt
class TrailAudioPlaybackService : MediaSessionService() {
    private lateinit var player: ExoPlayer
    private lateinit var mediaSession: MediaSession

    override fun onCreate() {
        super.onCreate()
        player = ExoPlayer.Builder(this).build()
        mediaSession = MediaSession.Builder(this, player).build()
    }

    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession = mediaSession

    override fun onDestroy() {
        mediaSession.run { player.release(); release() }
        super.onDestroy()
    }
}