linfeng/record-tool
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

支持录制中切换广角/主摄

Browse Source
This commit is contained in:
linfeng
2026-07-01 09:59:21 +08:00
parent f6347e99cd
commit da2e69b014
11 changed files with 656 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files
android/app/src/main/kotlin/com/run/sportsx/recording/RecordingCameraController.kt
+262 -41
View File
@@ -24,8 +24,10 @@ import androidx.camera.video.VideoRecordEvent
import androidx.camera.view.PreviewView
import androidx.core.content.ContextCompat
import androidx.lifecycle.LifecycleOwner
import java.io.File
import java.util.concurrent.Executor
import java.util.concurrent.ExecutionException
import java.util.concurrent.Executors
import kotlin.math.atan
import kotlin.math.round
@@ -33,6 +35,7 @@ class RecordingCameraController(
private val appContext: Context,
) {
private val mainExecutor: Executor = ContextCompat.getMainExecutor(appContext)
private val ioExecutor = Executors.newSingleThreadExecutor()
private var cameraProvider: ProcessCameraProvider? = null
private var preview: Preview? = null
@@ -45,6 +48,12 @@ class RecordingCameraController(
private var activeRecording: Recording? = null
private var boundLifecycleOwner: LifecycleOwner? = null
private var currentZoomRatio: Float = 1f
private var activeWithAudio: Boolean = true
private var activeDisplayName: String? = null
private var currentSegmentFile: File? = null
private val segmentFiles = mutableListOf<File>()
private var nextSegmentIndex: Int = 1
private var isSwitchingLens: Boolean = false
var status: RecordingStatus = RecordingStatus(RecordingState.IDLE)
private set
@@ -53,7 +62,9 @@ class RecordingCameraController(
private var recordingStartedAt: Long = 0L
private var latestOutputPath: String? = null
private var latestSegmentOutputPaths: List<String> = emptyList()
private var pendingStopCallback: ((String?) -> Unit)? = null
private var pendingSegmentSwitch: PendingSegmentSwitch? = null
fun bindPreview(
lifecycleOwner: LifecycleOwner,
@@ -142,21 +153,55 @@ class RecordingCameraController(
return
}
if (activeRecording != null || isSwitchingLens) {
onStarted(false, "Already recording")
return
}
activeWithAudio = withAudio
activeDisplayName = displayName
segmentFiles.clear()
nextSegmentIndex = 1
latestOutputPath = null
latestSegmentOutputPaths = emptyList()
recordingStartedAt = System.currentTimeMillis()
updateStatus(
RecordingStatus(
RecordingState.RECORDING,
outputPath = latestOutputPath,
),
)
startNewSegment(updateStatusOnStart = false, onStarted = onStarted)
}
private fun startNewSegment(
updateStatusOnStart: Boolean,
onStarted: (Boolean, String?) -> Unit,
) {
val capture = videoCapture
if (capture == null || boundLifecycleOwner == null) {
onStarted(false, "Camera not ready")
return
}
if (activeRecording != null) {
onStarted(false, "Already recording")
return
}
val outputOptions =
RecordingOutputFactory.buildMediaStoreOutputOptions(
val segmentFile =
RecordingOutputFactory.createSegmentFile(
appContext,
displayName,
activeDisplayName,
nextSegmentIndex++,
)
latestOutputPath = null
currentSegmentFile = segmentFile
val outputOptions = RecordingOutputFactory.buildSegmentOutputOptions(segmentFile)
val pending =
capture.output.prepareRecording(appContext, outputOptions).apply {
if (withAudio) {
if (activeWithAudio) {
val granted =
ContextCompat.checkSelfPermission(
appContext,
@@ -168,48 +213,25 @@ class RecordingCameraController(
}
}
recordingStartedAt = System.currentTimeMillis()
updateStatus(
RecordingStatus(
RecordingState.RECORDING,
outputPath = latestOutputPath,
),
)
if (updateStatusOnStart) {
updateStatus(
RecordingStatus(
RecordingState.RECORDING,
outputPath = latestOutputPath,
elapsedMillis = elapsedMillis(),
),
)
}
activeRecording =
pending.start(mainExecutor) { event ->
when (event) {
is VideoRecordEvent.Start -> Unit
is VideoRecordEvent.Finalize -> {
activeRecording = null
if (event.hasError()) {
updateStatus(
RecordingStatus(
RecordingState.ERROR,
message = event.cause?.message
?: "Recording failed",
),
)
} else {
latestOutputPath = event.outputResults.outputUri.toString()
updateStatus(
RecordingStatus(
RecordingState.PREVIEWING,
outputPath = latestOutputPath,
elapsedMillis =
System.currentTimeMillis() -
recordingStartedAt,
),
)
}
val stopCallback = pendingStopCallback
pendingStopCallback = null
stopCallback?.invoke(latestOutputPath)
}
is VideoRecordEvent.Finalize -> handleFinalize(event, segmentFile)
}
}
onStarted(true, latestOutputPath ?: "recording")
onStarted(true, segmentFile.absolutePath)
}
fun stopRecording(onStopped: (String?) -> Unit) {
@@ -218,12 +240,18 @@ class RecordingCameraController(
onStopped(latestOutputPath)
return
}
if (isSwitchingLens) {
onStopped(null)
return
}
pendingStopCallback = onStopped
val elapsed = elapsedMillis()
updateStatus(
RecordingStatus(
RecordingState.STOPPING,
outputPath = latestOutputPath,
elapsedMillis = elapsed,
),
)
@@ -231,6 +259,119 @@ class RecordingCameraController(
activeRecording = null
}
private fun handleFinalize(
event: VideoRecordEvent.Finalize,
segmentFile: File,
) {
activeRecording = null
if (!event.hasError() && segmentFile.exists() && segmentFile.length() > 0L) {
segmentFiles.add(segmentFile)
}
val segmentSwitch = pendingSegmentSwitch
if (segmentSwitch != null) {
pendingSegmentSwitch = null
if (event.hasError()) {
isSwitchingLens = false
val message = event.cause?.message ?: "Recording segment failed"
updateStatus(RecordingStatus(RecordingState.ERROR, message = message))
segmentSwitch.onComplete(false, zoomCapabilitiesMap(), message)
return
}
continueSegmentSwitch(segmentSwitch)
return
}
val stopCallback = pendingStopCallback
pendingStopCallback = null
if (stopCallback == null) {
return
}
if (event.hasError()) {
val message = event.cause?.message ?: "Recording failed"
updateStatus(RecordingStatus(RecordingState.ERROR, message = message))
stopCallback.invoke(null)
return
}
finalizeRecordingOutput(stopCallback)
}
private fun finalizeRecordingOutput(stopCallback: (String?) -> Unit) {
val segments = segmentFiles.toList()
val displayName = activeDisplayName
ioExecutor.execute {
try {
val mergedFile = RecordingOutputFactory.createMergeFile(appContext, displayName)
RecordingSegmentMuxer.mergeOrCopy(segments, mergedFile)
val outputUri =
RecordingOutputFactory.publishToMediaStore(
appContext,
displayName,
mergedFile,
)
latestOutputPath = outputUri
latestSegmentOutputPaths = emptyList()
cleanupSegmentFiles(segments + mergedFile)
mainExecutor.execute {
val elapsed = System.currentTimeMillis() - recordingStartedAt
updateStatus(
RecordingStatus(
RecordingState.PREVIEWING,
outputPath = latestOutputPath,
elapsedMillis = elapsed,
),
)
stopCallback.invoke(latestOutputPath)
}
} catch (error: Exception) {
Log.e(TAG, "finalizeRecordingOutput failed", error)
val publishedParts = publishSegmentsAfterMergeFailure(segments, displayName)
latestOutputPath = publishedParts.firstOrNull()
latestSegmentOutputPaths = publishedParts
mainExecutor.execute {
updateStatus(
RecordingStatus(
RecordingState.ERROR,
outputPath = latestOutputPath,
message = error.message ?: "保存到文件夹失败",
),
)
stopCallback.invoke(latestOutputPath)
}
}
}
}
private fun publishSegmentsAfterMergeFailure(
segments: List<File>,
displayName: String?,
): List<String> {
return segments.mapIndexedNotNull { index, segment ->
try {
RecordingOutputFactory.publishPartToMediaStore(
appContext,
displayName,
segment,
index + 1,
)
} catch (error: Exception) {
Log.e(TAG, "publish segment after merge failure failed", error)
null
}
}
}
private fun cleanupSegmentFiles(files: List<File>) {
files.forEach { file ->
try {
file.delete()
} catch (_: Exception) {
}
}
}
fun zoomCapabilitiesMap(): Map<String, Any> {
val zoomState = camera?.cameraInfo?.zoomState?.value
val cameraXMin = zoomState?.minZoomRatio ?: 1f
@@ -271,6 +412,10 @@ class RecordingCameraController(
) {
val boundCamera = camera
if (boundCamera == null) {
if (isSwitchingLens) {
onComplete(false, zoomCapabilitiesMap(), "Camera lens switch is already in progress")
return
}
val clamped =
if (ratio < 1.0 && hasUltraWideCamera()) {
ultraWideZoomRatio
@@ -337,12 +482,20 @@ class RecordingCameraController(
fun unbind() {
activeRecording?.stop()
activeRecording = null
pendingSegmentSwitch = null
pendingStopCallback = null
isSwitchingLens = false
cameraProvider?.unbindAll()
cameraProvider = null
preview = null
videoCapture = null
camera = null
boundLifecycleOwner = null
currentSegmentFile = null
cleanupSegmentFiles(segmentFiles)
segmentFiles.clear()
nextSegmentIndex = 1
activeDisplayName = null
currentLensMode = LensMode.MAIN
currentZoomRatio = 1f
ultraWideZoomRatio = DEFAULT_ULTRA_WIDE_ZOOM_RATIO
@@ -354,6 +507,8 @@ class RecordingCameraController(
return System.currentTimeMillis() - recordingStartedAt
}
fun segmentOutputPaths(): List<String> = latestSegmentOutputPaths
private fun updateStatus(next: RecordingStatus) {
status = next
statusListener?.invoke(next)
@@ -794,7 +949,11 @@ class RecordingCameraController(
return
}
if (activeRecording != null) {
onComplete(false, zoomCapabilitiesMap(), "Cannot switch physical camera while recording")
switchRecordingSegmentToLens(
LensMode.ULTRA_WIDE,
ultraWideZoomRatio.toDouble(),
onComplete,
)
return
}
val provider = cameraProvider
@@ -828,7 +987,7 @@ class RecordingCameraController(
onComplete: (Boolean, Map<String, Any>, String?) -> Unit,
) {
if (activeRecording != null) {
onComplete(false, zoomCapabilitiesMap(), "Cannot switch physical camera while recording")
switchRecordingSegmentToLens(LensMode.MAIN, ratio, onComplete)
return
}
val provider = cameraProvider
@@ -852,6 +1011,62 @@ class RecordingCameraController(
return ultraWideCameraId != null
}
private fun switchRecordingSegmentToLens(
targetLensMode: LensMode,
targetRatio: Double,
onComplete: (Boolean, Map<String, Any>, String?) -> Unit,
) {
val recording = activeRecording
if (recording == null) {
onComplete(false, zoomCapabilitiesMap(), "Recording is not active")
return
}
if (isSwitchingLens || pendingSegmentSwitch != null) {
onComplete(false, zoomCapabilitiesMap(), "Camera lens switch is already in progress")
return
}
pendingSegmentSwitch = PendingSegmentSwitch(targetLensMode, targetRatio, onComplete)
isSwitchingLens = true
recording.stop()
activeRecording = null
}
private fun continueSegmentSwitch(request: PendingSegmentSwitch) {
val provider = cameraProvider
val lifecycleOwner = boundLifecycleOwner
if (provider == null || lifecycleOwner == null) {
isSwitchingLens = false
request.onComplete(false, zoomCapabilitiesMap(), "Camera is not ready")
return
}
try {
currentLensMode = request.targetLensMode
currentZoomRatio =
if (request.targetLensMode == LensMode.ULTRA_WIDE) {
ultraWideZoomRatio
} else {
request.targetRatio.toFloat().coerceAtLeast(1f)
}
bindUseCases(provider, lifecycleOwner, selectorForCurrentLensMode())
applyCurrentZoom()
startNewSegment(updateStatusOnStart = true) { started, message ->
isSwitchingLens = false
if (started) {
request.onComplete(true, zoomCapabilitiesMap(), null)
} else {
updateStatus(RecordingStatus(RecordingState.ERROR, message = message))
request.onComplete(false, zoomCapabilitiesMap(), message)
}
}
} catch (error: Exception) {
Log.e(TAG, "continueSegmentSwitch failed", error)
isSwitchingLens = false
updateStatus(RecordingStatus(RecordingState.ERROR, message = error.message))
request.onComplete(false, zoomCapabilitiesMap(), error.message)
}
}
private fun ProcessCameraProvider.hasCameraSafely(selector: CameraSelector): Boolean {
return try {
hasCamera(selector)
@@ -895,6 +1110,12 @@ class RecordingCameraController(
val zoomRatio: Float,
)
private data class PendingSegmentSwitch(
val targetLensMode: LensMode,
val targetRatio: Double,
val onComplete: (Boolean, Map<String, Any>, String?) -> Unit,
)
companion object {
private const val TAG = "RecordingCamera"
private const val DEFAULT_ULTRA_WIDE_ZOOM_RATIO = 0.6f
android/app/src/main/kotlin/com/run/sportsx/recording/RecordingOutputFactory.kt
+65 -9
View File
@@ -4,7 +4,9 @@ import android.content.ContentValues
import android.content.Context
import android.os.Build
import android.provider.MediaStore
import androidx.camera.video.MediaStoreOutputOptions
import androidx.camera.video.FileOutputOptions
import java.io.File
import java.io.FileInputStream
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
@@ -13,10 +15,37 @@ object RecordingOutputFactory {
private const val RELATIVE_PATH = "Movies/酷跑录像工作台"
private const val MIME_TYPE = "video/mp4"
fun buildMediaStoreOutputOptions(
fun buildSegmentOutputOptions(segmentFile: File): FileOutputOptions {
return FileOutputOptions.Builder(segmentFile).build()
}
fun createSegmentFile(
context: Context,
displayName: String?,
): MediaStoreOutputOptions {
index: Int,
): File {
val directory = File(context.cacheDir, "recording_segments")
if (!directory.exists()) {
directory.mkdirs()
}
val baseName = resolveFileName(displayName).removeSuffix(".mp4")
return File(directory, "${baseName}_${System.currentTimeMillis()}_part$index.mp4")
}
fun createMergeFile(context: Context, displayName: String?): File {
val directory = File(context.cacheDir, "recording_segments")
if (!directory.exists()) {
directory.mkdirs()
}
val baseName = resolveFileName(displayName).removeSuffix(".mp4")
return File(directory, "${baseName}_${System.currentTimeMillis()}_merged.mp4")
}
fun publishToMediaStore(
context: Context,
displayName: String?,
sourceFile: File,
): String? {
val fileName = resolveFileName(displayName)
val contentValues =
ContentValues().apply {
@@ -24,15 +53,42 @@ object RecordingOutputFactory {
put(MediaStore.MediaColumns.MIME_TYPE, MIME_TYPE)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
put(MediaStore.Video.Media.RELATIVE_PATH, RELATIVE_PATH)
put(MediaStore.Video.Media.IS_PENDING, 1)
}
}
return MediaStoreOutputOptions.Builder(
context.contentResolver,
MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
)
.setContentValues(contentValues)
.build()
val resolver = context.contentResolver
val uri =
resolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues)
?: return null
try {
val outputStream =
resolver.openOutputStream(uri)
?: throw IllegalStateException("Cannot open MediaStore output stream")
outputStream.use { output ->
FileInputStream(sourceFile).use { input -> input.copyTo(output) }
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
val publishedValues =
ContentValues().apply { put(MediaStore.Video.Media.IS_PENDING, 0) }
resolver.update(uri, publishedValues, null, null)
}
return uri.toString()
} catch (error: Exception) {
resolver.delete(uri, null, null)
throw error
}
}
fun publishPartToMediaStore(
context: Context,
displayName: String?,
sourceFile: File,
partIndex: Int,
): String? {
val resolvedName = resolveFileName(displayName)
val partName = resolvedName.replace(".mp4", "_part$partIndex.mp4")
return publishToMediaStore(context, partName, sourceFile)
}
fun resolveFileName(displayName: String?): String {
android/app/src/main/kotlin/com/run/sportsx/recording/RecordingPlatformHandler.kt
+1
View File
@@ -196,6 +196,7 @@ class RecordingPlatformHandler(
"outputPath" to path,
"status" to controller.status.toMap(),
"fileSaved" to fileSaved,
"segmentOutputPaths" to controller.segmentOutputPaths(),
)
if (!fileSaved) {
payload["fileErrorMessage"] = controller.status.message ?: "保存到文件夹失败"
android/app/src/main/kotlin/com/run/sportsx/recording/RecordingSegmentMuxer.kt
+174
View File
@@ -0,0 +1,174 @@
package com.run.sportsx.recording
import android.media.MediaCodec
import android.media.MediaExtractor
import android.media.MediaFormat
import android.media.MediaMuxer
import java.io.File
import java.io.FileInputStream
import java.io.FileOutputStream
import java.nio.ByteBuffer
object RecordingSegmentMuxer {
fun mergeOrCopy(
segments: List<File>,
outputFile: File,
) {
val validSegments = segments.filter { it.exists() && it.length() > 0L }
require(validSegments.isNotEmpty()) { "No recording segments were generated" }
if (validSegments.size == 1) {
copyFile(validSegments.first(), outputFile)
return
}
MediaMuxer(outputFile.absolutePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4).use {
muxer ->
val firstTracks = readTrackFormats(validSegments.first())
val videoTrack = firstTracks.video?.let { muxer.addTrack(it) }
val audioTrack = firstTracks.audio?.let { muxer.addTrack(it) }
require(videoTrack != null) { "No video track in recording segment" }
muxer.start()
var offsetUs = 0L
validSegments.forEach { segment ->
val durationUs =
copySegmentTracks(
segment = segment,
muxer = muxer,
videoOutputTrack = videoTrack,
audioOutputTrack = audioTrack,
offsetUs = offsetUs,
)
offsetUs += durationUs + 1L
}
}
}
private fun copyFile(source: File, target: File) {
FileInputStream(source).use { input ->
FileOutputStream(target).use { output -> input.copyTo(output) }
}
}
private fun readTrackFormats(file: File): TrackFormats {
val extractor = MediaExtractor()
extractor.setDataSource(file.absolutePath)
try {
var video: MediaFormat? = null
var audio: MediaFormat? = null
for (index in 0 until extractor.trackCount) {
val format = extractor.getTrackFormat(index)
val mime = format.getString(MediaFormat.KEY_MIME).orEmpty()
when {
mime.startsWith("video/") && video == null -> video = format
mime.startsWith("audio/") && audio == null -> audio = format
}
}
return TrackFormats(video = video, audio = audio)
} finally {
extractor.release()
}
}
private fun copySegmentTracks(
segment: File,
muxer: MediaMuxer,
videoOutputTrack: Int,
audioOutputTrack: Int?,
offsetUs: Long,
): Long {
var segmentDurationUs = 0L
segmentDurationUs =
maxOf(
segmentDurationUs,
copyTrack(segment, muxer, "video/", videoOutputTrack, offsetUs),
)
if (audioOutputTrack != null) {
segmentDurationUs =
maxOf(
segmentDurationUs,
copyTrack(segment, muxer, "audio/", audioOutputTrack, offsetUs),
)
}
return segmentDurationUs
}
private fun copyTrack(
segment: File,
muxer: MediaMuxer,
mimePrefix: String,
outputTrack: Int,
offsetUs: Long,
): Long {
val extractor = MediaExtractor()
extractor.setDataSource(segment.absolutePath)
try {
val inputTrack = findTrack(extractor, mimePrefix) ?: return 0L
extractor.selectTrack(inputTrack)
val bufferSize = trackBufferSize(extractor.getTrackFormat(inputTrack))
val buffer = ByteBuffer.allocate(bufferSize)
val info = MediaCodec.BufferInfo()
var firstSampleTimeUs: Long? = null
var lastSampleTimeUs = 0L
while (true) {
buffer.clear()
val sampleSize = extractor.readSampleData(buffer, 0)
if (sampleSize < 0) break
val sampleTimeUs = extractor.sampleTime
val baseTimeUs = firstSampleTimeUs ?: sampleTimeUs.also { firstSampleTimeUs = it }
val normalizedTimeUs = (sampleTimeUs - baseTimeUs).coerceAtLeast(0L)
info.set(
0,
sampleSize,
offsetUs + normalizedTimeUs,
extractor.sampleFlags,
)
muxer.writeSampleData(outputTrack, buffer, info)
lastSampleTimeUs = normalizedTimeUs
extractor.advance()
}
return lastSampleTimeUs
} finally {
extractor.release()
}
}
private fun findTrack(extractor: MediaExtractor, mimePrefix: String): Int? {
for (index in 0 until extractor.trackCount) {
val mime = extractor.getTrackFormat(index).getString(MediaFormat.KEY_MIME).orEmpty()
if (mime.startsWith(mimePrefix)) {
return index
}
}
return null
}
private fun trackBufferSize(format: MediaFormat): Int {
return if (format.containsKey(MediaFormat.KEY_MAX_INPUT_SIZE)) {
format.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE).coerceAtLeast(DEFAULT_BUFFER_SIZE)
} else {
DEFAULT_BUFFER_SIZE
}
}
private data class TrackFormats(
val video: MediaFormat?,
val audio: MediaFormat?,
)
private const val DEFAULT_BUFFER_SIZE = 2 * 1024 * 1024
}
private inline fun MediaMuxer.use(block: (MediaMuxer) -> Unit) {
try {
block(this)
} finally {
try {
stop()
} catch (_: Exception) {
}
release()
}
}