Kotlin拿Android本地视频缩略图

        本文主要讨论如下三个问题:

  1. 如何拿到本地视频?
  2. 怎么拿视频缩略图?
  3. 缩略图如何压缩?

1 如何拿到本地视频?

1.1 定义数据结构

        先定义媒体信息数据结构MediaInfo,以及视频信息数据结构VideoInfo。

open class MediaInfo(
    var size: Long = 0L, // 大小 单位B
    var width: Float = 0f, // 宽
    var height: Float = 0f, // 高
    var localPath: String = "", // 系统绝对路径
    var localPathUri: String = "", // 媒体文件Uri
    var fileName: String = "", // 文件名
    var mimeType: String = "", // 媒体类型
    var mediaId: String = "", // 媒体ID
    var lastModified: Long = 0L, // 最后更改时间

    /*----业务字段----*/
    var seq: Int = 0, // 事件序列号
    /*----业务字段----*/
)
/**
 * 码率(比特率),单位为 bps,比特率越高,传送的数据速度越快。在压缩视频时指定码率,则可确定压缩后的视频大小。
 * 视频大小(byte) = (duration(ms) / 1000) * (biteRate(bit/s) / 8)
 */
data class VideoInfo(
    var firstFrame: Bitmap? = null, // 视频第一帧图
    var duration: Long = 0L, // 视频长度 ms
    var biteRate: Long = 0L, // 视频码率 bps

    /* --------not necessary, maybe not value---- */
    var addTime: Long = 0L, // 视频添加时间
    var videoRotation: Int = 0, // 视频方向
    /* --------not necessary, maybe not value---- */

) : MediaInfo()

1.2 ContentResolver查询系统中视频

        这里直接去Android媒体库找到所有视频即可,代码使用了Kotlin协程,参考如下。

import android.provider.MediaStore.Video.Media

    /**
     * 获取系统所有视频文件
     */
    suspend fun getSystemVideos(contentResolver: ContentResolver): MutableList =
        withContext(Dispatchers.IO) {
            val videoList: MutableList = mutableListOf()
            var cursor: Cursor? = null
            try {
                val queryArray = arrayOf(
                    Media._ID,
                    Media.SIZE, // 视频大小
                    Media.WIDTH, // 视频宽
                    Media.HEIGHT, // 视频高
                    Media.DATA, // 视频绝对路径
                    Media.DISPLAY_NAME, // 视频文件名
                    Media.MIME_TYPE, // 媒体类型
                    Media.DURATION, // 视频长度
                    Media.DATE_ADDED, // 视频添加时间
                    Media.DATE_MODIFIED, // 视频最后更改时间
                ).toMutableList()
                if (SDK_INT >= Build.VERSION_CODES.R) queryArray.add(Media.BITRATE)// 视频码率
                cursor = contentResolver.query(
                    Media.EXTERNAL_CONTENT_URI, queryArray.toTypedArray(),
                    null, null, Media.DATE_ADDED + " DESC", null
                )
                cursor?.moveToFirst()
                if (cursor == null || cursor.isAfterLast) return@withContext videoList
                while (!cursor.isAfterLast) {
                    getVideoInfo(cursor).run { if (duration > 0 && size > 0) videoList.add(this) }
                    cursor.moveToNext()
                }
            } catch (e: Exception) {
            } finally {
                cursor?.close()
            }
            videoList
        }

注:getVideoInfo获取视频文件信息可参考附件1。

2 怎么拿视频缩略图?

2.1 MediaMetadataRetriever

        可以通过视频系统路径,直接使用getFrameAtTime方法拿到第一帧作为缩略图。

val retriever = MediaMetadataRetriever()
retriever.setDataSource("filePath")
val bitmap: Bitmap? = retriever.frameAtTime

        也可以使用getScaledFrameAtTime,指定缩略图Bitmap尺寸512*512。

retriever.getScaledFrameAtTime(-1, OPTION_CLOSEST_SYNC,512,512)

2.2 ThumbnailUtils

  • 第二个参数kind可取如下值:MICRO_KIND(3)不清晰;FULL_SCREEN_KIND(2)清晰;MINI_KIND(1)较清晰
  • MICRO_KIND:96*96的缩略图
  • MINI_KIND:512*384的缩略图
  • FULL_SCREEN_KIND:完整大小的图片
ThumbnailUtils.createVideoThumbnail("filePath",MediaStore.Video.Thumbnails.FULL_SCREEN_KIND)

        ThumbnailUtils.createVideoThumbnail其实也是使用的MediaMetadataRetriever,如下源码截图:

Kotlin拿Android本地视频缩略图_第1张图片

Kotlin拿Android本地视频缩略图_第2张图片

2.3 Glide

Glide.with(mContext)
    .load(Uri.fromFile(File("filePath")))
    .into(binding.icon)

        项目中一般会使用图片加载框架如Glide,它内部也是支持加载视频作为图片的,亦是使用的MediaMetadataRetriever。 

Kotlin拿Android本地视频缩略图_第3张图片

Kotlin拿Android本地视频缩略图_第4张图片

2.4 Android媒体库

        直接从Android媒体库中查询缩略图,但是调试时发现未找到(视频为手机本地录制mp4格式) ,下面是查询视频缩略图的方法:

    /**
     * 获取视频缩略图:从媒体库中查询
     */
    @Deprecated("暂时不可用", replaceWith = ReplaceWith("getVideoThumbnail"))
    suspend fun getVideoThumbnailDefault(
        contentResolver: ContentResolver,
        cursor: Cursor
    ): Bitmap? = withContext(Dispatchers.IO) {
//        // 方式一:能拿到路径"content://media/external/images/media/126",但没有具体图片
//        BitmapFactory.decodeFile(
//            ContentUris.withAppendedId(
//                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
//                cursor.getLong(cursor.getColumnIndex(Media._ID))
//            ).toString()
//        )
//
//        // 方式二:拿到的是video视频路径"/storage/emulated/0/DCIM/Camera/20221122_200648.mp4"
//        BitmapFactory.decodeFile(cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA)))

        // 方式三:开发调试时发现,thumbCursor.moveToFirst()为false,也就是说cursor为空,视频缩略图路径未找到
        contentResolver.query(
            Thumbnails.EXTERNAL_CONTENT_URI,
            arrayOf(Thumbnails.DATA, Thumbnails.VIDEO_ID),
            Thumbnails.VIDEO_ID + "=" + cursor.getInt(cursor.getColumnIndex(Media._ID)),
            null,
            null
        )?.let { thumbCursor ->
            if (thumbCursor.moveToFirst()) {
                // 获取视频缩略图路径,并转为bitmap
                // MediaStore.Video.Thumbnails.DATA: 视频缩略图的文件路径
                BitmapFactory.decodeFile(thumbCursor.getString(thumbCursor.getColumnIndex(Thumbnails.DATA)))
            } else null
        }
    }

2.5 Android 10兼容

         Android 10对文件访问更加严格,不能直接操作视频绝对路径,如要操作则须加上在AndroidManifest.xml的application标签下声明requestLegacyExternalStorage=true,才可以访问非沙盒路径下的数据。

        但Google Play发布的应用,不允许带有requestLegacyExternalStorage,所以对于Android 10不能采用操作视频的绝对路径,改为操作视频的Uri即可。

       1) 针对Android 10可以采用更高版本API获取视频第一帧,如下:

    /**
     * 获取视频缩略图:兼容Android 10
     */
    suspend fun getVideoThumbnail(context: Context, uriString: String): Bitmap? =
        withContext(Dispatchers.IO) {
            var bitmap: Bitmap? = null
            if (SDK_INT >= Build.VERSION_CODES.Q) {
                try {
                    bitmap = context.contentResolver.loadThumbnail(
                        Uri.parse(uriString), Size(
                            THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt(),
                            THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt()
                        ), null
                    )
                } catch (e: Exception) {
                }
            } else getVideoThumbnail(uriString)
            bitmap
        }

        2)针对Android 10,也可以使用视频Uri去获取第一帧,如下:

    suspend fun getVideoThumbnail(context: Context, uriString: String): Bitmap? =
        withContext(Dispatchers.IO) {
            var bitmap: Bitmap? = null
            val retriever = MediaMetadataRetriever()
            try {
                retriever.setDataSource(context, Uri.parse(uriString))
                // OPTION_CLOSEST_SYNC:在给定的时间,检索最近一个同步与数据源相关联的的帧(关键帧)
                // OPTION_CLOSEST:表示获取离该时间戳最近帧(I帧或P帧)
                bitmap = if (SDK_INT >= Build.VERSION_CODES.O_MR1) {
                    retriever.getScaledFrameAtTime(
                        VIDEO_FIRST_FRAME_TIME_US, OPTION_CLOSEST_SYNC,
                        THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt(),
                        THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt()
                    )
                } else {
                    retriever.getFrameAtTime(VIDEO_FIRST_FRAME_TIME_US)
                        ?.let { compressVideoThumbnail(it) }
                }
            } catch (e: Exception) {
            } finally {
                try {
                    retriever.release()
                } catch (e: Exception) {
                }
            }
            bitmap
        }

        3)但,Android 10,不能使用视频绝对路径去获取第一帧,会存在权限不足问题,如下:

    /**
     * 获取视频缩略图:从路径中拿取第一帧,Android 10不可用
     */
    suspend fun getVideoThumbnail(filePath: String): Bitmap? = withContext(Dispatchers.IO) {
        var bitmap: Bitmap? = null
        val retriever = MediaMetadataRetriever()
        try {
            retriever.setDataSource(filePath)
            // OPTION_CLOSEST_SYNC:在给定的时间,检索最近一个同步与数据源相关联的的帧(关键帧)
            // OPTION_CLOSEST:表示获取离该时间戳最近帧(I帧或P帧)
            bitmap = if (SDK_INT >= Build.VERSION_CODES.O_MR1) {
                retriever.getScaledFrameAtTime(
                    VIDEO_FIRST_FRAME_TIME_US, OPTION_CLOSEST_SYNC,
                    THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt(),
                    THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt()
                )
            } else {
                retriever.getFrameAtTime(VIDEO_FIRST_FRAME_TIME_US)
                    ?.let { compressVideoThumbnail(it) }
            }
        } catch (e: Exception) {
        } finally {
            try {
                retriever.release()
            } catch (e: Exception) {
            }
        }
        bitmap
    }

         综上,使用第二种方式是一种比较统一的方式,不存在版本兼容问题。

参考:

https://blog.csdn.net/g984160547/article/details/115749804

android 10(Q)上传图片及视频,访问媒体文件适配_李小白的生活的博客-CSDN博客_android 10 上传文件

2.6 小结

  • Android媒体库可以获取缩略图但不稳定;

  • 第三方图片库如Glide以及ThumbnailUtils都是采用MediaMetadataRetriever。

          所以根本上来说,目前有两种方式拿到视频缩略图,Android媒体库或MediaMetadataRetriever,一般来说采用MediaMetadataRetriever方式,参考代码如下:

    const val VIDEO_FIRST_FRAME_TIME_US = 1000L
    /**
     * 视频缩略图默认压缩尺寸
     */
    const val THUMBNAIL_DEFAULT_COMPRESS_VALUE = 1024f

        /**
     * 获取视频缩略图:通过绝对路径抓取第一帧
     * @param filePath 视频在系统绝对路径。如:/storage/emulated/0/Pictures/Screenshots/SVID_20221109_181203_1.mp4
     */
    suspend fun getVideoThumbnail(filePath: String): Bitmap? = withContext(Dispatchers.IO) {
        var bitmap: Bitmap? = null
        val retriever = MediaMetadataRetriever()
        try {
            retriever.setDataSource(filePath)
            // OPTION_CLOSEST_SYNC:在给定的时间,检索最近一个同步与数据源相关联的的帧(关键帧)
            // OPTION_CLOSEST:表示获取离该时间戳最近帧(I帧或P帧)
            bitmap = if (SDK_INT >= Build.VERSION_CODES.O_MR1) {
                retriever.getScaledFrameAtTime(
                    VIDEO_FIRST_FRAME_TIME_US, OPTION_CLOSEST_SYNC,
                    THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt(),
                    THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt()
                )
            } else {
                retriever.getFrameAtTime(VIDEO_FIRST_FRAME_TIME_US)
                    ?.let { compressVideoThumbnail(it) }
            }
        } catch (e: Exception) {
        } finally {
            try {
                retriever.release()
            } catch (e: Exception) {
            }
        }
        bitmap
    }

    /**
     * 获取视频缩略图:通过Uri抓取第一帧
     * @param videoUriString 视频在媒体库中Uri。如:content://media/external/video/media/11378
     */
    suspend fun getVideoThumbnail(context: Context, videoUriString: String): Bitmap? =
        withContext(Dispatchers.IO) {
            var bitmap: Bitmap? = null
            val retriever = MediaMetadataRetriever()
            try {
                retriever.setDataSource(context, Uri.parse(videoUriString))
                // OPTION_CLOSEST_SYNC:在给定的时间,检索最近一个同步与数据源相关联的的帧(关键帧)
                // OPTION_CLOSEST:表示获取离该时间戳最近帧(I帧或P帧)
                bitmap = if (SDK_INT >= Build.VERSION_CODES.O_MR1) {
                    retriever.getScaledFrameAtTime(
                        VIDEO_FIRST_FRAME_TIME_US, OPTION_CLOSEST_SYNC,
                        THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt(),
                        THUMBNAIL_DEFAULT_COMPRESS_VALUE.toInt()
                    )
                } else {
                    retriever.getFrameAtTime(VIDEO_FIRST_FRAME_TIME_US)
                        ?.let { compressVideoThumbnail(it) }
                }
            } catch (e: Exception) {
            } finally {
                try {
                    retriever.release()
                } catch (e: Exception) {
                }
            }
            bitmap
        }

        为避免应用OOM,需要对缩略图大小进行压缩compressVideoThumbnail,下面看看Bitmap压缩方式。

3 缩略图如何压缩?        

        宽高压缩、缩放法压缩可针对Bitmap操作,而采样率压缩和质量压缩针对于File、Resource操作,下面可主要看看宽高压缩、缩放法压缩。

3.1 宽高压缩

    /**
     * 视频缩略图默认压缩尺寸
     */
    const val THUMBNAIL_DEFAULT_COMPRESS_VALUE = 512f

    /**
     * 压缩视频缩略图
     * @param bitmap 视频缩略图
     */
    fun compressVideoThumbnail(bitmap: Bitmap): Bitmap? {
        val width: Int = bitmap.width
        val height: Int = bitmap.height
        val max: Int = Math.max(width, height)
        if (max > THUMBNAIL_DEFAULT_COMPRESS_VALUE) {
            val scale: Float = THUMBNAIL_DEFAULT_COMPRESS_VALUE / max
            val w = (scale * width).roundToInt()
            val h = (scale * height).roundToInt()
            return compressVideoThumbnail(bitmap, w, h)
        }
        return bitmap
    }

    /**
     * 压缩视频缩略图:宽高压缩
     * 注:如果用户期望的长度和宽度和原图长度宽度相差太多的话,图片会很不清晰。
     * @param bitmap 视频缩略图
     */
    fun compressVideoThumbnail(bitmap: Bitmap, width: Int, height: Int): Bitmap? {
        return Bitmap.createScaledBitmap(bitmap, width, height, true)
    }

3.2 缩放法压缩

    /**
     * 视频缩略图默认压缩比例
     */
    private const val THUMBNAIL_DEFAULT_SCALE_VALUE = 0.5f

    /**
     * 压缩视频缩略图:缩放法压缩
     * 注:长度和宽度没有变,内存缩小4倍(宽高各缩小一半)
     */
    fun compressVideoThumbnailMatrix(bitmap: Bitmap): Bitmap? {
        val matrix = Matrix()
        matrix.setScale(THUMBNAIL_DEFAULT_SCALE_VALUE, THUMBNAIL_DEFAULT_SCALE_VALUE)
        return Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
    }

        其实,宽高压缩调用createScaledBitmap方法,最终也是走的缩放法压缩Matrix.setScale,如下图源码,通过宽高计算出scale值,进而进行压缩:

Kotlin拿Android本地视频缩略图_第5张图片

3.3 采样率压缩

    /**
     * 压缩视频缩略图:采样率压缩
     * @param filePath 视频缩略图路径
     */
    fun compressVideoThumbnailSample(filePath: String, width: Int, height: Int): Bitmap? {
        return BitmapFactory.Options().run {
            // inJustDecodeBounds 设置为 true后,BitmapFactory.decodeFile 不生成Bitmap对象,而仅仅是读取该图片的尺寸和类型信息。
            inJustDecodeBounds = true
            BitmapFactory.decodeFile(filePath, this)
            inSampleSize = calculateInSampleSize(this, width, height)
            inJustDecodeBounds = false
            BitmapFactory.decodeFile(filePath, this)
        }
    }

        计算采样率,可有以下2种方式: 

    /**
     * 计算采样率:值为2的幂。例如, 一个分辨率为2048x1536的图片,如果设置 inSampleSize 为4,那么会产出一个大约512x384大小的Bitmap。
     * @param options
     * @param reqWidth 想要压缩到的宽度
     * @param reqHeight  想要压缩到的高度
     * @return
     */
    fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
        var inSampleSize = 1
        if (options.outHeight > reqHeight || options.outWidth > reqWidth) {
            val halfHeight: Int = options.outHeight / 2
            val halfWidth: Int = options.outWidth / 2
            while (halfHeight / inSampleSize >= reqHeight && halfWidth / inSampleSize >= reqWidth) {
                inSampleSize *= 2
            }
        }
        return inSampleSize
    }

    /**
     * 计算采样率:值为整数的采样率。
     */
    fun calculateInSampleSizeFixed(options: BitmapFactory.Options, width: Int, height: Int): Int {
        val hRatio = ceil(options.outHeight.div(height.toDouble())) // 大于1:图片高度>手机屏幕高度
        val wRatio = ceil(options.outWidth.div(width.toDouble())) // 大于1:图片宽度>手机屏幕宽度
        return if (hRatio > wRatio) hRatio.toInt() else wRatio.toInt()
    }

        其实,这里的采样率压缩称之为采用邻近点插值算法邻近采样,即:如果采样率设置为2,意味着直接选择其中的一个像素作为生成像素,另一个像素直接抛弃。

        另外,宽高压缩或缩放法压缩称为双线性采样,且:它不像邻近点插值算法一样,直接粗暴的选择一个像素,而是参考了源像素相应位置周围 2x2 个点的值,根据相对位置取对应的权重,经过计算之后得到目标图像。

        双线性采样对比邻近采样的优势在于:

  • 它的系数可以是小数,而不一定是整数,在某些压缩限制下,效果尤为明显;
  • 处理文字比较多的图片在展示效果上的差别,双线性采样效果要更好。

3.4 质量压缩

        因为,质量压缩会让图片在磁盘中的大小(File文件的大小)减小,但是图片的像素数不会改变,加载压缩后的图片,占据的内存不会减少,所以我们这里内存中视频缩略图的压缩,就先不展开讨论此种方式。具体实现可参考此文 。

注:

  • 质量压缩依靠Bitmap.compress(CompressFormat format, int quality, OutputStream stream)实现;
  • 质量压缩可以减少文件大小,典型使用场景为:图片的上传。

3.5 小结  

        图片压缩方法根据实际情况去选择即可,比如微信图片压缩算法,大致就是按照以下步骤进行的:

  • 第一步进行采样率压缩;
  • 第二步进行宽高压缩(微信对原图和缩略图限制了最大长宽或者最小长宽);
  • 第三步就是对图片的质量进行压缩(一般75或者70);
  • 第四部就是采用webP的格式。

4 附件

【附1:获取视频文件信息】

    /**
     * 获取视频文件信息
     * 注:(1)暂未包括videoRotation;(2)biteRate通过文件大小和视频时长计算
     */
    suspend fun getVideoInfo(cursor: Cursor): VideoInfo = withContext(Dispatchers.IO) {
        val videoInfo = VideoInfo()
        videoInfo.mediaId = cursor.getString(cursor.getColumnIndex(Media._ID))
        videoInfo.size = cursor.getLong(cursor.getColumnIndex(Media.SIZE))
        videoInfo.width = cursor.getFloat(cursor.getColumnIndex(Media.WIDTH))
        videoInfo.height = cursor.getFloat(cursor.getColumnIndex(Media.HEIGHT))
        videoInfo.localPath = cursor.getString(cursor.getColumnIndex(Media.DATA))
        videoInfo.localPathUri = getVideoPathUri(videoInfo.mediaId).toString()
        videoInfo.fileName = cursor.getString(cursor.getColumnIndex(Media.DISPLAY_NAME))
        videoInfo.mimeType = cursor.getString(cursor.getColumnIndex(Media.MIME_TYPE))
//        不能在这获取第一帧,太耗时,改为使用的地方去获取第一帧。
//        videoInfo.firstFrame = getVideoThumbnail(cursor.getString(cursor.getColumnIndex(Media.DATA)))
        videoInfo.duration = cursor.getLong(cursor.getColumnIndex(Media.DURATION))
        videoInfo.biteRate =
            if (SDK_INT >= Build.VERSION_CODES.R) cursor.getLong(cursor.getColumnIndex(Media.BITRATE))
            else ((8 * videoInfo.size * 1024) / (videoInfo.duration / 1000f)).toLong()
        videoInfo.addTime = cursor.getLong(cursor.getColumnIndex(Media.DATE_ADDED))
        videoInfo.lastModified = cursor.getLong(cursor.getColumnIndex(Media.DATE_MODIFIED))
        videoInfo
    }

【附2:通过视频路径直接获取文件信息】

    /**
     * 获取视频文件信息
     * 注:(1)暂未包括lastModified、addTime;(2)mediaId以filePath代替
     *
     * @param path 视频文件的路径
     * @return VideoInfo 视频文件信息
     */
    suspend fun getVideoInfo(path: String?): VideoInfo = withContext(Dispatchers.IO) {
        val videoInfo = VideoInfo()
        if (!path.isNullOrEmpty()) {
            val media = MediaMetadataRetriever()
            try {
                media.setDataSource(path)
                videoInfo.size =
                    File(path).let { if (FileUtils.isFileExists(it)) it.length() else 0 }
                videoInfo.width = media.extractMetadata(METADATA_KEY_VIDEO_WIDTH)?.toFloat() ?: 0f
                videoInfo.height = media.extractMetadata(METADATA_KEY_VIDEO_HEIGHT)?.toFloat() ?: 0f
                videoInfo.localPath = path
                videoInfo.localPathUri =
                    getVideoPathUri(ApplicationUtils.getApplication(), path).toString()
                videoInfo.fileName = path.split(File.separator).let {
                    if (it.isNotEmpty()) it[it.size - 1] else ""
                }
                videoInfo.mimeType = media.extractMetadata(METADATA_KEY_MIMETYPE) ?: ""
                videoInfo.firstFrame =
                    media.getFrameAtTime(VIDEO_FIRST_FRAME_TIME_US)
                        ?.let { compressVideoThumbnail(it) }
                videoInfo.duration = media.extractMetadata(METADATA_KEY_DURATION)?.toLong() ?: 0
                videoInfo.biteRate = media.extractMetadata(METADATA_KEY_BITRATE)?.toLong() ?: 0
                videoInfo.videoRotation =
                    media.extractMetadata(METADATA_KEY_VIDEO_ROTATION)?.toInt() ?: 0
                videoInfo.mediaId = path
            } catch (e: Exception) {
            } finally {
                media.release()
            }
        }
        videoInfo
    }

【附3:获取视频Uri】

    private const val URI_VIDEO_PRE = "content://media/external/video/media"

    /**
     * 通过视频资源ID,直接获取视频Uri
     * @param mediaId 视频资源ID
     */
    fun getVideoPathUri(mediaId: String): Uri =
        Uri.withAppendedPath(Uri.parse(URI_VIDEO_PRE), mediaId)

    /**
     * 通过视频资源本地路径,获取视频Uri
     * @param path 视频资源本地路径
     */
    fun getVideoPathUri(context: Context, path: String): Uri? {
        var uri: Uri? = null
        var cursor: Cursor? = null
        try {
            cursor = context.contentResolver.query(
                Media.EXTERNAL_CONTENT_URI, arrayOf(Media._ID),
                Media.DATA + "=? ", arrayOf(path), null
            )
            uri = if (cursor != null && cursor.moveToFirst()) {
                Uri.withAppendedPath(
                    Uri.parse(URI_VIDEO_PRE),
                    "" + cursor.getInt(cursor.getColumnIndex(MediaStore.MediaColumns._ID))
                )
            } else {
                if (File(path).exists()) {
                    val values = ContentValues()
                    values.put(Media.DATA, path)
                    context.contentResolver.insert(Media.EXTERNAL_CONTENT_URI, values)
                } else {
                    null
                }
            }
        } catch (e: Exception) {
        } finally {
            cursor?.close()
        }
        return uri
    }

你可能感兴趣的:(Android:开发实践,Kotlin,kotlin,缩略图,视频首帧,图片压缩)