847 lines
29 KiB
Kotlin
847 lines
29 KiB
Kotlin
package jp.juggler.subwaytooter
|
|
|
|
import android.annotation.SuppressLint
|
|
import android.app.DownloadManager
|
|
import android.content.ClipData
|
|
import android.content.ClipDescription
|
|
import android.content.ClipboardManager
|
|
import android.content.Intent
|
|
import android.graphics.*
|
|
import android.os.Build
|
|
import android.os.Bundle
|
|
import android.os.Environment
|
|
import android.os.SystemClock
|
|
import android.view.View
|
|
import android.view.Window
|
|
import androidx.appcompat.app.AppCompatActivity
|
|
import com.google.android.exoplayer2.*
|
|
import com.google.android.exoplayer2.Player.TimelineChangeReason
|
|
import com.google.android.exoplayer2.source.LoadEventInfo
|
|
import com.google.android.exoplayer2.source.MediaLoadData
|
|
import com.google.android.exoplayer2.source.MediaSource
|
|
import com.google.android.exoplayer2.source.MediaSourceEventListener
|
|
import com.google.android.exoplayer2.util.RepeatModeUtil.REPEAT_TOGGLE_MODE_ONE
|
|
import jp.juggler.subwaytooter.api.ApiTask
|
|
import jp.juggler.subwaytooter.api.TootApiClient
|
|
import jp.juggler.subwaytooter.api.TootApiResult
|
|
import jp.juggler.subwaytooter.api.entity.*
|
|
import jp.juggler.subwaytooter.api.runApiTask
|
|
import jp.juggler.subwaytooter.databinding.ActMediaViewerBinding
|
|
import jp.juggler.subwaytooter.dialog.ActionsDialog
|
|
import jp.juggler.subwaytooter.drawable.MediaBackgroundDrawable
|
|
import jp.juggler.subwaytooter.global.appPref
|
|
import jp.juggler.subwaytooter.pref.PrefI
|
|
import jp.juggler.subwaytooter.pref.put
|
|
import jp.juggler.subwaytooter.util.ProgressResponseBody
|
|
import jp.juggler.subwaytooter.view.PinchBitmapView
|
|
import jp.juggler.util.*
|
|
import kotlinx.coroutines.yield
|
|
import okhttp3.Request
|
|
import java.io.ByteArrayInputStream
|
|
import java.io.IOException
|
|
import java.util.*
|
|
import javax.net.ssl.HttpsURLConnection
|
|
import kotlin.math.max
|
|
|
|
class ActMediaViewer : AppCompatActivity(), View.OnClickListener {
|
|
|
|
companion object {
|
|
|
|
internal val log = LogCategory("ActMediaViewer")
|
|
|
|
internal val download_history_list = LinkedList<DownloadHistory>()
|
|
internal const val DOWNLOAD_REPEAT_EXPIRE = 3000L
|
|
internal const val short_limit = 5000L
|
|
|
|
internal const val EXTRA_IDX = "idx"
|
|
internal const val EXTRA_DATA = "data"
|
|
internal const val EXTRA_SERVICE_TYPE = "serviceType"
|
|
internal const val EXTRA_SHOW_DESCRIPTION = "showDescription"
|
|
|
|
internal const val STATE_PLAYER_POS = "playerPos"
|
|
internal const val STATE_PLAYER_PLAY_WHEN_READY = "playerPlayWhenReady"
|
|
internal const val STATE_LAST_VOLUME = "lastVolume"
|
|
|
|
internal fun <T : TootAttachmentLike> encodeMediaList(list: ArrayList<T>?) =
|
|
list?.encodeJson()?.toString() ?: "[]"
|
|
|
|
internal fun decodeMediaList(src: String?) =
|
|
ArrayList<TootAttachment>().apply {
|
|
src?.decodeJsonArray()?.forEach {
|
|
if (it !is JsonObject) return@forEach
|
|
add(TootAttachment.decodeJson(it))
|
|
}
|
|
}
|
|
|
|
fun open(
|
|
activity: ActMain,
|
|
showDescription: Boolean,
|
|
serviceType: ServiceType,
|
|
list: ArrayList<TootAttachmentLike>,
|
|
idx: Int,
|
|
) {
|
|
val intent = Intent(activity, ActMediaViewer::class.java)
|
|
intent.putExtra(EXTRA_IDX, idx)
|
|
intent.putExtra(EXTRA_SERVICE_TYPE, serviceType.ordinal)
|
|
intent.putExtra(EXTRA_DATA, encodeMediaList(list))
|
|
intent.putExtra(EXTRA_SHOW_DESCRIPTION, showDescription)
|
|
activity.startActivity(intent)
|
|
activity.overridePendingTransition(R.anim.slide_from_bottom, android.R.anim.fade_out)
|
|
}
|
|
}
|
|
|
|
class DownloadHistory(val time: Long, val url: String)
|
|
|
|
internal var idx: Int = 0
|
|
private lateinit var mediaList: ArrayList<TootAttachment>
|
|
private lateinit var serviceType: ServiceType
|
|
private var showDescription = true
|
|
|
|
private val views by lazy {
|
|
ActMediaViewerBinding.inflate(layoutInflater)
|
|
}
|
|
|
|
private lateinit var exoPlayer: ExoPlayer
|
|
|
|
private var lastVolume = Float.NaN
|
|
|
|
internal var bufferingLastShown: Long = 0
|
|
|
|
private var lastVideoUrl: String? = null
|
|
|
|
private val tileStep by lazy {
|
|
val density = resources.displayMetrics.density
|
|
(density * 12f + 0.5f).toInt()
|
|
}
|
|
|
|
private val playerListener = object : Player.Listener {
|
|
|
|
override fun onTimelineChanged(
|
|
timeline: Timeline,
|
|
@TimelineChangeReason reason: Int,
|
|
) {
|
|
log.d("exoPlayer onTimelineChanged reason=$reason")
|
|
}
|
|
|
|
override fun onShuffleModeEnabledChanged(shuffleModeEnabled: Boolean) {
|
|
}
|
|
|
|
private fun showBufferingToast() {
|
|
val playWhenReady = exoPlayer.playWhenReady
|
|
val playbackState = exoPlayer.playbackState
|
|
if (playWhenReady && playbackState == Player.STATE_BUFFERING) {
|
|
val now = SystemClock.elapsedRealtime()
|
|
if (now - bufferingLastShown >= short_limit && exoPlayer.duration >= short_limit) {
|
|
bufferingLastShown = now
|
|
showToast(false, R.string.video_buffering)
|
|
}
|
|
/*
|
|
exoPlayer.getDuration() may returns negative value (TIME_UNSET ,same as Long.MIN_VALUE + 1).
|
|
*/
|
|
}
|
|
}
|
|
|
|
override fun onPlaybackStateChanged(playbackState: Int) {
|
|
showBufferingToast()
|
|
}
|
|
|
|
override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
|
|
log.d("onPlayWhenReadyChanged playWhenReady=$playWhenReady, reason=$reason")
|
|
showBufferingToast()
|
|
}
|
|
|
|
override fun onRepeatModeChanged(repeatMode: Int) {
|
|
log.d("exoPlayer onRepeatModeChanged $repeatMode")
|
|
}
|
|
|
|
override fun onPlayerError(error: PlaybackException) {
|
|
log.w(error, "exoPlayer onPlayerError")
|
|
if (recoverLocalVideo()) return
|
|
showToast(error, "exoPlayer onPlayerError")
|
|
}
|
|
|
|
override fun onPositionDiscontinuity(
|
|
oldPosition: Player.PositionInfo,
|
|
newPosition: Player.PositionInfo,
|
|
reason: Int,
|
|
) {
|
|
log.d("exoPlayer onPositionDiscontinuity reason=$reason, oldPosition=$oldPosition, newPosition=$newPosition")
|
|
}
|
|
}
|
|
|
|
private val mediaSourceEventListener = object : MediaSourceEventListener {
|
|
override fun onLoadStarted(
|
|
windowIndex: Int,
|
|
mediaPeriodId: MediaSource.MediaPeriodId?,
|
|
loadEventInfo: LoadEventInfo,
|
|
mediaLoadData: MediaLoadData,
|
|
) {
|
|
log.d("onLoadStarted")
|
|
}
|
|
|
|
override fun onDownstreamFormatChanged(
|
|
windowIndex: Int,
|
|
mediaPeriodId: MediaSource.MediaPeriodId?,
|
|
mediaLoadData: MediaLoadData,
|
|
) {
|
|
log.d("onDownstreamFormatChanged")
|
|
}
|
|
|
|
override fun onUpstreamDiscarded(
|
|
windowIndex: Int,
|
|
mediaPeriodId: MediaSource.MediaPeriodId,
|
|
mediaLoadData: MediaLoadData,
|
|
) {
|
|
log.d("onUpstreamDiscarded")
|
|
}
|
|
|
|
override fun onLoadCompleted(
|
|
windowIndex: Int,
|
|
mediaPeriodId: MediaSource.MediaPeriodId?,
|
|
loadEventInfo: LoadEventInfo,
|
|
mediaLoadData: MediaLoadData,
|
|
) {
|
|
log.d("onLoadCompleted")
|
|
}
|
|
|
|
override fun onLoadCanceled(
|
|
windowIndex: Int,
|
|
mediaPeriodId: MediaSource.MediaPeriodId?,
|
|
loadEventInfo: LoadEventInfo,
|
|
mediaLoadData: MediaLoadData,
|
|
) {
|
|
log.d("onLoadCanceled")
|
|
}
|
|
|
|
override fun onLoadError(
|
|
windowIndex: Int,
|
|
mediaPeriodId: MediaSource.MediaPeriodId?,
|
|
loadEventInfo: LoadEventInfo,
|
|
mediaLoadData: MediaLoadData,
|
|
error: IOException,
|
|
wasCanceled: Boolean,
|
|
) {
|
|
showError(error.withCaption("load error."))
|
|
}
|
|
}
|
|
|
|
private val prDownload = permissionSpecMediaDownload.requester { download(mediaList[idx]) }
|
|
|
|
override fun onSaveInstanceState(outState: Bundle) {
|
|
super.onSaveInstanceState(outState)
|
|
|
|
log.d("onSaveInstanceState")
|
|
|
|
outState.putInt(EXTRA_IDX, idx)
|
|
outState.putInt(EXTRA_SERVICE_TYPE, serviceType.ordinal)
|
|
outState.putString(EXTRA_DATA, encodeMediaList(mediaList))
|
|
|
|
outState.putLong(STATE_PLAYER_POS, exoPlayer.currentPosition)
|
|
outState.putBoolean(STATE_PLAYER_PLAY_WHEN_READY, exoPlayer.playWhenReady)
|
|
outState.putFloat(STATE_LAST_VOLUME, lastVolume)
|
|
}
|
|
|
|
override fun onCreate(savedInstanceState: Bundle?) {
|
|
super.onCreate(savedInstanceState)
|
|
prDownload.register(this)
|
|
requestWindowFeature(Window.FEATURE_NO_TITLE)
|
|
App1.setActivityTheme(this, noActionBar = true, forceDark = true)
|
|
|
|
this.showDescription = intent.getBooleanExtra(EXTRA_SHOW_DESCRIPTION, showDescription)
|
|
|
|
this.serviceType = ServiceType.values()[
|
|
savedInstanceState?.getInt(EXTRA_SERVICE_TYPE)
|
|
?: intent.getIntExtra(EXTRA_SERVICE_TYPE, 0)
|
|
]
|
|
|
|
this.mediaList = decodeMediaList(
|
|
savedInstanceState?.getString(EXTRA_DATA)
|
|
?: intent.getStringExtra(EXTRA_DATA)
|
|
)
|
|
|
|
this.idx = (savedInstanceState?.getInt(EXTRA_IDX)
|
|
?: intent.getIntExtra(EXTRA_IDX, 0))
|
|
.takeIf { it in mediaList.indices }
|
|
?: 0
|
|
|
|
initUI()
|
|
|
|
load(savedInstanceState)
|
|
}
|
|
|
|
override fun onDestroy() {
|
|
super.onDestroy()
|
|
views.pbvImage.setBitmap(null)
|
|
exoPlayer.release()
|
|
}
|
|
|
|
override fun onStart() {
|
|
super.onStart()
|
|
views.exoView.onResume()
|
|
}
|
|
|
|
override fun onStop() {
|
|
super.onStop()
|
|
views.exoView.onPause()
|
|
}
|
|
|
|
override fun finish() {
|
|
super.finish()
|
|
overridePendingTransition(R.anim.fade_in, R.anim.slide_to_bottom)
|
|
}
|
|
|
|
internal fun initUI() {
|
|
setContentView(views.root)
|
|
App1.initEdgeToEdge(this)
|
|
|
|
views.pbvImage.background = MediaBackgroundDrawable(
|
|
context = views.root.context,
|
|
tileStep = tileStep,
|
|
kind = MediaBackgroundDrawable.Kind.fromIndex(PrefI.ipMediaBackground(this))
|
|
)
|
|
|
|
val enablePaging = mediaList.size > 1
|
|
views.btnPrevious.isEnabledAlpha = enablePaging
|
|
views.btnNext.isEnabledAlpha = enablePaging
|
|
|
|
views.btnPrevious.setOnClickListener(this)
|
|
views.btnNext.setOnClickListener(this)
|
|
findViewById<View>(R.id.btnDownload).setOnClickListener(this)
|
|
findViewById<View>(R.id.btnMore).setOnClickListener(this)
|
|
|
|
views.cbMute.setOnCheckedChangeListener { _, isChecked ->
|
|
if (isChecked) {
|
|
// mute
|
|
lastVolume = exoPlayer.volume
|
|
exoPlayer.volume = 0f
|
|
} else {
|
|
// unmute
|
|
exoPlayer.volume = when {
|
|
lastVolume.isNaN() -> 1f
|
|
lastVolume <= 0f -> 1f
|
|
else -> lastVolume
|
|
}
|
|
lastVolume = Float.NaN
|
|
}
|
|
}
|
|
|
|
views.pbvImage.setCallback(object : PinchBitmapView.Callback {
|
|
override fun onSwipe(deltaX: Int, deltaY: Int) {
|
|
if (isDestroyed) return
|
|
if (deltaX != 0) {
|
|
loadDelta(deltaX)
|
|
} else {
|
|
log.d("finish by vertical swipe")
|
|
finish()
|
|
}
|
|
}
|
|
|
|
override fun onMove(
|
|
bitmapW: Float,
|
|
bitmapH: Float,
|
|
tx: Float,
|
|
ty: Float,
|
|
scale: Float,
|
|
) {
|
|
App1.getAppState(this@ActMediaViewer).handler.post(Runnable {
|
|
if (isDestroyed) return@Runnable
|
|
if (views.tvStatus.visibility == View.VISIBLE) {
|
|
views.tvStatus.text = getString(
|
|
R.string.zooming_of,
|
|
bitmapW.toInt(),
|
|
bitmapH.toInt(),
|
|
scale
|
|
)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
exoPlayer = ExoPlayer.Builder(this).build()
|
|
exoPlayer.addListener(playerListener)
|
|
views.exoView.run {
|
|
player = exoPlayer
|
|
controllerAutoShow = false
|
|
setShowRewindButton(false)
|
|
setShowFastForwardButton(false)
|
|
setShowPreviousButton(false)
|
|
setShowNextButton(false)
|
|
setRepeatToggleModes(REPEAT_TOGGLE_MODE_ONE)
|
|
}
|
|
}
|
|
|
|
internal fun loadDelta(delta: Int) {
|
|
if (mediaList.size < 2) return
|
|
val size = mediaList.size
|
|
idx = (idx + size + delta) % size
|
|
load()
|
|
}
|
|
|
|
internal fun load(state: Bundle? = null) {
|
|
|
|
exoPlayer.stop()
|
|
|
|
// いったんすべて隠す
|
|
views.run {
|
|
pbvImage.gone()
|
|
exoView.gone()
|
|
tvError.gone()
|
|
svDescription.gone()
|
|
tvStatus.gone()
|
|
}
|
|
|
|
if (idx < 0 || idx >= mediaList.size) {
|
|
showError(getString(R.string.media_attachment_empty))
|
|
return
|
|
}
|
|
val ta = mediaList[idx]
|
|
val description = ta.description
|
|
if (showDescription && description?.isNotEmpty() == true) {
|
|
views.svDescription.visible()
|
|
views.tvDescription.text = description
|
|
}
|
|
|
|
when (ta.type) {
|
|
TootAttachmentType.Unknown,
|
|
-> showError(getString(R.string.media_attachment_type_error, ta.type.id))
|
|
|
|
TootAttachmentType.Image,
|
|
-> loadBitmap(ta)
|
|
|
|
TootAttachmentType.Video,
|
|
TootAttachmentType.GIFV,
|
|
TootAttachmentType.Audio,
|
|
-> loadVideo(ta, state)
|
|
}
|
|
}
|
|
|
|
private fun showError(message: String) {
|
|
views.run {
|
|
exoView.gone()
|
|
pbvImage.gone()
|
|
tvError.visible().text = message
|
|
}
|
|
}
|
|
|
|
private fun loadVideo(
|
|
ta: TootAttachment,
|
|
state: Bundle? = null,
|
|
forceLocalUrl: Boolean = false,
|
|
) {
|
|
|
|
views.cbMute.visible().run {
|
|
if (isChecked && lastVolume.isFinite()) {
|
|
exoPlayer.volume = 0f
|
|
}
|
|
}
|
|
|
|
val url = when {
|
|
forceLocalUrl -> ta.url
|
|
else -> ta.getLargeUrl(appPref)
|
|
}
|
|
if (url == null) {
|
|
showError("missing media attachment url.")
|
|
return
|
|
}
|
|
val uri = url.mayUri()
|
|
if (uri == null) {
|
|
showError("can't parse URI: $url")
|
|
return
|
|
}
|
|
lastVideoUrl = url
|
|
|
|
// https://github.com/google/ExoPlayer/issues/1819
|
|
HttpsURLConnection.setDefaultSSLSocketFactory(MySslSocketFactory)
|
|
views.exoView.visibility = View.VISIBLE
|
|
exoPlayer.setMediaItem(MediaItem.fromUri(uri))
|
|
exoPlayer.prepare()
|
|
exoPlayer.repeatMode = when (ta.type) {
|
|
TootAttachmentType.Video -> Player.REPEAT_MODE_OFF
|
|
// GIFV or AUDIO
|
|
else -> Player.REPEAT_MODE_ALL
|
|
}
|
|
if (state == null) {
|
|
exoPlayer.playWhenReady = true
|
|
} else {
|
|
exoPlayer.playWhenReady = state.getBoolean(STATE_PLAYER_PLAY_WHEN_READY, true)
|
|
exoPlayer.seekTo(max(0L, state.getLong(STATE_PLAYER_POS, 0L)))
|
|
lastVolume = state.getFloat(STATE_LAST_VOLUME, 1f)
|
|
}
|
|
}
|
|
|
|
private fun decodeBitmap(
|
|
options: BitmapFactory.Options,
|
|
data: ByteArray,
|
|
@Suppress("SameParameterValue") pixelMax: Int,
|
|
): Pair<Bitmap?, String?> {
|
|
|
|
val orientation: Int? = ByteArrayInputStream(data).imageOrientation()
|
|
|
|
// detects image size
|
|
options.inJustDecodeBounds = true
|
|
options.inScaled = false
|
|
options.outWidth = 0
|
|
options.outHeight = 0
|
|
BitmapFactory.decodeByteArray(data, 0, data.size, options)
|
|
var w = options.outWidth
|
|
var h = options.outHeight
|
|
if (w <= 0 || h <= 0) {
|
|
return Pair(null, "can't decode image bounds.")
|
|
}
|
|
|
|
// calc bits to reduce size
|
|
var bits = 0
|
|
while (w > pixelMax || h > pixelMax) {
|
|
++bits
|
|
w = w shr 1
|
|
h = h shr 1
|
|
}
|
|
options.inJustDecodeBounds = false
|
|
options.inSampleSize = 1 shl bits
|
|
|
|
// decode image
|
|
val bitmap1 = BitmapFactory.decodeByteArray(data, 0, data.size, options)
|
|
?: return Pair(null, "BitmapFactory.decodeByteArray returns null.")
|
|
|
|
val srcWidth = bitmap1.width.toFloat()
|
|
val srcHeight = bitmap1.height.toFloat()
|
|
if (srcWidth <= 0f || srcHeight <= 0f) {
|
|
bitmap1.recycle()
|
|
return Pair(null, "image size <= 0")
|
|
}
|
|
|
|
val dstSize = rotateSize(orientation, srcWidth, srcHeight)
|
|
val dstSizeInt = Point(
|
|
max(1, (dstSize.x + 0.5f).toInt()),
|
|
max(1, (dstSize.y + 0.5f).toInt())
|
|
)
|
|
|
|
// 回転行列を作る
|
|
val matrix = Matrix()
|
|
matrix.reset()
|
|
|
|
// 画像の中心が原点に来るようにして
|
|
matrix.postTranslate(srcWidth * -0.5f, srcHeight * -0.5f)
|
|
|
|
// orientationに合わせた回転指定
|
|
matrix.resolveOrientation(orientation)
|
|
|
|
// 表示領域に埋まるように平行移動
|
|
matrix.postTranslate(dstSize.x * 0.5f, dstSize.y * 0.5f)
|
|
|
|
// 回転後の画像
|
|
val bitmap2 = try {
|
|
Bitmap.createBitmap(dstSizeInt.x, dstSizeInt.y, Bitmap.Config.ARGB_8888)
|
|
?: return Pair(bitmap1, "createBitmap returns null")
|
|
} catch (ex: Throwable) {
|
|
log.e(ex, "createBitmap failed.")
|
|
return Pair(bitmap1, ex.withCaption("createBitmap failed."))
|
|
}
|
|
|
|
try {
|
|
Canvas(bitmap2).drawBitmap(
|
|
bitmap1,
|
|
matrix,
|
|
Paint().apply { isFilterBitmap = true }
|
|
)
|
|
} catch (ex: Throwable) {
|
|
bitmap2.recycle()
|
|
log.e(ex, "drawBitmap failed.")
|
|
return Pair(bitmap1, ex.withCaption("drawBitmap failed."))
|
|
}
|
|
|
|
try {
|
|
bitmap1.recycle()
|
|
} catch (ignored: Throwable) {
|
|
}
|
|
return Pair(bitmap2, null)
|
|
}
|
|
|
|
private suspend fun getHttpCached(
|
|
client: TootApiClient,
|
|
url: String,
|
|
): Pair<TootApiResult?, ByteArray?> {
|
|
val result = TootApiResult.makeWithCaption(url)
|
|
|
|
val request = try {
|
|
Request.Builder()
|
|
.url(url)
|
|
.cacheControl(App1.CACHE_CONTROL)
|
|
.addHeader("Accept", "image/webp,image/*,*/*;q=0.8")
|
|
.build()
|
|
} catch (ex: Throwable) {
|
|
result.setError(ex.withCaption("incorrect URL."))
|
|
return Pair(result, null)
|
|
}
|
|
|
|
if (!client.sendRequest(result, tmpOkhttpClient = App1.ok_http_client_media_viewer) {
|
|
request
|
|
}) return Pair(result, null)
|
|
|
|
if (client.isApiCancelled()) return Pair(null, null)
|
|
|
|
val response = result.response!!
|
|
if (!response.isSuccessful) {
|
|
result.parseErrorResponse()
|
|
return Pair(result, null)
|
|
}
|
|
|
|
try {
|
|
val ba = ProgressResponseBody.bytes(response) { bytesRead, bytesTotal ->
|
|
// 50MB以上のデータはキャンセルする
|
|
if (max(bytesRead, bytesTotal) >= 50000000) {
|
|
error("media attachment is larger than 50000000")
|
|
}
|
|
client.publishApiProgressRatio(bytesRead.toInt(), bytesTotal.toInt())
|
|
}
|
|
if (client.isApiCancelled()) return Pair(null, null)
|
|
return Pair(result, ba)
|
|
} catch (ignored: Throwable) {
|
|
result.parseErrorResponse("?")
|
|
return Pair(result, null)
|
|
}
|
|
}
|
|
|
|
@SuppressLint("StaticFieldLeak")
|
|
private fun loadBitmap(ta: TootAttachment) {
|
|
|
|
views.run {
|
|
cbMute.gone()
|
|
tvStatus.visible().text = null
|
|
pbvImage.visible().setBitmap(null)
|
|
}
|
|
|
|
val urlList = ta.getLargeUrlList(appPref)
|
|
if (urlList.isEmpty()) {
|
|
showError("missing media attachment url.")
|
|
return
|
|
}
|
|
|
|
launchMain {
|
|
val options = BitmapFactory.Options()
|
|
|
|
var resultBitmap: Bitmap? = null
|
|
|
|
runApiTask(progressStyle = ApiTask.PROGRESS_HORIZONTAL) { client ->
|
|
if (urlList.isEmpty()) return@runApiTask TootApiResult("missing url")
|
|
var lastResult: TootApiResult? = null
|
|
for (url in urlList) {
|
|
val (result, ba) = getHttpCached(client, url)
|
|
lastResult = result
|
|
if (ba != null) {
|
|
client.publishApiProgress("decoding image…")
|
|
|
|
val (bitmap, error) = decodeBitmap(options, ba, 2048)
|
|
if (bitmap != null) {
|
|
resultBitmap = bitmap
|
|
break
|
|
}
|
|
if (error != null) lastResult = TootApiResult(error)
|
|
}
|
|
}
|
|
lastResult
|
|
}.let { result -> // may null
|
|
when (val bitmap = resultBitmap) {
|
|
null -> if (result != null) showToast(true, result.error)
|
|
else -> views.pbvImage.setBitmap(bitmap)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onClick(v: View) {
|
|
try {
|
|
when (v) {
|
|
views.btnPrevious -> loadDelta(-1)
|
|
views.btnNext -> loadDelta(+1)
|
|
views.btnDownload -> download(mediaList[idx])
|
|
views.btnMore -> more(mediaList[idx])
|
|
}
|
|
} catch (ex: Throwable) {
|
|
showToast(ex, "action failed.")
|
|
}
|
|
}
|
|
|
|
private fun download(ta: TootAttachmentLike) {
|
|
if (!prDownload.checkOrLaunch()) return
|
|
|
|
val downLoadManager: DownloadManager = systemService(this)
|
|
?: error("missing DownloadManager system service")
|
|
|
|
val url = if (ta is TootAttachment) {
|
|
ta.getLargeUrl(appPref)
|
|
} else {
|
|
null
|
|
} ?: return
|
|
|
|
// ボタン連打対策
|
|
run {
|
|
val now = SystemClock.elapsedRealtime()
|
|
|
|
// 期限切れの履歴を削除
|
|
val it = download_history_list.iterator()
|
|
while (it.hasNext()) {
|
|
val dh = it.next()
|
|
if (now - dh.time >= DOWNLOAD_REPEAT_EXPIRE) {
|
|
// この履歴は十分に古いので捨てる
|
|
it.remove()
|
|
} else if (url == dh.url) {
|
|
// 履歴に同じURLがあればエラーとする
|
|
showToast(false, R.string.dont_repeat_download_to_same_url)
|
|
return
|
|
}
|
|
}
|
|
// 履歴の末尾に追加(履歴は古い順に並ぶ)
|
|
download_history_list.addLast(DownloadHistory(now, url))
|
|
}
|
|
|
|
val fileName = (
|
|
url.mayUri()?.pathSegments?.findLast { !it.isNullOrBlank() }
|
|
?: url
|
|
.replaceFirst("https?://".asciiPattern(), "")
|
|
.replaceAll("[^.\\w\\d]+".asciiPattern(), "-")
|
|
)
|
|
.take(20)
|
|
|
|
val request = DownloadManager.Request(url.toUri())
|
|
request.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, fileName)
|
|
request.setTitle(fileName)
|
|
request.setAllowedNetworkTypes(DownloadManager.Request.NETWORK_MOBILE or DownloadManager.Request.NETWORK_WIFI)
|
|
|
|
// Android 10 以降では allowScanningByMediaScanner は無視される
|
|
if (Build.VERSION.SDK_INT < 29) {
|
|
//メディアスキャンを許可する
|
|
@Suppress("DEPRECATION")
|
|
request.allowScanningByMediaScanner()
|
|
}
|
|
|
|
//ダウンロード中・ダウンロード完了時にも通知を表示する
|
|
request.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
|
|
|
|
downLoadManager.enqueue(request)
|
|
showToast(false, R.string.downloading)
|
|
}
|
|
|
|
private fun share(action: String, url: String) {
|
|
|
|
try {
|
|
val intent = Intent(action)
|
|
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
|
if (action == Intent.ACTION_SEND) {
|
|
intent.type = "text/plain"
|
|
intent.putExtra(Intent.EXTRA_TEXT, url)
|
|
} else {
|
|
intent.data = url.toUri()
|
|
}
|
|
|
|
startActivity(intent)
|
|
} catch (ex: Throwable) {
|
|
showToast(ex, "can't open app.")
|
|
}
|
|
}
|
|
|
|
private fun copy(url: String) {
|
|
val cm = getSystemService(CLIPBOARD_SERVICE) as? ClipboardManager
|
|
?: throw NotImplementedError("missing ClipboardManager system service")
|
|
|
|
try {
|
|
//クリップボードに格納するItemを作成
|
|
val item = ClipData.Item(url)
|
|
|
|
val mimeType = arrayOfNulls<String>(1)
|
|
mimeType[0] = ClipDescription.MIMETYPE_TEXT_PLAIN
|
|
|
|
//クリップボードに格納するClipDataオブジェクトの作成
|
|
val cd = ClipData(ClipDescription("media URL", mimeType), item)
|
|
|
|
//クリップボードにデータを格納
|
|
cm.setPrimaryClip(cd)
|
|
|
|
showToast(false, R.string.url_is_copied)
|
|
} catch (ex: Throwable) {
|
|
showToast(ex, "clipboard access failed.")
|
|
}
|
|
}
|
|
|
|
private fun more(ta: TootAttachmentLike) {
|
|
val ad = ActionsDialog()
|
|
if (ta is TootAttachment) {
|
|
val url = ta.getLargeUrl(appPref) ?: return
|
|
ad.addAction(getString(R.string.open_in_browser)) { share(Intent.ACTION_VIEW, url) }
|
|
ad.addAction(getString(R.string.share_url)) { share(Intent.ACTION_SEND, url) }
|
|
ad.addAction(getString(R.string.copy_url)) { copy(url) }
|
|
addMoreMenu(ad, "url", ta.url, Intent.ACTION_VIEW)
|
|
addMoreMenu(ad, "remote_url", ta.remote_url, Intent.ACTION_VIEW)
|
|
addMoreMenu(ad, "preview_url", ta.preview_url, Intent.ACTION_VIEW)
|
|
addMoreMenu(ad, "preview_remote_url", ta.preview_remote_url, Intent.ACTION_VIEW)
|
|
addMoreMenu(ad, "text_url", ta.text_url, Intent.ACTION_VIEW)
|
|
} else if (ta is TootAttachmentMSP) {
|
|
val url = ta.preview_url
|
|
ad.addAction(getString(R.string.open_in_browser)) { share(Intent.ACTION_VIEW, url) }
|
|
ad.addAction(getString(R.string.share_url)) { share(Intent.ACTION_SEND, url) }
|
|
ad.addAction(getString(R.string.copy_url)) { copy(url) }
|
|
}
|
|
|
|
if (TootAttachmentType.Image == mediaList.elementAtOrNull(idx)?.type) {
|
|
ad.addAction(getString(R.string.background_pattern)) { mediaBackgroundDialog() }
|
|
}
|
|
|
|
ad.show(this, null)
|
|
}
|
|
|
|
private fun addMoreMenu(
|
|
ad: ActionsDialog,
|
|
captionPrefix: String,
|
|
url: String?,
|
|
@Suppress("SameParameterValue") action: String,
|
|
) {
|
|
val uri = url.mayUri() ?: return
|
|
val caption = getString(R.string.open_browser_of, captionPrefix)
|
|
ad.addAction(caption) {
|
|
try {
|
|
val intent = Intent(action, uri)
|
|
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
|
startActivity(intent)
|
|
} catch (ex: Throwable) {
|
|
showToast(ex, "can't open app.")
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun mediaBackgroundDialog() {
|
|
val ad = ActionsDialog()
|
|
for (k in MediaBackgroundDrawable.Kind.values()) {
|
|
if (!k.isMediaBackground) continue
|
|
ad.addAction(k.name) {
|
|
val idx = k.toIndex()
|
|
appPref.edit().put(PrefI.ipMediaBackground, idx).apply()
|
|
views.pbvImage.background = MediaBackgroundDrawable(
|
|
context = views.root.context,
|
|
tileStep = tileStep,
|
|
kind = k
|
|
)
|
|
}
|
|
}
|
|
ad.show(this, getString(R.string.background_pattern))
|
|
}
|
|
|
|
/**
|
|
* remote_urlを再生できなかった場合、自サーバで再生し直す
|
|
*/
|
|
private fun recoverLocalVideo(): Boolean {
|
|
val ta = mediaList.elementAtOrNull(idx)
|
|
if (ta != null &&
|
|
lastVideoUrl == ta.remote_url &&
|
|
!ta.url.isNullOrEmpty() &&
|
|
ta.url != ta.remote_url
|
|
) {
|
|
launchMain {
|
|
yield()
|
|
loadVideo(ta, forceLocalUrl = true)
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
}
|