603 lines
22 KiB
Kotlin
603 lines
22 KiB
Kotlin
package jp.juggler.subwaytooter
|
||
|
||
import android.annotation.SuppressLint
|
||
import android.content.*
|
||
import android.media.Ringtone
|
||
import android.media.RingtoneManager
|
||
import android.net.Uri
|
||
import android.os.Handler
|
||
import android.os.SystemClock
|
||
import android.speech.tts.TextToSpeech
|
||
import android.speech.tts.Voice
|
||
import android.text.Spannable
|
||
import jp.juggler.subwaytooter.api.entity.TootStatus
|
||
import jp.juggler.subwaytooter.column.Column
|
||
import jp.juggler.subwaytooter.column.ColumnEncoder
|
||
import jp.juggler.subwaytooter.column.getBackgroundImageDir
|
||
import jp.juggler.subwaytooter.column.onMuteUpdated
|
||
import jp.juggler.subwaytooter.span.MyClickableSpan
|
||
import jp.juggler.subwaytooter.streaming.StreamManager
|
||
import jp.juggler.subwaytooter.table.*
|
||
import jp.juggler.subwaytooter.util.NetworkStateTracker
|
||
import jp.juggler.subwaytooter.util.PostAttachment
|
||
import jp.juggler.util.*
|
||
import jp.juggler.util.coroutine.launchIO
|
||
import jp.juggler.util.coroutine.runOnMainLooper
|
||
import jp.juggler.util.data.*
|
||
import jp.juggler.util.log.LogCategory
|
||
import jp.juggler.util.log.showToast
|
||
import java.io.File
|
||
import java.io.FileNotFoundException
|
||
import java.lang.ref.WeakReference
|
||
import java.util.*
|
||
import kotlin.math.max
|
||
|
||
enum class DedupMode {
|
||
None,
|
||
RecentExpire,
|
||
Recent,
|
||
}
|
||
|
||
class DedupItem(
|
||
val text: String,
|
||
var time: Long = SystemClock.elapsedRealtime(),
|
||
)
|
||
|
||
class AppState(
|
||
internal val context: Context,
|
||
internal val handler: Handler,
|
||
) {
|
||
|
||
companion object {
|
||
|
||
internal val log = LogCategory("AppState")
|
||
|
||
private const val FILE_COLUMN_LIST = "column_list"
|
||
|
||
private const val TTS_STATUS_NONE = 0
|
||
private const val TTS_STATUS_INITIALIZING = 1
|
||
private const val TTS_STATUS_INITIALIZED = 2
|
||
|
||
private const val tts_speak_wait_expire = 1000L * 100
|
||
private val random = Random()
|
||
|
||
private val reSpaces = "[\\s ]+".asciiPattern()
|
||
|
||
private var utteranceIdSeed = 0
|
||
|
||
internal fun saveColumnList(context: Context, fileName: String, array: JsonArray) {
|
||
synchronized(log) {
|
||
try {
|
||
val tmpName =
|
||
"tmpColumnList.${System.currentTimeMillis()}.${Thread.currentThread().id}"
|
||
val tmpFile = context.getFileStreamPath(tmpName)
|
||
try {
|
||
// write to tmp file
|
||
context.openFileOutput(tmpName, Context.MODE_PRIVATE).use { os ->
|
||
os.write(array.toString().encodeUTF8())
|
||
}
|
||
// rename
|
||
val outFile = context.getFileStreamPath(fileName)
|
||
if (!tmpFile.renameTo(outFile)) {
|
||
error("saveColumnList: rename failed!")
|
||
} else {
|
||
log.d("saveColumnList: rename ok: $outFile")
|
||
}
|
||
Unit
|
||
} finally {
|
||
tmpFile.delete() // ignore return value
|
||
}
|
||
} catch (ex: Throwable) {
|
||
log.e(ex, "saveColumnList failed.")
|
||
context.showToast(ex, "saveColumnList failed.")
|
||
}
|
||
}
|
||
}
|
||
|
||
internal fun loadColumnList(context: Context, fileName: String): JsonArray? {
|
||
synchronized(log) {
|
||
try {
|
||
return context.openFileInput(fileName).use { inData ->
|
||
inData.readBytes().decodeUTF8().decodeJsonArray()
|
||
}
|
||
} catch (ignored: FileNotFoundException) {
|
||
} catch (ex: Throwable) {
|
||
log.e(ex, "loadColumnList failed.")
|
||
context.showToast(ex, "loadColumnList failed.")
|
||
}
|
||
return null
|
||
}
|
||
}
|
||
|
||
private fun getStatusText(status: TootStatus?): Spannable? {
|
||
return when {
|
||
status == null -> null
|
||
status.decoded_spoiler_text.isNotEmpty() -> status.decoded_spoiler_text
|
||
status.decoded_content.isNotEmpty() -> status.decoded_content
|
||
else -> null
|
||
}
|
||
}
|
||
}
|
||
|
||
internal val density: Float
|
||
|
||
internal val streamManager: StreamManager
|
||
|
||
internal var mediaThumbHeight: Int = 0
|
||
|
||
private val _columnList = ArrayList<Column>()
|
||
|
||
// make shallow copy
|
||
val columnList: List<Column>
|
||
get() = synchronized(_columnList) { ArrayList(_columnList) }
|
||
|
||
val columnCount: Int
|
||
get() = synchronized(_columnList) { _columnList.size }
|
||
|
||
fun column(i: Int) =
|
||
synchronized(_columnList) { _columnList.elementAtOrNull(i) }
|
||
|
||
fun columnIndex(column: Column?) =
|
||
synchronized(_columnList) { _columnList.indexOf(column).takeIf { it != -1 } }
|
||
|
||
fun editColumnList(save: Boolean = true, block: (ArrayList<Column>) -> Unit) {
|
||
synchronized(_columnList) {
|
||
block(_columnList)
|
||
if (save) saveColumnList()
|
||
}
|
||
}
|
||
|
||
private val mapBusyFav = HashSet<String>()
|
||
private val mapBusyBookmark = HashSet<String>()
|
||
private val mapBusyBoost = HashSet<String>()
|
||
internal var attachmentList: ArrayList<PostAttachment>? = null
|
||
|
||
private var willSpeechEnabled: Boolean = false
|
||
private var tts: TextToSpeech? = null
|
||
private var ttsStatus = TTS_STATUS_NONE
|
||
private var ttsSpeakStart = 0L
|
||
private var ttsSpeakEnd = 0L
|
||
|
||
private val voiceList = ArrayList<Voice>()
|
||
|
||
private val ttsQueue = LinkedList<String>()
|
||
|
||
private val duplicationCheck = LinkedList<DedupItem>()
|
||
|
||
private var lastRingtone: WeakReference<Ringtone>? = null
|
||
|
||
private var lastSound: Long = 0
|
||
|
||
val networkTracker: NetworkStateTracker
|
||
|
||
// initからプロパティにアクセスする場合、そのプロパティはinitより上で定義されていないとダメっぽい
|
||
// そしてその他のメソッドからval プロパティにアクセスする場合、そのプロパティはメソッドより上で初期化されていないとダメっぽい
|
||
init {
|
||
|
||
this.density = context.resources.displayMetrics.density
|
||
this.streamManager = StreamManager(this)
|
||
this.networkTracker = NetworkStateTracker(context) {
|
||
App1.custom_emoji_cache.onNetworkChanged()
|
||
App1.custom_emoji_lister.onNetworkChanged()
|
||
}
|
||
}
|
||
|
||
//////////////////////////////////////////////////////
|
||
// TextToSpeech
|
||
|
||
private val isTextToSpeechRequired: Boolean
|
||
get() = columnList.any { it.enableSpeech } || daoHighlightWord.hasTextToSpeechHighlightWord()
|
||
|
||
private val ttsReceiver = object : BroadcastReceiver() {
|
||
override fun onReceive(context: Context, intent: Intent?) {
|
||
if (intent != null) {
|
||
if (TextToSpeech.ACTION_TTS_QUEUE_PROCESSING_COMPLETED == intent.action) {
|
||
log.d("tts_receiver: speech completed.")
|
||
ttsSpeakEnd = SystemClock.elapsedRealtime()
|
||
handler.post(procFlushSpeechQueue)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private val procFlushSpeechQueue = object : Runnable {
|
||
override fun run() {
|
||
try {
|
||
handler.removeCallbacks(this)
|
||
|
||
val queue_count = ttsQueue.size
|
||
if (queue_count <= 0) {
|
||
return
|
||
}
|
||
|
||
val tts = this@AppState.tts
|
||
if (tts == null) {
|
||
log.d("proc_flushSpeechQueue: tts is null")
|
||
return
|
||
}
|
||
|
||
val now = SystemClock.elapsedRealtime()
|
||
|
||
if (ttsSpeakStart >= max(1L, ttsSpeakEnd)) {
|
||
// まだ終了イベントを受け取っていない
|
||
val expire_remain = tts_speak_wait_expire + ttsSpeakStart - now
|
||
if (expire_remain <= 0) {
|
||
log.d("proc_flushSpeechQueue: tts_speak wait expired.")
|
||
restartTTS()
|
||
} else {
|
||
log.d(
|
||
"proc_flushSpeechQueue: tts is speaking. queue_count=$queue_count, expire_remain=${
|
||
"%.3f".format(expire_remain.div(1000f))
|
||
}"
|
||
)
|
||
handler.postDelayed(this, expire_remain)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
val sv = ttsQueue.removeFirst()
|
||
log.d("proc_flushSpeechQueue: speak $sv")
|
||
|
||
val voice_count = voiceList.size
|
||
if (voice_count > 0) {
|
||
val n = random.nextInt(voice_count)
|
||
tts.voice = voiceList[n]
|
||
}
|
||
|
||
ttsSpeakStart = now
|
||
tts.speak(
|
||
sv,
|
||
TextToSpeech.QUEUE_ADD,
|
||
null, // Bundle params
|
||
(++utteranceIdSeed).toString() // String utteranceId
|
||
)
|
||
} catch (ex: Throwable) {
|
||
log.e(ex, "proc_flushSpeechQueue catch exception.")
|
||
restartTTS()
|
||
}
|
||
}
|
||
|
||
fun restartTTS() {
|
||
log.d("restart TextToSpeech")
|
||
tts?.shutdown()
|
||
tts = null
|
||
ttsStatus = TTS_STATUS_NONE
|
||
enableSpeech()
|
||
}
|
||
}
|
||
|
||
internal fun encodeColumnList() =
|
||
columnList.mapIndexedNotNull { index, column ->
|
||
try {
|
||
val dst = JsonObject()
|
||
ColumnEncoder.encode(column, dst, index)
|
||
dst
|
||
} catch (ex: JsonException) {
|
||
log.e(ex, "encodeColumnList: encode failed at $index.")
|
||
null
|
||
}
|
||
}.toJsonArray()
|
||
|
||
internal fun saveColumnList(bEnableSpeech: Boolean = true) {
|
||
val array = encodeColumnList()
|
||
saveColumnList(context, FILE_COLUMN_LIST, array)
|
||
if (bEnableSpeech) enableSpeech()
|
||
}
|
||
|
||
fun loadColumnList() {
|
||
val list = loadColumnList(context, FILE_COLUMN_LIST)
|
||
?.objectList()
|
||
?.mapIndexedNotNull { index, src ->
|
||
try {
|
||
Column(this, src)
|
||
} catch (ex: Throwable) {
|
||
log.e(ex, "loadColumnList: decode column failed at $index")
|
||
null
|
||
}
|
||
}
|
||
if (list != null) editColumnList(save = false) { it.addAll(list) }
|
||
|
||
// ミュートデータのロード
|
||
TootStatus.muted_app = daoMutedApp.nameSet()
|
||
TootStatus.muted_word = daoMutedWord.nameSet()
|
||
|
||
// 背景フォルダの掃除
|
||
try {
|
||
val backgroundImageDir = getBackgroundImageDir(context)
|
||
backgroundImageDir.list()?.forEach { name ->
|
||
val file = File(backgroundImageDir, name)
|
||
if (file.isFile) {
|
||
val delm = name.indexOf(':')
|
||
val id = if (delm != -1) name.substring(0, delm) else name
|
||
val column = ColumnEncoder.findColumnById(id)
|
||
if (column == null) file.delete()
|
||
}
|
||
}
|
||
} catch (ex: Throwable) {
|
||
// クラッシュレポートによると状態が悪いとダメらしい
|
||
// java.lang.IllegalStateException
|
||
log.e(ex, "loadColumnList failed.")
|
||
}
|
||
}
|
||
|
||
fun isBusyFav(account: SavedAccount, status: TootStatus): Boolean {
|
||
val key = account.acct.ascii + ":" + status.busyKey
|
||
return mapBusyFav.contains(key)
|
||
}
|
||
|
||
fun setBusyFav(account: SavedAccount, status: TootStatus) {
|
||
val key = account.acct.ascii + ":" + status.busyKey
|
||
mapBusyFav.add(key)
|
||
}
|
||
|
||
fun resetBusyFav(account: SavedAccount, status: TootStatus) {
|
||
val key = account.acct.ascii + ":" + status.busyKey
|
||
mapBusyFav.remove(key)
|
||
}
|
||
|
||
fun isBusyBookmark(account: SavedAccount, status: TootStatus): Boolean {
|
||
val key = account.acct.ascii + ":" + status.busyKey
|
||
return mapBusyBookmark.contains(key)
|
||
}
|
||
|
||
fun setBusyBookmark(account: SavedAccount, status: TootStatus) {
|
||
val key = account.acct.ascii + ":" + status.busyKey
|
||
mapBusyBookmark.add(key)
|
||
}
|
||
|
||
fun resetBusyBookmark(account: SavedAccount, status: TootStatus) {
|
||
val key = account.acct.ascii + ":" + status.busyKey
|
||
mapBusyBookmark.remove(key)
|
||
}
|
||
|
||
fun isBusyBoost(account: SavedAccount, status: TootStatus): Boolean {
|
||
val key = account.acct.ascii + ":" + status.busyKey
|
||
return mapBusyBoost.contains(key)
|
||
}
|
||
|
||
fun setBusyBoost(account: SavedAccount, status: TootStatus) {
|
||
val key = account.acct.ascii + ":" + status.busyKey
|
||
mapBusyBoost.add(key)
|
||
}
|
||
|
||
fun resetBusyBoost(account: SavedAccount, status: TootStatus) {
|
||
val key = account.acct.ascii + ":" + status.busyKey
|
||
mapBusyBoost.remove(key)
|
||
}
|
||
|
||
@SuppressLint("StaticFieldLeak")
|
||
fun enableSpeech() {
|
||
this.willSpeechEnabled = isTextToSpeechRequired
|
||
|
||
if (willSpeechEnabled && tts == null && ttsStatus == TTS_STATUS_NONE) {
|
||
ttsStatus = TTS_STATUS_INITIALIZING
|
||
context.showToast(false, R.string.text_to_speech_initializing)
|
||
log.d("initializing TextToSpeech…")
|
||
|
||
launchIO {
|
||
|
||
var tmpTts: TextToSpeech? = null
|
||
|
||
val ttsInitListener: TextToSpeech.OnInitListener =
|
||
TextToSpeech.OnInitListener { status ->
|
||
|
||
val tts = tmpTts
|
||
if (tts == null || TextToSpeech.SUCCESS != status) {
|
||
context.showToast(
|
||
false,
|
||
R.string.text_to_speech_initialize_failed,
|
||
status
|
||
)
|
||
log.d("speech initialize failed. status=$status")
|
||
return@OnInitListener
|
||
}
|
||
|
||
runOnMainLooper {
|
||
if (!willSpeechEnabled) {
|
||
context.showToast(false, R.string.text_to_speech_shutdown)
|
||
log.d("shutdown TextToSpeech…")
|
||
tts.shutdown()
|
||
} else {
|
||
this@AppState.tts = tts
|
||
ttsStatus = TTS_STATUS_INITIALIZED
|
||
ttsSpeakStart = 0L
|
||
ttsSpeakEnd = 0L
|
||
|
||
voiceList.clear()
|
||
try {
|
||
val voiceSet = try {
|
||
tts.voices
|
||
// may raise NullPointerException is tts has no collection
|
||
} catch (ignored: Throwable) {
|
||
null
|
||
}
|
||
if (voiceSet == null || voiceSet.isEmpty()) {
|
||
log.d("TextToSpeech.getVoices returns null or empty set.")
|
||
} else {
|
||
val lang = defaultLocale(context).toLanguageTag()
|
||
for (v in voiceSet) {
|
||
log.d("Voice ${v.name} ${v.locale.toLanguageTag()} $lang")
|
||
if (lang != v.locale.toLanguageTag()) continue
|
||
voiceList.add(v)
|
||
}
|
||
}
|
||
} catch (ex: Throwable) {
|
||
log.e(ex, "TextToSpeech.getVoices raises exception.")
|
||
}
|
||
|
||
handler.post(procFlushSpeechQueue)
|
||
|
||
context.registerReceiver(
|
||
ttsReceiver,
|
||
IntentFilter(TextToSpeech.ACTION_TTS_QUEUE_PROCESSING_COMPLETED)
|
||
)
|
||
|
||
// tts.setOnUtteranceProgressListener( new UtteranceProgressListener() {
|
||
// @Override public void onStart( String utteranceId ){
|
||
// warning.d( "UtteranceProgressListener.onStart id=%s", utteranceId );
|
||
// }
|
||
//
|
||
// @Override public void onDone( String utteranceId ){
|
||
// warning.d( "UtteranceProgressListener.onDone id=%s", utteranceId );
|
||
// handler.post( proc_flushSpeechQueue );
|
||
// }
|
||
//
|
||
// @Override public void onError( String utteranceId ){
|
||
// warning.d( "UtteranceProgressListener.onError id=%s", utteranceId );
|
||
// handler.post( proc_flushSpeechQueue );
|
||
// }
|
||
// } );
|
||
}
|
||
}
|
||
}
|
||
|
||
tmpTts = TextToSpeech(context, ttsInitListener)
|
||
}
|
||
return
|
||
}
|
||
|
||
if (!willSpeechEnabled && tts != null) {
|
||
context.showToast(false, R.string.text_to_speech_shutdown)
|
||
log.d("shutdown TextToSpeech…")
|
||
tts?.shutdown()
|
||
tts = null
|
||
ttsStatus = TTS_STATUS_NONE
|
||
}
|
||
}
|
||
|
||
internal fun addSpeech(status: TootStatus) {
|
||
|
||
if (tts == null) return
|
||
|
||
val text = getStatusText(status)
|
||
if (text == null || text.length == 0) return
|
||
|
||
val spanList = text.getSpans(0, text.length, MyClickableSpan::class.java)
|
||
if (spanList == null || spanList.isEmpty()) {
|
||
addSpeech(text.toString())
|
||
return
|
||
}
|
||
Arrays.sort(spanList) { a, b ->
|
||
val aStart = text.getSpanStart(a)
|
||
val bStart = text.getSpanStart(b)
|
||
aStart - bStart
|
||
}
|
||
val strText = text.toString()
|
||
val sb = StringBuilder()
|
||
var lastEnd = 0
|
||
var hasUrl = false
|
||
for (span in spanList) {
|
||
val start = text.getSpanStart(span)
|
||
val end = text.getSpanEnd(span)
|
||
//
|
||
if (start > lastEnd) {
|
||
sb.append(strText.substring(lastEnd, start))
|
||
}
|
||
lastEnd = end
|
||
//
|
||
val spanText = strText.substring(start, end)
|
||
if (spanText.isNotEmpty()) {
|
||
val c = spanText[0]
|
||
if (c == '#' || c == '@') {
|
||
// #hashtag や @user はそのまま読み上げる
|
||
sb.append(spanText)
|
||
} else {
|
||
// それ以外はURL省略
|
||
hasUrl = true
|
||
sb.append(" ")
|
||
}
|
||
}
|
||
}
|
||
val textEnd = strText.length
|
||
if (textEnd > lastEnd) {
|
||
sb.append(strText.substring(lastEnd, textEnd))
|
||
}
|
||
if (hasUrl) {
|
||
sb.append(context.getString(R.string.url_omitted))
|
||
}
|
||
addSpeech(sb.toString())
|
||
}
|
||
|
||
internal fun addSpeech(text: String, dedupMode: DedupMode = DedupMode.Recent) {
|
||
|
||
if (tts == null) return
|
||
|
||
val sv = reSpaces.matcher(text).replaceAll(" ").trim { it <= ' ' }
|
||
if (sv.isEmpty()) return
|
||
|
||
if (dedupMode != DedupMode.None) {
|
||
synchronized(this) {
|
||
val check = duplicationCheck.find { it.text.equals(sv, ignoreCase = true) }
|
||
if (check == null) {
|
||
duplicationCheck.addLast(DedupItem(sv))
|
||
if (duplicationCheck.size > 60) duplicationCheck.removeFirst()
|
||
} else {
|
||
val now = SystemClock.elapsedRealtime()
|
||
val delta = now - check.time
|
||
// 古い項目が残っていることがあるので、check.timeの更新は必須
|
||
check.time = now
|
||
|
||
if (dedupMode == DedupMode.Recent) return
|
||
if (dedupMode == DedupMode.RecentExpire && delta < 5000L) return
|
||
}
|
||
}
|
||
}
|
||
|
||
ttsQueue.add(sv)
|
||
if (ttsQueue.size > 30) ttsQueue.removeFirst()
|
||
|
||
handler.post(procFlushSpeechQueue)
|
||
}
|
||
|
||
private fun stopLastRingtone() {
|
||
lastRingtone?.get()?.let { r ->
|
||
try {
|
||
r.stop()
|
||
} catch (ex: Throwable) {
|
||
log.e(ex, "stopLastRingtone failed.")
|
||
} finally {
|
||
lastRingtone = null
|
||
}
|
||
}
|
||
}
|
||
|
||
internal fun sound(item: HighlightWord) {
|
||
// 短時間に何度もならないようにする
|
||
val now = SystemClock.elapsedRealtime()
|
||
if (now - lastSound < 500L) return
|
||
lastSound = now
|
||
|
||
stopLastRingtone()
|
||
|
||
if (item.sound_type == HighlightWord.SOUND_TYPE_NONE) return
|
||
|
||
fun Uri?.tryRingtone(): Boolean {
|
||
try {
|
||
if (this != null) {
|
||
RingtoneManager.getRingtone(context, this)?.let { ringTone ->
|
||
lastRingtone = WeakReference(ringTone)
|
||
ringTone.play()
|
||
return true
|
||
}
|
||
}
|
||
} catch (ex: Throwable) {
|
||
log.e(ex, "tryRingtone failed.")
|
||
}
|
||
return false
|
||
}
|
||
|
||
if (item.sound_type == HighlightWord.SOUND_TYPE_CUSTOM && item.sound_uri.mayUri()
|
||
.tryRingtone()
|
||
) return
|
||
|
||
RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION).tryRingtone()
|
||
}
|
||
|
||
fun onMuteUpdated() {
|
||
TootStatus.muted_app = daoMutedApp.nameSet()
|
||
TootStatus.muted_word = daoMutedWord.nameSet()
|
||
columnList.forEach { it.onMuteUpdated() }
|
||
}
|
||
}
|