603 lines
23 KiB
Kotlin
603 lines
23 KiB
Kotlin
package jp.juggler.subwaytooter.util
|
|
|
|
import android.os.SystemClock
|
|
import androidx.appcompat.app.AppCompatActivity
|
|
import jp.juggler.subwaytooter.R
|
|
import jp.juggler.subwaytooter.api.*
|
|
import jp.juggler.subwaytooter.api.entity.*
|
|
import jp.juggler.subwaytooter.dialog.DlgConfirm.confirm
|
|
import jp.juggler.subwaytooter.emoji.CustomEmoji
|
|
import jp.juggler.subwaytooter.getVisibilityString
|
|
import jp.juggler.subwaytooter.pref.PrefB
|
|
import jp.juggler.subwaytooter.span.MyClickableSpan
|
|
import jp.juggler.subwaytooter.table.AcctColor
|
|
import jp.juggler.subwaytooter.table.SavedAccount
|
|
import jp.juggler.subwaytooter.table.TagSet
|
|
import jp.juggler.util.*
|
|
import jp.juggler.util.coroutine.AppDispatchers
|
|
import jp.juggler.util.data.*
|
|
import jp.juggler.util.log.*
|
|
import jp.juggler.util.network.MEDIA_TYPE_JSON
|
|
import jp.juggler.util.network.toPostRequestBuilder
|
|
import jp.juggler.util.ui.*
|
|
import kotlinx.coroutines.CancellationException
|
|
import kotlinx.coroutines.delay
|
|
import kotlinx.coroutines.withContext
|
|
import okhttp3.Request
|
|
import okhttp3.RequestBody.Companion.toRequestBody
|
|
import java.util.*
|
|
import java.util.concurrent.atomic.AtomicBoolean
|
|
|
|
sealed class PostResult {
|
|
class Normal(
|
|
val targetAccount: SavedAccount,
|
|
val status: TootStatus,
|
|
) : PostResult()
|
|
|
|
class Scheduled(
|
|
val targetAccount: SavedAccount,
|
|
) : PostResult()
|
|
}
|
|
|
|
@Suppress("LongParameterList")
|
|
class PostImpl(
|
|
val activity: AppCompatActivity,
|
|
val account: SavedAccount,
|
|
val content: String,
|
|
|
|
// nullはCWチェックなしを示す // nullじゃなくてカラならエラー
|
|
val spoilerText: String?,
|
|
|
|
val visibilityArg: TootVisibility,
|
|
val bNSFW: Boolean,
|
|
val inReplyToId: EntityId?,
|
|
val attachmentListArg: List<PostAttachment>?,
|
|
enqueteItemsArg: List<String>?,
|
|
val pollType: TootPollsType?,
|
|
val pollExpireSeconds: Int,
|
|
val pollHideTotals: Boolean,
|
|
val pollMultipleChoice: Boolean,
|
|
val scheduledAt: Long,
|
|
val scheduledId: EntityId?,
|
|
val redraftStatusId: EntityId?,
|
|
val editStatusId: EntityId?,
|
|
val emojiMapCustom: HashMap<String, CustomEmoji>?,
|
|
var useQuoteToot: Boolean,
|
|
var lang: String,
|
|
) {
|
|
companion object {
|
|
private val log = LogCategory("PostImpl")
|
|
private val reAscii = """[\x00-\x7f]""".asciiPattern()
|
|
private val reNotAscii = """[^\x00-\x7f]""".asciiPattern()
|
|
|
|
private var lastPostTapped: Long = 0L
|
|
|
|
private val isPosting = AtomicBoolean(false)
|
|
}
|
|
|
|
private val attachmentList = attachmentListArg?.mapNotNull { it.attachment }?.notEmpty()
|
|
|
|
// null だと投票を作成しない。空リストはエラー
|
|
private val enqueteItems = enqueteItemsArg?.filter { it.isNotEmpty() }
|
|
|
|
private var visibilityChecked: TootVisibility? = null
|
|
|
|
private val choiceMaxChars = when {
|
|
account.isMisskey -> 15
|
|
pollType == TootPollsType.FriendsNico -> 15
|
|
else -> 40 // TootPollsType.Mastodon
|
|
}
|
|
|
|
private fun preCheckPollItemOne(list: List<String>, idx: Int, item: String) {
|
|
|
|
// 選択肢が長すぎる
|
|
val cpCount = item.codePointCount(0, item.length)
|
|
if (cpCount > choiceMaxChars) {
|
|
val over = cpCount - choiceMaxChars
|
|
activity.errorString(R.string.enquete_item_too_long, idx + 1, over)
|
|
}
|
|
|
|
// 他の項目と重複している
|
|
if ((0 until idx).any { list[it] == item }) {
|
|
activity.errorString(R.string.enquete_item_duplicate, idx + 1)
|
|
}
|
|
}
|
|
|
|
private var resultStatus: TootStatus? = null
|
|
private var resultCredentialTmp: TootAccount? = null
|
|
private var resultScheduledStatusSucceeded = false
|
|
|
|
private suspend fun getCredential(
|
|
client: TootApiClient,
|
|
parser: TootParser,
|
|
): TootApiResult? {
|
|
return client.request("/api/v1/accounts/verify_credentials")?.also { result ->
|
|
resultCredentialTmp = parser.account(result.jsonObject)
|
|
}
|
|
}
|
|
|
|
private suspend fun getWebVisibility(
|
|
client: TootApiClient,
|
|
parser: TootParser,
|
|
instance: TootInstance,
|
|
): TootVisibility? {
|
|
if (account.isMisskey || instance.versionGE(TootInstance.VERSION_1_6)) return null
|
|
|
|
val r2 = getCredential(client, parser)
|
|
|
|
val credentialTmp = resultCredentialTmp
|
|
?: errorApiResult(r2)
|
|
|
|
val privacy = credentialTmp.source?.privacy
|
|
?: errorApiResult(activity.getString(R.string.cant_get_web_setting_visibility))
|
|
|
|
return TootVisibility.parseMastodon(privacy)
|
|
// may null, not error
|
|
}
|
|
|
|
private fun checkServerHasVisibility(
|
|
actual: TootVisibility?,
|
|
extra: TootVisibility,
|
|
instance: TootInstance,
|
|
checkFun: (TootInstance) -> Boolean,
|
|
) {
|
|
if (actual != extra || checkFun(instance)) return
|
|
val strVisibility = getVisibilityString(activity, account.isMisskey, extra)
|
|
errorApiResult(
|
|
activity.getString(
|
|
R.string.server_has_no_support_of_visibility,
|
|
strVisibility
|
|
)
|
|
)
|
|
}
|
|
|
|
private suspend fun checkVisibility(
|
|
client: TootApiClient,
|
|
parser: TootParser,
|
|
instance: TootInstance,
|
|
): TootVisibility? {
|
|
val v = when (visibilityArg) {
|
|
TootVisibility.WebSetting -> getWebVisibility(client, parser, instance)
|
|
else -> visibilityArg
|
|
}
|
|
checkServerHasVisibility(
|
|
v,
|
|
TootVisibility.Mutual,
|
|
instance,
|
|
InstanceCapability::visibilityMutual
|
|
)
|
|
checkServerHasVisibility(
|
|
v,
|
|
TootVisibility.Limited,
|
|
instance,
|
|
InstanceCapability::visibilityLimited
|
|
)
|
|
return v
|
|
}
|
|
|
|
private suspend fun deleteStatus(client: TootApiClient) {
|
|
val result = if (account.isMisskey) {
|
|
client.request(
|
|
"/api/notes/delete",
|
|
account.putMisskeyApiToken(JsonObject()).apply {
|
|
put("noteId", redraftStatusId)
|
|
}.toPostRequestBuilder()
|
|
)
|
|
} else {
|
|
client.request(
|
|
"/api/v1/statuses/$redraftStatusId",
|
|
Request.Builder().delete()
|
|
)
|
|
}
|
|
log.d("delete redraft. result=$result")
|
|
delay(2000L)
|
|
}
|
|
|
|
private suspend fun deleteScheduledStatus(client: TootApiClient) {
|
|
val result = client.request(
|
|
"/api/v1/scheduled_statuses/$scheduledId",
|
|
Request.Builder().delete()
|
|
)
|
|
|
|
log.d("delete old scheduled status. result=$result")
|
|
delay(2000L)
|
|
}
|
|
|
|
private suspend fun encodeParamsMisskey(json: JsonObject, client: TootApiClient) {
|
|
account.putMisskeyApiToken(json)
|
|
|
|
json["viaMobile"] = true
|
|
|
|
json["text"] = EmojiDecoder.decodeShortCode(content, emojiMapCustom = emojiMapCustom)
|
|
|
|
spoilerText?.notEmpty()?.let {
|
|
json["cw"] = EmojiDecoder.decodeShortCode(it, emojiMapCustom = emojiMapCustom)
|
|
}
|
|
|
|
inReplyToId?.toString()?.let {
|
|
json[if (useQuoteToot) "renoteId" else "replyId"] = it
|
|
}
|
|
|
|
when (val visibility = visibilityChecked) {
|
|
null -> Unit
|
|
TootVisibility.DirectSpecified, TootVisibility.DirectPrivate -> {
|
|
val userIds = JsonArray()
|
|
val m = TootAccount.reMisskeyMentionPost.matcher(content)
|
|
while (m.find()) {
|
|
val username = m.groupEx(1)
|
|
val host = m.groupEx(2) // may null
|
|
|
|
client.request(
|
|
"/api/users/show",
|
|
account.putMisskeyApiToken().apply {
|
|
username.notEmpty()?.let { put("username", it) }
|
|
host.notEmpty()?.let { put("host", it) }
|
|
}.toPostRequestBuilder()
|
|
)?.let { result ->
|
|
result.jsonObject?.string("id").notEmpty()?.let { userIds.add(it) }
|
|
}
|
|
}
|
|
json["visibility"] = when {
|
|
userIds.isNotEmpty() -> {
|
|
json["visibleUserIds"] = userIds
|
|
"specified"
|
|
}
|
|
account.misskeyVersion >= 11 -> "specified"
|
|
else -> "private"
|
|
}
|
|
}
|
|
|
|
else -> {
|
|
val localVis = visibility.strMisskey.replace("^local-".toRegex(), "")
|
|
if (localVis != visibility.strMisskey) json["localOnly"] = true
|
|
json["visibility"] = localVis
|
|
}
|
|
}
|
|
|
|
if (attachmentList != null) {
|
|
val array = JsonArray()
|
|
for (a in attachmentList) {
|
|
|
|
// Misskeyは画像の再利用に問題がないので redraftとバージョンのチェックは行わない
|
|
array.add(a.id.toString())
|
|
|
|
// Misskeyの場合、NSFWするにはアップロード済みの画像を drive/files/update で更新する
|
|
if (bNSFW) {
|
|
val r = client.request(
|
|
"/api/drive/files/update",
|
|
account.putMisskeyApiToken().apply {
|
|
put("fileId", a.id.toString())
|
|
put("isSensitive", true)
|
|
}
|
|
.toPostRequestBuilder()
|
|
)
|
|
if (r == null || r.error != null) errorApiResult(r)
|
|
}
|
|
}
|
|
if (array.isNotEmpty()) json["mediaIds"] = array
|
|
}
|
|
|
|
if (enqueteItems?.isNotEmpty() == true) {
|
|
val choices = JsonArray().apply {
|
|
for (item in enqueteItems) {
|
|
val text = EmojiDecoder.decodeShortCode(item, emojiMapCustom = emojiMapCustom)
|
|
if (text.isEmpty()) continue
|
|
add(text)
|
|
}
|
|
}
|
|
if (choices.isNotEmpty()) {
|
|
json["poll"] = jsonObjectOf("choices" to choices)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun encodeParamsMastodon(json: JsonObject, instance: TootInstance) {
|
|
|
|
when (val lang = lang.trim()) {
|
|
// Web設定に従うなら指定しない
|
|
SavedAccount.LANG_WEB, "" -> Unit
|
|
// 端末の言語コード
|
|
SavedAccount.LANG_DEVICE ->
|
|
json["language"] = Locale.getDefault().language
|
|
// その他
|
|
else ->
|
|
json["language"] = lang
|
|
}
|
|
|
|
visibilityChecked?.let { json["visibility"] = it.strMastodon }
|
|
|
|
json["status"] = EmojiDecoder.decodeShortCode(content, emojiMapCustom = emojiMapCustom)
|
|
json["sensitive"] = bNSFW
|
|
json["spoiler_text"] =
|
|
EmojiDecoder.decodeShortCode(spoilerText ?: "", emojiMapCustom = emojiMapCustom)
|
|
|
|
inReplyToId?.toString()
|
|
?.let { json[if (useQuoteToot) "quote_id" else "in_reply_to_id"] = it }
|
|
|
|
if (attachmentList != null) {
|
|
json["media_ids"] = buildJsonArray {
|
|
for (a in attachmentList) {
|
|
if (a.redraft && !instance.versionGE(TootInstance.VERSION_2_4_1)) continue
|
|
add(a.id.toString())
|
|
}
|
|
}
|
|
}
|
|
|
|
if (enqueteItems != null) {
|
|
if (pollType == TootPollsType.Mastodon) {
|
|
json["poll"] = buildJsonObject {
|
|
put("multiple", pollMultipleChoice)
|
|
put("hide_totals", pollHideTotals)
|
|
put("expires_in", pollExpireSeconds)
|
|
put("options", enqueteItems.map {
|
|
EmojiDecoder.decodeShortCode(it, emojiMapCustom = emojiMapCustom)
|
|
}.toJsonArray())
|
|
}
|
|
} else {
|
|
json["isEnquete"] = true
|
|
json["enquete_items"] = enqueteItems.map {
|
|
EmojiDecoder.decodeShortCode(it, emojiMapCustom = emojiMapCustom)
|
|
}.toJsonArray()
|
|
}
|
|
}
|
|
|
|
if (scheduledAt != 0L) {
|
|
if (!instance.versionGE(TootInstance.VERSION_2_7_0_rc1)) {
|
|
errorApiResult(activity.getString(R.string.scheduled_status_requires_mastodon_2_7_0))
|
|
}
|
|
// UTCの日時を渡す
|
|
val c = GregorianCalendar.getInstance(TimeZone.getTimeZone("UTC"))
|
|
c.timeInMillis = scheduledAt
|
|
val sv = String.format(
|
|
Locale.JAPANESE,
|
|
"%d-%02d-%02dT%02d:%02d:%02d.%03dZ",
|
|
c.get(Calendar.YEAR),
|
|
c.get(Calendar.MONTH) + 1,
|
|
c.get(Calendar.DAY_OF_MONTH),
|
|
c.get(Calendar.HOUR_OF_DAY),
|
|
c.get(Calendar.MINUTE),
|
|
c.get(Calendar.SECOND),
|
|
c.get(Calendar.MILLISECOND)
|
|
)
|
|
json["scheduled_at"] = sv
|
|
}
|
|
}
|
|
|
|
private fun saveStatusTag(status: TootStatus?) {
|
|
status ?: return
|
|
|
|
val s = status.decoded_content
|
|
val spanList = s.getSpans(0, s.length, MyClickableSpan::class.java)
|
|
if (spanList != null) {
|
|
val tagList = ArrayList<String?>(spanList.size)
|
|
for (span in spanList) {
|
|
val start = s.getSpanStart(span)
|
|
val end = s.getSpanEnd(span)
|
|
val text = s.subSequence(start, end).toString()
|
|
if (text.startsWith("#")) {
|
|
tagList.add(text.substring(1))
|
|
}
|
|
}
|
|
val count = tagList.size
|
|
if (count > 0) {
|
|
TagSet.saveList(System.currentTimeMillis(), tagList, 0, count)
|
|
}
|
|
}
|
|
}
|
|
|
|
suspend fun runSuspend(): PostResult {
|
|
|
|
if (account.isMisskey) {
|
|
attachmentList
|
|
?.notEmpty()
|
|
?.map { it.id.toString() }
|
|
?.takeIf { it != it.distinct() }
|
|
?.let {
|
|
activity.errorString(R.string.post_error_attachments_duplicated)
|
|
}
|
|
}
|
|
|
|
if (content.isEmpty() && attachmentList == null) {
|
|
activity.errorString(R.string.post_error_contents_empty)
|
|
}
|
|
|
|
// nullはCWチェックなしを示す // nullじゃなくてカラならエラー
|
|
if (spoilerText != null && spoilerText.isEmpty()) {
|
|
activity.errorString(R.string.post_error_contents_warning_empty)
|
|
}
|
|
|
|
if (!enqueteItems.isNullOrEmpty()) {
|
|
if (enqueteItems.size < 2) {
|
|
activity.errorString(R.string.enquete_item_is_empty, enqueteItems.size + 1)
|
|
}
|
|
enqueteItems.forEachIndexed { i, v ->
|
|
preCheckPollItemOne(enqueteItems, i, v)
|
|
}
|
|
}
|
|
|
|
if (scheduledAt != 0L && account.isMisskey) {
|
|
error("misskey has no scheduled status API")
|
|
}
|
|
|
|
if (PrefB.bpWarnHashtagAsciiAndNonAscii()) {
|
|
TootTag.findHashtags(content, account.isMisskey)
|
|
?.filter {
|
|
val hasAscii = reAscii.matcher(it).find()
|
|
val hasNotAscii = reNotAscii.matcher(it).find()
|
|
hasAscii && hasNotAscii
|
|
}?.map { "#$it" }
|
|
?.notEmpty()
|
|
?.let { badTags ->
|
|
activity.confirm(
|
|
R.string.hashtag_contains_ascii_and_not_ascii,
|
|
badTags.joinToString(", ")
|
|
)
|
|
}
|
|
}
|
|
|
|
val isMisskey = account.isMisskey
|
|
if (!visibilityArg.isTagAllowed(isMisskey)) {
|
|
TootTag.findHashtags(content, isMisskey)
|
|
?.notEmpty()
|
|
?.let { tags ->
|
|
log.d("findHashtags ${tags.joinToString(",")}")
|
|
activity.confirm(
|
|
R.string.hashtag_and_visibility_not_match
|
|
)
|
|
}
|
|
}
|
|
|
|
if (redraftStatusId != null) {
|
|
activity.confirm(R.string.delete_base_status_before_toot)
|
|
}
|
|
|
|
if (scheduledId != null) {
|
|
activity.confirm(R.string.delete_scheduled_status_before_update)
|
|
}
|
|
|
|
activity.confirm(
|
|
activity.getString(R.string.confirm_post_from, AcctColor.getNickname(account)),
|
|
account.confirm_post
|
|
) { newConfirmEnabled ->
|
|
account.confirm_post = newConfirmEnabled
|
|
account.saveSetting()
|
|
}
|
|
|
|
// ボタン連打判定
|
|
val now = SystemClock.elapsedRealtime()
|
|
val delta = now - lastPostTapped
|
|
lastPostTapped = now
|
|
if (delta < 1000L) {
|
|
log.e("lastPostTapped within 1 sec!")
|
|
activity.showToast(false, R.string.post_button_tapped_repeatly)
|
|
throw CancellationException("post_button_tapped_repeatly")
|
|
}
|
|
|
|
// 投稿中に再度投稿ボタンが押された
|
|
if (isPosting.get()) {
|
|
log.e("other postJob is active!")
|
|
activity.showToast(false, R.string.post_button_tapped_repeatly)
|
|
throw CancellationException("preCheck failed.")
|
|
}
|
|
// 全ての確認を終えたらバックグラウンドでの処理を開始する
|
|
isPosting.set(true)
|
|
return try {
|
|
withContext(AppDispatchers.mainImmediate) {
|
|
activity.runApiTask(
|
|
account,
|
|
progressSetup = { it.setCanceledOnTouchOutside(false) },
|
|
) { client ->
|
|
val (instance, ri) = TootInstance.get(client)
|
|
instance ?: return@runApiTask ri
|
|
|
|
if (instance.instanceType == InstanceType.Pixelfed) {
|
|
// Pixelfedは返信に画像を添付できない
|
|
if (inReplyToId != null && attachmentList != null) {
|
|
return@runApiTask TootApiResult(getString(R.string.pixelfed_does_not_allow_reply_with_media))
|
|
}
|
|
|
|
// Pixelfedの返信ではない投稿は画像添付が必須
|
|
if (inReplyToId == null && attachmentList == null) {
|
|
return@runApiTask TootApiResult(getString(R.string.pixelfed_does_not_allow_post_without_media))
|
|
}
|
|
}
|
|
|
|
val parser = TootParser(this, account)
|
|
|
|
this@PostImpl.visibilityChecked = try {
|
|
checkVisibility(client, parser, instance) // may null
|
|
} catch (ex: TootApiResultException) {
|
|
return@runApiTask ex.result
|
|
}
|
|
|
|
if (redraftStatusId != null) {
|
|
// 元の投稿を削除する
|
|
deleteStatus(client)
|
|
} else if (scheduledId != null) {
|
|
deleteScheduledStatus(client)
|
|
}
|
|
|
|
val json = JsonObject()
|
|
try {
|
|
if (account.isMisskey) {
|
|
encodeParamsMisskey(json, client)
|
|
} else {
|
|
encodeParamsMastodon(json, instance)
|
|
}
|
|
} catch (ex: TootApiResultException) {
|
|
return@runApiTask ex.result
|
|
} catch (ex: JsonException) {
|
|
log.e(ex, "status encoding failed.")
|
|
}
|
|
|
|
val bodyString = json.toString()
|
|
|
|
fun createRequestBuilder(isPut: Boolean = false): Request.Builder {
|
|
val requestBody = bodyString.toRequestBody(MEDIA_TYPE_JSON)
|
|
return when {
|
|
isPut -> Request.Builder().put(requestBody)
|
|
else -> Request.Builder().post(requestBody)
|
|
}.also {
|
|
if (!PrefB.bpDontDuplicationCheck()) {
|
|
val digest = (bodyString + account.acct.ascii).digestSHA256Hex()
|
|
it.header("Idempotency-Key", digest)
|
|
}
|
|
}
|
|
}
|
|
|
|
when {
|
|
account.isMisskey -> client.request(
|
|
"/api/notes/create",
|
|
createRequestBuilder()
|
|
)
|
|
|
|
editStatusId != null -> client.request(
|
|
"/api/v1/statuses/$editStatusId",
|
|
createRequestBuilder(isPut = true)
|
|
)
|
|
|
|
else -> client.request(
|
|
"/api/v1/statuses",
|
|
createRequestBuilder()
|
|
)
|
|
}?.also { result ->
|
|
val jsonObject = result.jsonObject
|
|
|
|
if (scheduledAt != 0L && jsonObject != null) {
|
|
// {"id":"3","scheduled_at":"2019-01-06T07:08:00.000Z","media_attachments":[]}
|
|
resultScheduledStatusSucceeded = true
|
|
return@runApiTask result
|
|
} else {
|
|
val status = parser.status(
|
|
when {
|
|
account.isMisskey -> jsonObject?.jsonObject("createdNote")
|
|
?: jsonObject
|
|
else -> jsonObject
|
|
}
|
|
)
|
|
resultStatus = status
|
|
saveStatusTag(status)
|
|
}
|
|
}
|
|
}.let { result ->
|
|
if (result == null) throw CancellationException()
|
|
|
|
val status = resultStatus
|
|
when {
|
|
resultScheduledStatusSucceeded ->
|
|
PostResult.Scheduled(account)
|
|
|
|
// 連投してIdempotency が同じだった場合もエラーにはならず、ここを通る
|
|
status != null ->
|
|
PostResult.Normal(account, status)
|
|
|
|
else -> error(result.error ?: "(result.error is null)")
|
|
}
|
|
}
|
|
}
|
|
} finally {
|
|
isPosting.set(false)
|
|
}
|
|
}
|
|
}
|