mirror of
https://github.com/nextcloud/talk-android
synced 2025-06-19 19:49:33 +01:00
400 lines
15 KiB
Kotlin
400 lines
15 KiB
Kotlin
/*
|
|
* Nextcloud Talk application
|
|
*
|
|
* @author Marcel Hibbe
|
|
* Copyright (C) 2022 Marcel Hibbe <dev@mhibbe.de>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package com.nextcloud.talk.utils
|
|
|
|
import android.annotation.SuppressLint
|
|
import android.content.ComponentName
|
|
import android.content.Context
|
|
import android.content.Intent
|
|
import android.net.Uri
|
|
import android.os.Build
|
|
import android.util.Log
|
|
import android.view.View
|
|
import android.widget.ProgressBar
|
|
import androidx.core.content.FileProvider
|
|
import androidx.emoji.widget.EmojiTextView
|
|
import androidx.work.Data
|
|
import androidx.work.OneTimeWorkRequest
|
|
import androidx.work.WorkInfo
|
|
import androidx.work.WorkManager
|
|
import com.facebook.drawee.view.SimpleDraweeView
|
|
import com.nextcloud.talk.R
|
|
import com.nextcloud.talk.activities.FullScreenImageActivity
|
|
import com.nextcloud.talk.activities.FullScreenMediaActivity
|
|
import com.nextcloud.talk.activities.FullScreenTextViewerActivity
|
|
import com.nextcloud.talk.adapters.messages.MagicPreviewMessageViewHolder
|
|
import com.nextcloud.talk.jobs.DownloadFileToCacheWorker
|
|
import com.nextcloud.talk.models.database.CapabilitiesUtil
|
|
import com.nextcloud.talk.models.database.UserEntity
|
|
import com.nextcloud.talk.models.json.chat.ChatMessage
|
|
import com.nextcloud.talk.utils.AccountUtils.canWeOpenFilesApp
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys.KEY_ACCOUNT
|
|
import com.nextcloud.talk.utils.bundle.BundleKeys.KEY_FILE_ID
|
|
import java.io.File
|
|
import java.util.concurrent.ExecutionException
|
|
|
|
class FileViewerUtils(private val context: Context, private val userEntity: UserEntity) {
|
|
|
|
fun openFile(
|
|
message: ChatMessage,
|
|
progressUi: ProgressUi
|
|
) {
|
|
val fileName = message.getSelectedIndividualHashMap()[MagicPreviewMessageViewHolder.KEY_NAME]!!
|
|
val mimetype = message.getSelectedIndividualHashMap()[MagicPreviewMessageViewHolder.KEY_MIMETYPE]!!
|
|
val link = message.getSelectedIndividualHashMap()["link"]!!
|
|
|
|
val fileId = message.getSelectedIndividualHashMap()[MagicPreviewMessageViewHolder.KEY_ID]!!
|
|
val path = message.getSelectedIndividualHashMap()[MagicPreviewMessageViewHolder.KEY_PATH]!!
|
|
|
|
var size = message.getSelectedIndividualHashMap()["size"]
|
|
if (size == null) {
|
|
size = "-1"
|
|
}
|
|
val fileSize = Integer.valueOf(size)
|
|
|
|
openFile(
|
|
fileId,
|
|
fileName,
|
|
fileSize,
|
|
path,
|
|
link,
|
|
mimetype,
|
|
progressUi
|
|
)
|
|
}
|
|
|
|
fun openFile(
|
|
fileId: String,
|
|
fileName: String,
|
|
fileSize: Int,
|
|
path: String,
|
|
link: String,
|
|
mimetype: String,
|
|
progressUi: ProgressUi
|
|
) {
|
|
if (isSupportedForInternalViewer(mimetype) || canBeHandledByExternalApp(mimetype, fileName)) {
|
|
openOrDownloadFile(
|
|
fileName,
|
|
fileId,
|
|
path,
|
|
fileSize,
|
|
mimetype,
|
|
progressUi
|
|
)
|
|
} else {
|
|
openFileInFilesApp(link, fileId)
|
|
}
|
|
}
|
|
|
|
private fun canBeHandledByExternalApp(mimetype: String, fileName: String): Boolean {
|
|
val path: String = context.cacheDir.absolutePath + "/" + fileName
|
|
val file = File(path)
|
|
val intent = Intent(Intent.ACTION_VIEW)
|
|
intent.setDataAndType(Uri.fromFile(file), mimetype)
|
|
return intent.resolveActivity(context.packageManager) != null
|
|
}
|
|
|
|
private fun openOrDownloadFile(
|
|
fileName: String,
|
|
fileId: String,
|
|
path: String,
|
|
fileSize: Int,
|
|
mimetype: String,
|
|
progressUi: ProgressUi
|
|
) {
|
|
val file = File(context.cacheDir, fileName)
|
|
if (file.exists()) {
|
|
openFileByMimetype(fileName!!, mimetype!!)
|
|
} else {
|
|
downloadFileToCache(
|
|
fileName,
|
|
fileId,
|
|
path,
|
|
fileSize,
|
|
mimetype,
|
|
progressUi
|
|
)
|
|
}
|
|
}
|
|
|
|
private fun openFileByMimetype(filename: String, mimetype: String) {
|
|
when (mimetype) {
|
|
"audio/mpeg",
|
|
"audio/wav",
|
|
"audio/ogg",
|
|
"video/mp4",
|
|
"video/quicktime",
|
|
"video/ogg"
|
|
-> openMediaView(filename, mimetype)
|
|
"image/png",
|
|
"image/jpeg",
|
|
"image/gif"
|
|
-> openImageView(filename, mimetype)
|
|
"text/markdown",
|
|
"text/plain"
|
|
-> openTextView(filename, mimetype)
|
|
else
|
|
-> openFileByExternalApp(filename, mimetype)
|
|
}
|
|
}
|
|
|
|
@Suppress("Detekt.TooGenericExceptionCaught")
|
|
private fun openFileByExternalApp(fileName: String, mimetype: String) {
|
|
val path = context.cacheDir.absolutePath + "/" + fileName
|
|
val file = File(path)
|
|
val intent: Intent
|
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
|
|
intent = Intent(Intent.ACTION_VIEW)
|
|
intent.setDataAndType(Uri.fromFile(file), mimetype)
|
|
intent.flags = Intent.FLAG_ACTIVITY_NO_HISTORY
|
|
} else {
|
|
intent = Intent()
|
|
intent.action = Intent.ACTION_VIEW
|
|
val pdfURI = FileProvider.getUriForFile(context, context.packageName, file)
|
|
intent.setDataAndType(pdfURI, mimetype)
|
|
intent.flags = Intent.FLAG_ACTIVITY_NO_HISTORY
|
|
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
|
|
}
|
|
try {
|
|
if (intent.resolveActivity(context.packageManager) != null) {
|
|
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
|
context.startActivity(intent)
|
|
} else {
|
|
Log.e(TAG, "No Application found to open the file. This should have been handled beforehand!")
|
|
}
|
|
} catch (e: Exception) {
|
|
Log.e(TAG, "Error while opening file", e)
|
|
}
|
|
}
|
|
|
|
fun openFileInFilesApp(link: String, keyID: String) {
|
|
val accountString = userEntity.username + "@" +
|
|
userEntity.baseUrl
|
|
.replace("https://", "")
|
|
.replace("http://", "")
|
|
|
|
if (canWeOpenFilesApp(context, accountString)) {
|
|
val filesAppIntent = Intent(Intent.ACTION_VIEW, null)
|
|
val componentName = ComponentName(
|
|
context.getString(R.string.nc_import_accounts_from),
|
|
"com.owncloud.android.ui.activity.FileDisplayActivity"
|
|
)
|
|
filesAppIntent.component = componentName
|
|
filesAppIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
|
filesAppIntent.setPackage(context.getString(R.string.nc_import_accounts_from))
|
|
filesAppIntent.putExtra(KEY_ACCOUNT, accountString)
|
|
filesAppIntent.putExtra(KEY_FILE_ID, keyID)
|
|
context.startActivity(filesAppIntent)
|
|
} else {
|
|
val browserIntent = Intent(
|
|
Intent.ACTION_VIEW,
|
|
Uri.parse(link)
|
|
)
|
|
browserIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
|
context.startActivity(browserIntent)
|
|
}
|
|
}
|
|
|
|
private fun openImageView(filename: String, mimetype: String) {
|
|
val fullScreenImageIntent = Intent(context, FullScreenImageActivity::class.java)
|
|
fullScreenImageIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
|
fullScreenImageIntent.putExtra("FILE_NAME", filename)
|
|
fullScreenImageIntent.putExtra("IS_GIF", isGif(mimetype))
|
|
context.startActivity(fullScreenImageIntent)
|
|
}
|
|
|
|
private fun openMediaView(filename: String, mimetype: String) {
|
|
val fullScreenMediaIntent = Intent(context, FullScreenMediaActivity::class.java)
|
|
fullScreenMediaIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
|
fullScreenMediaIntent.putExtra("FILE_NAME", filename)
|
|
fullScreenMediaIntent.putExtra("AUDIO_ONLY", isAudioOnly(mimetype))
|
|
context.startActivity(fullScreenMediaIntent)
|
|
}
|
|
|
|
private fun openTextView(filename: String, mimetype: String) {
|
|
val fullScreenTextViewerIntent = Intent(context, FullScreenTextViewerActivity::class.java)
|
|
fullScreenTextViewerIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
|
fullScreenTextViewerIntent.putExtra("FILE_NAME", filename)
|
|
fullScreenTextViewerIntent.putExtra("IS_MARKDOWN", isMarkdown(mimetype))
|
|
context.startActivity(fullScreenTextViewerIntent)
|
|
}
|
|
|
|
fun isSupportedForInternalViewer(mimetype: String?): Boolean {
|
|
return when (mimetype) {
|
|
"image/png", "image/jpeg",
|
|
"image/gif", "audio/mpeg",
|
|
"audio/wav", "audio/ogg",
|
|
"video/mp4", "video/quicktime",
|
|
"video/ogg", "text/markdown",
|
|
"text/plain" -> true
|
|
else -> false
|
|
}
|
|
}
|
|
|
|
private fun isGif(mimetype: String): Boolean {
|
|
return "image/gif" == mimetype
|
|
}
|
|
|
|
private fun isMarkdown(mimetype: String): Boolean {
|
|
return "text/markdown" == mimetype
|
|
}
|
|
|
|
private fun isAudioOnly(mimetype: String): Boolean {
|
|
return mimetype.startsWith("audio")
|
|
}
|
|
|
|
@SuppressLint("LongLogTag")
|
|
private fun downloadFileToCache(
|
|
fileName: String,
|
|
fileId: String,
|
|
path: String,
|
|
fileSize: Int,
|
|
mimetype: String,
|
|
progressUi: ProgressUi
|
|
) {
|
|
// check if download worker is already running
|
|
val workers = WorkManager.getInstance(context).getWorkInfosByTag(fileId!!)
|
|
try {
|
|
for (workInfo in workers.get()) {
|
|
if (workInfo.state == WorkInfo.State.RUNNING || workInfo.state == WorkInfo.State.ENQUEUED) {
|
|
Log.d(TAG, "Download worker for $fileId is already running or scheduled")
|
|
return
|
|
}
|
|
}
|
|
} catch (e: ExecutionException) {
|
|
Log.e(TAG, "Error when checking if worker already exsists", e)
|
|
} catch (e: InterruptedException) {
|
|
Log.e(TAG, "Error when checking if worker already exsists", e)
|
|
}
|
|
val downloadWorker: OneTimeWorkRequest
|
|
val data: Data = Data.Builder()
|
|
.putString(DownloadFileToCacheWorker.KEY_BASE_URL, userEntity.baseUrl)
|
|
.putString(DownloadFileToCacheWorker.KEY_USER_ID, userEntity.userId)
|
|
.putString(
|
|
DownloadFileToCacheWorker.KEY_ATTACHMENT_FOLDER,
|
|
CapabilitiesUtil.getAttachmentFolder(userEntity)
|
|
)
|
|
.putString(DownloadFileToCacheWorker.KEY_FILE_NAME, fileName)
|
|
.putString(DownloadFileToCacheWorker.KEY_FILE_PATH, path)
|
|
.putInt(DownloadFileToCacheWorker.KEY_FILE_SIZE, fileSize)
|
|
.build()
|
|
downloadWorker = OneTimeWorkRequest.Builder(DownloadFileToCacheWorker::class.java)
|
|
.setInputData(data)
|
|
.addTag(fileId)
|
|
.build()
|
|
WorkManager.getInstance().enqueue(downloadWorker)
|
|
progressUi.progressBar?.visibility = View.VISIBLE
|
|
WorkManager.getInstance(context).getWorkInfoByIdLiveData(downloadWorker.id)
|
|
.observeForever { workInfo: WorkInfo? ->
|
|
updateViewsByProgress(
|
|
fileName,
|
|
mimetype,
|
|
workInfo!!,
|
|
progressUi
|
|
)
|
|
}
|
|
}
|
|
|
|
private fun updateViewsByProgress(
|
|
fileName: String,
|
|
mimetype: String,
|
|
workInfo: WorkInfo,
|
|
progressUi: ProgressUi
|
|
) {
|
|
when (workInfo.state) {
|
|
WorkInfo.State.RUNNING -> {
|
|
val progress = workInfo.progress.getInt(DownloadFileToCacheWorker.PROGRESS, -1)
|
|
if (progress > -1) {
|
|
progressUi.messageText?.text = String.format(
|
|
context.resources.getString(R.string.filename_progress),
|
|
fileName,
|
|
progress
|
|
)
|
|
}
|
|
}
|
|
WorkInfo.State.SUCCEEDED -> {
|
|
if (progressUi.previewImage.isShown) {
|
|
openFileByMimetype(fileName, mimetype)
|
|
} else {
|
|
Log.d(
|
|
TAG,
|
|
"file " + fileName +
|
|
" was downloaded but it's not opened because view is not shown on screen"
|
|
)
|
|
}
|
|
progressUi.messageText?.text = fileName
|
|
progressUi.progressBar?.visibility = View.GONE
|
|
}
|
|
WorkInfo.State.FAILED -> {
|
|
progressUi.messageText?.text = fileName
|
|
progressUi.progressBar?.visibility = View.GONE
|
|
}
|
|
else -> {
|
|
}
|
|
}
|
|
}
|
|
|
|
fun resumeToUpdateViewsByProgress(
|
|
fileName: String,
|
|
fileId: String,
|
|
mimeType: String,
|
|
progressUi: ProgressUi
|
|
) {
|
|
val workers = WorkManager.getInstance(context).getWorkInfosByTag(fileId)
|
|
|
|
try {
|
|
for (workInfo in workers.get()) {
|
|
if (workInfo.state == WorkInfo.State.RUNNING ||
|
|
workInfo.state == WorkInfo.State.ENQUEUED
|
|
) {
|
|
progressUi.progressBar?.visibility = View.VISIBLE
|
|
WorkManager
|
|
.getInstance(context)
|
|
.getWorkInfoByIdLiveData(workInfo.id)
|
|
.observeForever { info: WorkInfo? ->
|
|
updateViewsByProgress(
|
|
fileName,
|
|
mimeType,
|
|
info!!,
|
|
progressUi
|
|
)
|
|
}
|
|
}
|
|
}
|
|
} catch (e: ExecutionException) {
|
|
Log.e(TAG, "Error when checking if worker already exists", e)
|
|
} catch (e: InterruptedException) {
|
|
Log.e(TAG, "Error when checking if worker already exists", e)
|
|
}
|
|
}
|
|
|
|
data class ProgressUi(
|
|
val progressBar: ProgressBar?,
|
|
val messageText: EmojiTextView?,
|
|
val previewImage: SimpleDraweeView
|
|
)
|
|
|
|
companion object {
|
|
private val TAG = FileViewerUtils::class.simpleName
|
|
const val KEY_ID = "id"
|
|
}
|
|
}
|