Разберитесь в жизненном цикле улучшения мультимедиа в растровом режиме.

API улучшения качества мультимедиа предоставляет решение на основе искусственного интеллекта с низкой задержкой и сохранением конфиденциальности, работающее непосредственно на устройстве и использующее аппаратное ускорение для улучшения качества мультимедиа без увеличения размера APK-файла. Для получения дополнительной информации см. раздел «Ознакомление с возможностями улучшения качества мультимедиа» .

Статический режим обработки растровых изображений ( EnhancementMode.BITMAP ) предназначен для обработки статических декодированных изображений.

Работа в режиме Bitmap требует от операционной системы сериализации несжатых пиксельных данных и их копирования из памяти ЦП по системной шине в память графического процессора, после чего обработанный кадр возвращается путем обратного копирования. Этот режим оптимизирован для покадровой обработки и несовместим с потоковой передачей видео в реальном времени.

Данный рабочий процесс включает в себя создание сессии, обработку с её помощью одного растрового изображения, а затем обработку результата. Примеры кода из предыдущих разделов подробно рассматривают этот вариант использования.

  1. Настройка параметров : Создайте объект EnhancementOptions , убедившись, что enhancementMode установлен на EnhancementMode.BITMAP .
  2. Создание сессии : Используйте описанную ранее обертку createSessionAsync для создания объекта EnhancementSession . Это ресурсоемкий объект, поэтому создавайте его только при необходимости.
  3. Обработка изображения : вызовите сессию, укажите входное растровое изображение и необходимые параметры.
  4. Обработка результата : Функция `suspend` возвращает новый, улучшенный Bitmap в случае успеха или генерирует исключение в случае неудачи.
  5. Освобождение сессии : Крайне важно вызвать session.release() после завершения работы, чтобы освободить ресурсы графического процессора.

EnhancementSession — это ресурсоёмкий контекстный объект, поддерживающий постоянный конвейер обработки памяти графического или нейронного процессора. Он выделяет выделенную видеопамять (VRAM) и собственные системные дескрипторы. Для предотвращения серьёзных утечек памяти и потенциальных сбоев OutOfMemoryError следует придерживаться следующих принципов жизненного цикла:

  1. Ленивое создание экземпляра : не создавайте сессию до тех пор, пока пользователь не инициирует действие по улучшению.
  2. Стратегическое повторное использование : Поддерживайте и повторно используйте один экземпляр сессии при обработке нескольких изображений с идентичными конфигурациями (размерами и переключаемыми параметрами).
  3. Завершение сессии : Вызывайте session.release() немедленно после завершения визуальных задач, чтобы освободить общие аппаратные ресурсы.

Инициализировать механизм улучшений

Этот метод предусматривает двухэтапную проверку. Сначала проверяется, поддерживает ли аппаратное обеспечение устройства ускорение, а затем убеждается в наличии необходимых модулей машинного обучения.

Выполнение этого шага в качестве предварительного условия предотвращает ошибки инициализации во время выполнения, проверяя возможности приложения до того, как оно попытается обработать медиафайлы.

class MediaSetupViewModel(application: Application) : AndroidViewModel(application) {
    private val enhancementClient = Enhancement.getClient(application)
    fun initializeEnhancementEngine() {
        viewModelScope.launch {
            try {
                // 1. Verify hardware capability
                val isSupported = enhancementClient.isDeviceSupportedAsync()
                if (!isSupported) {
                    notifyUiDeviceIncompatible()
                    return@launch
                }
                // 2. Verify and download the Google Play services ML modules
                val isInstalled = enhancementClient.isModuleInstalledAsync()
                if (!isInstalled) {
                    notifyUiDownloadingModels()
                    enhancementClient.installModule().await() 
                }
                notifyUiEngineReady()
            } catch (e: Exception) {

                // Handle potential errors during session creation or image processing.
                handleInitializationError(e)
            }
        }
    }
}

Создание оболочек для процессов сессий и битовых карт

Используйте эти обертки для сопрограмм на Kotlin, чтобы преобразовать клиентские коллбэки, основанные на задачах, в стандартные функции приостановки, что обеспечит более чистое и последовательное выполнение.

// Wraps the task-based createSession callback into a suspending function.
suspend fun EnhancementClient.createSessionAsync(
    options: EnhancementOptions,
    executor: Executor
): EnhancementSession = withContext(Dispatchers.Main) {
    suspendCancellableCoroutine { continuation ->

        // EnhancementSessionCallback handles session success or failure.
        val callback = object : EnhancementSessionCallback {
            override fun onSessionCreated(session: EnhancementSession) {
                continuation.resume(session)
            }
            override fun onSessionCreationFailed(status: Status) {
                continuation.resumeWithException(
                    Exception("Session creation failed: ${status.statusMessage} (${status.statusCode})")
                )
            }
            override fun onSessionDestroyed() {}
            override fun onSessionDisconnected(status: Status) {}
        }

        // Handles errors during the initial request trigger.
        this.createSession(options, callback).addOnFailureListener(executor) { e ->
            if (continuation.isActive) {
                continuation.resumeWithException(e)
            }
        }
    }
}

// Wraps this process in a suspending function for cleaner execution.
suspend fun EnhancementSession.processBitmapAsync(
    bitmap: Bitmap,
    options: EnhancementOptions
): Bitmap = suspendCancellableCoroutine { continuation ->

    // EnhancementCallback returns the processed bitmap or an error code.
    val callback = object : EnhancementCallback {
        override fun onBitmapProcessed(enhancedBitmap: Bitmap) {
            continuation.resume(enhancedBitmap)
        }
        override fun onError(statusCode: Int) {
            continuation.resumeWithException(
                Exception("Bitmap processing failed with status code: $statusCode")
            )
        }
        override fun onSurfaceProcessed(timestamp: Long) {}
    }
    this.process(bitmap, options, callback)
}

Выполните обработку растровых изображений в ViewModel

Для интеграции конвейера улучшений в архитектуру вашего приложения используйте ViewModel для управления жизненным циклом сессии. Такой подход гарантирует освобождение ресурсоемких графических ресурсов при очистке ViewModel .

// Define a data class to hold image information.
data class ImageInfo(val bitmap: Bitmap)
// Define a UI state class to hold loading status, errors, and enhanced image.
data class EnhancementUiState(
    val isLoading: Boolean = false,
    val enhancementError: String? = null,
    val enhancedImage: ImageInfo? = null
)

class EnhancementViewModel(application: Application) : AndroidViewModel(application) {

    // Backing field for UI state, initialized with default values.
    private val _uiState = MutableStateFlow(EnhancementUiState())
    // Publicly exposed UI state flow for observation.
    val uiState: StateFlow<EnhancementUiState> = _uiState.asStateFlow()

// Initialize client to interact with the Media Enhancement service.
    private val enhancementClient: EnhancementClient = Enhancement.getClient(application)

// Single-thread executor for processing background enhancement tasks.
    private val enhancementExecutor = Executors.newSingleThreadExecutor()

// Track session state to enable reuse across multiple processing calls.
    private var enhancementSession: EnhancementSession? = null

// Primary function to trigger the enhancement workflow for a provided bitmap.
    fun enhanceImage(bitmap: Bitmap) {
        viewModelScope.launch(Dispatchers.IO) {
            _uiState.update { it.copy(isLoading = true, enhancementError = null) }
            try {
                // 1. Establish the session lazily on demand

// Define enhancement options (for example, enable upscale, tonemapping) based
// on bitmap dimensions.
                if (enhancementSession == null) {
                    val options = EnhancementOptions(
                        bitmap.width,
                        bitmap.height,
                        EnhancementMode.BITMAP,
                        enableTonemap = true,
                        enableDeblurDenoise = true,
                        enableDenoiseOnly = false,
                        enableUpscale = false,
                    )
                    enhancementSession = enhancementClient.createSessionAsync(options, enhancementExecutor)
                }
                val session = enhancementSession ?: throw IllegalStateException("Session unavailable.")
                // 2. Dispatch image through the neural pipeline
                val enhancedBitmap = session.processBitmapAsync(bitmap, session.defaultOptions)
                // 3. Render output to UI
                _uiState.update {
                    it.copy(enhancedImage = ImageInfo(bitmap = enhancedBitmap))
                }
            } catch (e: Exception) {
                _uiState.update { it.copy(enhancementError = e.message) }
            } finally {

// Ensure loading state is reset regardless of the outcome.
                _uiState.update { it.copy(isLoading = false) }
            }
        }
    }
    override fun onCleared() {
        // 4. Critical: Release native GPU hardware resources
        enhancementSession?.release()
        enhancementSession = null
        enhancementExecutor.shutdown()
        super.onCleared()
    }
}