2018-01-04 19:52:25 +01:00
|
|
|
package jp.juggler.subwaytooter.util
|
|
|
|
|
|
|
|
import android.content.SharedPreferences
|
|
|
|
import android.os.Handler
|
2018-06-28 11:15:31 +02:00
|
|
|
import android.os.SystemClock
|
2018-01-04 19:52:25 +01:00
|
|
|
import android.support.v7.app.AlertDialog
|
|
|
|
import android.support.v7.app.AppCompatActivity
|
2018-01-16 07:48:17 +01:00
|
|
|
import android.text.*
|
2018-11-06 02:29:33 +01:00
|
|
|
import android.text.style.ForegroundColorSpan
|
2018-01-04 19:52:25 +01:00
|
|
|
import android.view.View
|
2018-01-16 07:48:17 +01:00
|
|
|
import jp.juggler.emoji.EmojiMap201709
|
2018-01-04 19:52:25 +01:00
|
|
|
|
|
|
|
import org.json.JSONArray
|
|
|
|
import org.json.JSONException
|
|
|
|
import org.json.JSONObject
|
|
|
|
|
|
|
|
import java.util.ArrayList
|
|
|
|
import java.util.regex.Pattern
|
|
|
|
|
|
|
|
import jp.juggler.subwaytooter.App1
|
|
|
|
import jp.juggler.subwaytooter.Pref
|
|
|
|
import jp.juggler.subwaytooter.R
|
2018-11-06 02:29:33 +01:00
|
|
|
import jp.juggler.subwaytooter.Styler
|
2018-01-04 19:52:25 +01:00
|
|
|
import jp.juggler.subwaytooter.api.TootApiClient
|
|
|
|
import jp.juggler.subwaytooter.api.TootApiResult
|
|
|
|
import jp.juggler.subwaytooter.api.TootTask
|
|
|
|
import jp.juggler.subwaytooter.api.TootTaskRunner
|
|
|
|
import jp.juggler.subwaytooter.api.TootParser
|
2018-01-10 16:47:35 +01:00
|
|
|
import jp.juggler.subwaytooter.api.entity.*
|
2018-01-04 19:52:25 +01:00
|
|
|
import jp.juggler.subwaytooter.dialog.DlgConfirm
|
|
|
|
import jp.juggler.subwaytooter.dialog.EmojiPicker
|
|
|
|
import jp.juggler.subwaytooter.span.MyClickableSpan
|
|
|
|
import jp.juggler.subwaytooter.span.NetworkEmojiSpan
|
|
|
|
import jp.juggler.subwaytooter.table.AcctColor
|
|
|
|
import jp.juggler.subwaytooter.table.AcctSet
|
|
|
|
import jp.juggler.subwaytooter.table.SavedAccount
|
|
|
|
import jp.juggler.subwaytooter.table.TagSet
|
|
|
|
import jp.juggler.subwaytooter.view.MyEditText
|
|
|
|
import okhttp3.Request
|
|
|
|
import okhttp3.RequestBody
|
2018-06-28 11:43:46 +02:00
|
|
|
import java.lang.ref.WeakReference
|
2018-03-10 17:22:13 +01:00
|
|
|
import java.util.HashMap
|
2018-01-04 19:52:25 +01:00
|
|
|
|
|
|
|
class PostHelper(
|
|
|
|
private val activity : AppCompatActivity,
|
|
|
|
private val pref : SharedPreferences,
|
|
|
|
private val handler : Handler
|
2018-01-16 07:48:17 +01:00
|
|
|
) {
|
2018-01-04 19:52:25 +01:00
|
|
|
|
|
|
|
companion object {
|
|
|
|
private val log = LogCategory("PostHelper")
|
|
|
|
|
|
|
|
// [:word:] 単語構成文字 (Letter | Mark | Decimal_Number | Connector_Punctuation)
|
|
|
|
// [:alpha:] 英字 (Letter | Mark)
|
|
|
|
|
|
|
|
private const val word = "[_\\p{L}\\p{M}\\p{Nd}\\p{Pc}]"
|
|
|
|
private const val alpha = "[_\\p{L}\\p{M}]"
|
|
|
|
|
|
|
|
private val reTag = Pattern.compile(
|
|
|
|
"(?:^|[^/)\\w])#($word*$alpha$word*)", Pattern.CASE_INSENSITIVE
|
|
|
|
)
|
|
|
|
|
|
|
|
private val reCharsNotTag = Pattern.compile("[・\\s\\-+.,:;/]")
|
|
|
|
private val reCharsNotEmoji = Pattern.compile("[^0-9A-Za-z_-]")
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// 投稿機能
|
|
|
|
|
|
|
|
var content : String? = null
|
|
|
|
var spoiler_text : String? = null
|
2018-08-20 19:37:42 +02:00
|
|
|
var visibility : TootVisibility = TootVisibility.Public
|
2018-01-04 19:52:25 +01:00
|
|
|
var bNSFW : Boolean = false
|
2018-08-18 12:58:14 +02:00
|
|
|
var in_reply_to_id : EntityId? = null
|
2018-01-04 19:52:25 +01:00
|
|
|
var attachment_list : ArrayList<PostAttachment>? = null
|
|
|
|
var enquete_items : ArrayList<String>? = null
|
2018-06-23 04:43:18 +02:00
|
|
|
var emojiMapCustom : HashMap<String, CustomEmoji>? = null
|
2018-08-18 12:58:14 +02:00
|
|
|
var redraft_status_id : EntityId? = null
|
2018-11-12 18:19:57 +01:00
|
|
|
var useQuotedRenote : Boolean = false
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-06-28 11:15:31 +02:00
|
|
|
private var last_post_tapped : Long = 0L
|
|
|
|
|
2018-06-28 11:43:46 +02:00
|
|
|
private var last_post_task : WeakReference<TootTaskRunner>? = null
|
2018-06-28 11:15:31 +02:00
|
|
|
|
2018-01-21 17:47:13 +01:00
|
|
|
fun post(
|
|
|
|
account : SavedAccount,
|
2018-06-23 04:43:18 +02:00
|
|
|
bConfirmTag : Boolean = false,
|
|
|
|
bConfirmAccount : Boolean = false,
|
|
|
|
bConfirmRedraft : Boolean = false,
|
2018-01-21 17:47:13 +01:00
|
|
|
callback : PostCompleteCallback
|
|
|
|
) {
|
2018-01-16 07:48:17 +01:00
|
|
|
val content = this.content ?: ""
|
2018-01-04 19:52:25 +01:00
|
|
|
val spoiler_text = this.spoiler_text
|
|
|
|
val bNSFW = this.bNSFW
|
|
|
|
val in_reply_to_id = this.in_reply_to_id
|
|
|
|
val attachment_list = this.attachment_list
|
|
|
|
val enquete_items = this.enquete_items
|
2018-08-20 19:37:42 +02:00
|
|
|
val visibility = this.visibility
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-03-09 20:54:03 +01:00
|
|
|
val hasAttachment = attachment_list?.isNotEmpty() ?: false
|
|
|
|
|
2018-06-23 04:43:18 +02:00
|
|
|
if(! hasAttachment && content.isEmpty()) {
|
2018-01-21 13:46:36 +01:00
|
|
|
showToast(activity, true, R.string.post_error_contents_empty)
|
2018-01-04 19:52:25 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-01-10 16:47:35 +01:00
|
|
|
// nullはCWチェックなしを示す
|
|
|
|
// nullじゃなくてカラならエラー
|
2018-01-16 07:48:17 +01:00
|
|
|
if(spoiler_text != null && spoiler_text.isEmpty()) {
|
2018-01-21 13:46:36 +01:00
|
|
|
showToast(activity, true, R.string.post_error_contents_warning_empty)
|
2018-01-04 19:52:25 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if(enquete_items?.isNotEmpty() == true) {
|
|
|
|
var n = 0
|
|
|
|
val ne = enquete_items.size
|
|
|
|
while(n < ne) {
|
|
|
|
val item = enquete_items[n]
|
|
|
|
if(item.isEmpty()) {
|
|
|
|
if(n < 2) {
|
2018-01-21 13:46:36 +01:00
|
|
|
showToast(activity, true, R.string.enquete_item_is_empty, n + 1)
|
2018-01-04 19:52:25 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
val code_count = item.codePointCount(0, item.length)
|
|
|
|
if(code_count > 15) {
|
|
|
|
val over = code_count - 15
|
2018-01-21 13:46:36 +01:00
|
|
|
showToast(activity, true, R.string.enquete_item_too_long, n + 1, over)
|
2018-01-04 19:52:25 +01:00
|
|
|
return
|
|
|
|
} else if(n > 0) {
|
|
|
|
for(i in 0 until n) {
|
|
|
|
if(item == enquete_items[i]) {
|
2018-01-21 13:46:36 +01:00
|
|
|
showToast(activity, true, R.string.enquete_item_duplicate, n + 1)
|
2018-01-04 19:52:25 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
++ n
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(! bConfirmAccount) {
|
2018-01-21 17:47:13 +01:00
|
|
|
DlgConfirm.open(
|
|
|
|
activity,
|
|
|
|
activity.getString(R.string.confirm_post_from, AcctColor.getNickname(account.acct)),
|
|
|
|
object : DlgConfirm.Callback {
|
|
|
|
override var isConfirmEnabled : Boolean
|
|
|
|
get() = account.confirm_post
|
|
|
|
set(bv) {
|
|
|
|
account.confirm_post = bv
|
|
|
|
account.saveSetting()
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun onOK() {
|
2018-06-23 04:43:18 +02:00
|
|
|
post(account, bConfirmTag, true, bConfirmRedraft, callback)
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
2018-01-21 17:47:13 +01:00
|
|
|
})
|
2018-01-04 19:52:25 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if(! bConfirmTag) {
|
2018-08-20 19:37:42 +02:00
|
|
|
|
2018-11-06 02:29:33 +01:00
|
|
|
if(! account.isMisskey
|
2018-08-20 19:37:42 +02:00
|
|
|
&& visibility != TootVisibility.Public
|
|
|
|
&& reTag.matcher(content).find()
|
|
|
|
) {
|
2018-01-04 19:52:25 +01:00
|
|
|
AlertDialog.Builder(activity)
|
|
|
|
.setCancelable(true)
|
|
|
|
.setMessage(R.string.hashtag_and_visibility_not_match)
|
|
|
|
.setNegativeButton(R.string.cancel, null)
|
2018-01-21 17:47:13 +01:00
|
|
|
.setPositiveButton(R.string.ok) { _, _ ->
|
|
|
|
post(
|
|
|
|
account,
|
|
|
|
true,
|
|
|
|
bConfirmAccount,
|
2018-06-23 04:43:18 +02:00
|
|
|
bConfirmRedraft,
|
2018-01-21 17:47:13 +01:00
|
|
|
callback
|
|
|
|
)
|
|
|
|
}
|
2018-01-04 19:52:25 +01:00
|
|
|
.show()
|
|
|
|
return
|
|
|
|
}
|
2018-08-20 19:37:42 +02:00
|
|
|
// MisskeyのWebUIはタグ種別による警告とかはないみたいだ
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
|
2018-08-20 02:07:55 +02:00
|
|
|
if(! bConfirmRedraft && redraft_status_id != null) {
|
2018-06-23 04:43:18 +02:00
|
|
|
AlertDialog.Builder(activity)
|
|
|
|
.setCancelable(true)
|
|
|
|
.setMessage(R.string.delete_base_status_before_toot)
|
|
|
|
.setNegativeButton(R.string.cancel, null)
|
|
|
|
.setPositiveButton(R.string.ok) { _, _ ->
|
|
|
|
post(
|
|
|
|
account,
|
|
|
|
bConfirmTag,
|
|
|
|
bConfirmAccount,
|
|
|
|
true,
|
|
|
|
callback
|
|
|
|
)
|
|
|
|
}
|
|
|
|
.show()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-06-28 11:15:31 +02:00
|
|
|
// 確認を終えたらボタン連打判定
|
2018-08-15 04:06:25 +02:00
|
|
|
|
2018-06-28 11:43:46 +02:00
|
|
|
if(last_post_task?.get()?.isActive == true) {
|
|
|
|
showToast(activity, false, R.string.post_button_tapped_repeatly)
|
|
|
|
return
|
|
|
|
}
|
2018-08-15 04:06:25 +02:00
|
|
|
|
2018-06-28 11:15:31 +02:00
|
|
|
val now = SystemClock.elapsedRealtime()
|
|
|
|
val delta = now - last_post_tapped
|
|
|
|
last_post_tapped = now
|
|
|
|
if(delta < 1000L) {
|
|
|
|
showToast(activity, false, R.string.post_button_tapped_repeatly)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// 全ての確認を終えたらバックグラウンドでの処理を開始する
|
2018-06-28 11:43:46 +02:00
|
|
|
last_post_task = WeakReference(TootTaskRunner(activity
|
2018-06-28 11:15:31 +02:00
|
|
|
, progressSetupCallback = { progressDialog ->
|
|
|
|
progressDialog.setCanceledOnTouchOutside(false)
|
|
|
|
}
|
|
|
|
).run(account, object : TootTask {
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-06-28 11:15:31 +02:00
|
|
|
var status : TootStatus? = null
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-06-28 11:15:31 +02:00
|
|
|
var instance_tmp : TootInstance? = null
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-06-28 11:15:31 +02:00
|
|
|
var credential_tmp : TootAccount? = null
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-11-06 02:29:33 +01:00
|
|
|
val parser = TootParser(activity, account)
|
2018-08-20 02:07:55 +02:00
|
|
|
|
2018-06-28 11:15:31 +02:00
|
|
|
fun getInstanceInformation(client : TootApiClient) : TootApiResult? {
|
2018-11-06 02:29:33 +01:00
|
|
|
val result = if(account.isMisskey) {
|
|
|
|
val params = JSONObject().apply {
|
|
|
|
put("dummy", 1)
|
2018-08-20 02:07:55 +02:00
|
|
|
}
|
2018-11-06 02:29:33 +01:00
|
|
|
client.request("/api/meta", params.toPostRequestBuilder())
|
|
|
|
} else {
|
2018-08-20 02:07:55 +02:00
|
|
|
client.request("/api/v1/instance")
|
|
|
|
}
|
2018-11-06 02:29:33 +01:00
|
|
|
instance_tmp = parseItem(::TootInstance, parser, result?.jsonObject)
|
2018-01-04 19:52:25 +01:00
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
2018-06-28 11:15:31 +02:00
|
|
|
fun getCredential(client : TootApiClient) : TootApiResult? {
|
2018-01-04 19:52:25 +01:00
|
|
|
val result = client.request("/api/v1/accounts/verify_credentials")
|
2018-08-20 02:07:55 +02:00
|
|
|
credential_tmp = parser.account(result?.jsonObject)
|
2018-01-04 19:52:25 +01:00
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun background(client : TootApiClient) : TootApiResult? {
|
|
|
|
|
2018-06-23 04:43:18 +02:00
|
|
|
var result : TootApiResult?
|
2018-06-28 11:15:31 +02:00
|
|
|
|
2018-06-23 04:43:18 +02:00
|
|
|
// 元の投稿を削除する
|
2018-08-20 02:07:55 +02:00
|
|
|
if(redraft_status_id != null) {
|
2018-11-06 02:29:33 +01:00
|
|
|
result = if(isMisskey) {
|
|
|
|
val params = account.putMisskeyApiToken(JSONObject()).apply {
|
|
|
|
put("noteId", redraft_status_id)
|
2018-08-20 02:07:55 +02:00
|
|
|
}
|
|
|
|
client.request(
|
|
|
|
"/api/notes/delete",
|
|
|
|
params.toPostRequestBuilder()
|
|
|
|
)
|
2018-11-06 02:29:33 +01:00
|
|
|
} else {
|
2018-08-20 02:07:55 +02:00
|
|
|
client.request(
|
|
|
|
"/api/v1/statuses/$redraft_status_id",
|
|
|
|
Request.Builder().delete()
|
|
|
|
)
|
|
|
|
|
|
|
|
}
|
2018-06-23 04:43:18 +02:00
|
|
|
log.d("delete redraft. result=$result")
|
|
|
|
Thread.sleep(2000L)
|
|
|
|
}
|
|
|
|
|
2018-08-20 19:37:42 +02:00
|
|
|
var visibility_checked : TootVisibility? = visibility
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-06-23 04:43:18 +02:00
|
|
|
var instance = account.instance
|
|
|
|
if(instance == null) {
|
|
|
|
val r2 = getInstanceInformation(client)
|
|
|
|
instance = instance_tmp ?: return r2
|
|
|
|
account.instance = instance
|
|
|
|
}
|
2018-06-28 11:15:31 +02:00
|
|
|
|
2018-11-06 02:29:33 +01:00
|
|
|
if(visibility == TootVisibility.WebSetting) {
|
|
|
|
visibility_checked =
|
|
|
|
if(account.isMisskey || instance.versionGE(TootInstance.VERSION_1_6)) {
|
|
|
|
null
|
|
|
|
} else {
|
|
|
|
val r2 = getCredential(client)
|
|
|
|
val credential_tmp = this.credential_tmp ?: return r2
|
|
|
|
val privacy = credential_tmp.source?.privacy
|
|
|
|
?: return TootApiResult(activity.getString(R.string.cant_get_web_setting_visibility))
|
|
|
|
TootVisibility.parseMastodon(privacy)
|
|
|
|
}
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
|
2018-06-23 04:43:18 +02:00
|
|
|
val json = JSONObject()
|
|
|
|
try {
|
2018-08-20 02:07:55 +02:00
|
|
|
if(account.isMisskey) {
|
|
|
|
account.putMisskeyApiToken(json)
|
|
|
|
json.put(
|
|
|
|
"text",
|
|
|
|
EmojiDecoder.decodeShortCode(
|
|
|
|
content,
|
|
|
|
emojiMapCustom = emojiMapCustom
|
|
|
|
)
|
2018-06-23 04:43:18 +02:00
|
|
|
)
|
2018-08-20 02:07:55 +02:00
|
|
|
if(visibility_checked != null) {
|
2018-08-20 19:37:42 +02:00
|
|
|
|
2018-11-06 02:29:33 +01:00
|
|
|
if(visibility_checked == TootVisibility.DirectSpecified) {
|
2018-08-20 19:37:42 +02:00
|
|
|
val userIds = JSONArray()
|
2018-11-06 02:29:33 +01:00
|
|
|
val reMention =
|
|
|
|
Pattern.compile("(?:\\A|\\s)@([a-zA-Z0-9_]{1,20})(?:@([\\w.:-]+))?(?:\\z|\\s)")
|
2018-08-20 19:37:42 +02:00
|
|
|
val m = reMention.matcher(content)
|
2018-11-06 02:29:33 +01:00
|
|
|
while(m.find()) {
|
2018-08-20 19:37:42 +02:00
|
|
|
val username = m.group(1)
|
|
|
|
val host = m.group(2)
|
|
|
|
val queryParams = account.putMisskeyApiToken(JSONObject())
|
2018-11-06 02:29:33 +01:00
|
|
|
if(username?.isNotEmpty() == true) queryParams.put(
|
|
|
|
"username",
|
|
|
|
username
|
|
|
|
)
|
|
|
|
if(host?.isNotEmpty() == true) queryParams.put("host", host)
|
|
|
|
result = client.request(
|
|
|
|
"/api/users/show",
|
|
|
|
queryParams.toPostRequestBuilder()
|
|
|
|
)
|
2018-08-20 19:37:42 +02:00
|
|
|
val id = result?.jsonObject?.parseString("id")
|
2018-11-06 02:29:33 +01:00
|
|
|
if(id?.isNotEmpty() == true) {
|
|
|
|
userIds.put(id)
|
2018-08-20 02:07:55 +02:00
|
|
|
}
|
|
|
|
}
|
2018-11-06 02:29:33 +01:00
|
|
|
json.put(
|
|
|
|
"visibility", if(userIds.length() == 0) {
|
|
|
|
"private"
|
|
|
|
} else {
|
|
|
|
json.put("visibleUserIds", userIds)
|
|
|
|
"specified"
|
|
|
|
}
|
|
|
|
)
|
|
|
|
} else {
|
2018-11-16 00:43:10 +01:00
|
|
|
val localVis = visibility_checked.strMisskey.replace("^local-".toRegex(),"")
|
|
|
|
if( localVis != visibility_checked.strMisskey){
|
|
|
|
json.put("localOnly", true)
|
|
|
|
json.put("visibility", localVis)
|
|
|
|
}else {
|
|
|
|
json.put("visibility", visibility_checked.strMisskey)
|
|
|
|
}
|
2018-08-20 19:37:42 +02:00
|
|
|
}
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
2018-08-20 02:07:55 +02:00
|
|
|
|
2018-11-06 02:29:33 +01:00
|
|
|
if(spoiler_text?.isNotEmpty() == true) {
|
2018-08-20 02:07:55 +02:00
|
|
|
json.put(
|
|
|
|
"cw",
|
2018-06-23 04:43:18 +02:00
|
|
|
EmojiDecoder.decodeShortCode(
|
2018-08-20 02:07:55 +02:00
|
|
|
spoiler_text,
|
2018-06-23 04:43:18 +02:00
|
|
|
emojiMapCustom = emojiMapCustom
|
|
|
|
)
|
|
|
|
)
|
|
|
|
}
|
2018-08-20 02:07:55 +02:00
|
|
|
|
|
|
|
if(in_reply_to_id != null) {
|
2018-11-12 18:19:57 +01:00
|
|
|
if( useQuotedRenote){
|
|
|
|
json.put("renoteId", in_reply_to_id.toString())
|
|
|
|
}else{
|
|
|
|
json.put("replyId", in_reply_to_id.toString())
|
|
|
|
}
|
2018-08-20 02:07:55 +02:00
|
|
|
}
|
|
|
|
|
2018-11-06 02:29:33 +01:00
|
|
|
json.put("viaMobile", true)
|
2018-08-20 02:07:55 +02:00
|
|
|
|
|
|
|
if(attachment_list != null) {
|
|
|
|
val array = JSONArray()
|
|
|
|
for(pa in attachment_list) {
|
|
|
|
val a = pa.attachment ?: continue
|
|
|
|
// Misskeyは画像の再利用に問題がないので redraftとバージョンのチェックは行わない
|
|
|
|
array.put(a.id.toString())
|
2018-08-21 02:26:49 +02:00
|
|
|
|
|
|
|
// Misskeyの場合、NSFWするにはアップロード済みの画像を drive/files/update で更新する
|
2018-11-06 02:29:33 +01:00
|
|
|
if(bNSFW) {
|
2018-08-21 02:26:49 +02:00
|
|
|
val params = account.putMisskeyApiToken(JSONObject())
|
2018-11-06 02:29:33 +01:00
|
|
|
.put("fileId", a.id.toString())
|
|
|
|
.put("isSensitive", true)
|
|
|
|
val r = client.request(
|
|
|
|
"/api/drive/files/update",
|
|
|
|
params.toPostRequestBuilder()
|
|
|
|
)
|
|
|
|
if(r == null || r.error != null) return r
|
2018-08-21 02:26:49 +02:00
|
|
|
}
|
2018-08-20 02:07:55 +02:00
|
|
|
}
|
2018-11-06 02:29:33 +01:00
|
|
|
if(array.length() > 0) json.put("mediaIds", array)
|
2018-08-20 02:07:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if(enquete_items?.isNotEmpty() == true) {
|
|
|
|
val choices = JSONArray().apply {
|
|
|
|
for(item in enquete_items) {
|
2018-11-06 02:29:33 +01:00
|
|
|
val text = EmojiDecoder.decodeShortCode(
|
2018-08-20 02:07:55 +02:00
|
|
|
item,
|
|
|
|
emojiMapCustom = emojiMapCustom
|
|
|
|
)
|
2018-11-06 02:29:33 +01:00
|
|
|
if(text.isEmpty()) continue
|
2018-08-20 02:07:55 +02:00
|
|
|
put(text)
|
|
|
|
}
|
|
|
|
}
|
2018-11-06 02:29:33 +01:00
|
|
|
if(choices.length() > 0) {
|
|
|
|
json.put("poll", JSONObject().apply {
|
|
|
|
put("choices", choices)
|
2018-08-20 02:07:55 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
json.put(
|
|
|
|
"status",
|
|
|
|
EmojiDecoder.decodeShortCode(
|
|
|
|
content,
|
|
|
|
emojiMapCustom = emojiMapCustom
|
|
|
|
)
|
|
|
|
)
|
|
|
|
if(visibility_checked != null) {
|
2018-08-20 19:37:42 +02:00
|
|
|
json.put("visibility", visibility_checked.strMastodon)
|
2018-08-20 02:07:55 +02:00
|
|
|
}
|
|
|
|
json.put("sensitive", bNSFW)
|
|
|
|
json.put(
|
|
|
|
"spoiler_text",
|
|
|
|
EmojiDecoder.decodeShortCode(
|
|
|
|
spoiler_text ?: "",
|
|
|
|
emojiMapCustom = emojiMapCustom
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
if(in_reply_to_id != null) {
|
2018-09-01 15:50:37 +02:00
|
|
|
json.put("in_reply_to_id", in_reply_to_id.toLong())
|
2018-08-20 02:07:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if(attachment_list != null) {
|
|
|
|
val array = JSONArray()
|
|
|
|
for(pa in attachment_list) {
|
|
|
|
val a = pa.attachment ?: continue
|
|
|
|
if(a.redraft && ! instance.versionGE(TootInstance.VERSION_2_4_1)) continue
|
|
|
|
array.put(a.id)
|
|
|
|
}
|
|
|
|
json.put("media_ids", array)
|
|
|
|
}
|
|
|
|
|
|
|
|
if(enquete_items?.isNotEmpty() == true) {
|
|
|
|
json.put("isEnquete", true)
|
|
|
|
val array = JSONArray()
|
|
|
|
for(item in enquete_items) {
|
|
|
|
array.put(
|
|
|
|
EmojiDecoder.decodeShortCode(
|
|
|
|
item,
|
|
|
|
emojiMapCustom = emojiMapCustom
|
|
|
|
)
|
|
|
|
)
|
|
|
|
}
|
|
|
|
json.put("enquete_items", array)
|
|
|
|
}
|
|
|
|
|
2018-06-23 04:43:18 +02:00
|
|
|
}
|
|
|
|
} catch(ex : JSONException) {
|
|
|
|
log.trace(ex)
|
|
|
|
log.e(ex, "status encoding failed.")
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
|
2018-06-23 04:43:18 +02:00
|
|
|
val body_string = json.toString()
|
|
|
|
val request_body = RequestBody.create(
|
|
|
|
TootApiClient.MEDIA_TYPE_JSON, body_string
|
|
|
|
)
|
|
|
|
|
2018-01-21 13:46:36 +01:00
|
|
|
val request_builder = Request.Builder().post(request_body)
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-01-21 17:47:13 +01:00
|
|
|
if(! Pref.bpDontDuplicationCheck(pref)) {
|
2018-05-16 21:09:07 +02:00
|
|
|
val digest = (body_string + account.acct).digestSHA256Hex()
|
2018-01-04 19:52:25 +01:00
|
|
|
request_builder.header("Idempotency-Key", digest)
|
|
|
|
}
|
2018-11-06 02:29:33 +01:00
|
|
|
|
|
|
|
result = if(isMisskey) {
|
2018-11-12 18:19:57 +01:00
|
|
|
log.d("misskey json %s",body_string)
|
|
|
|
|
2018-08-20 02:07:55 +02:00
|
|
|
client.request("/api/notes/create", request_builder)
|
2018-11-06 02:29:33 +01:00
|
|
|
} else {
|
2018-08-20 02:07:55 +02:00
|
|
|
client.request("/api/v1/statuses", request_builder)
|
|
|
|
}
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-11-06 02:29:33 +01:00
|
|
|
val status = parser.status(
|
|
|
|
if(isMisskey) {
|
|
|
|
result?.jsonObject?.optJSONObject("createdNote") ?: result?.jsonObject
|
|
|
|
} else {
|
|
|
|
result?.jsonObject
|
|
|
|
}
|
|
|
|
)
|
2018-01-04 19:52:25 +01:00
|
|
|
this.status = status
|
|
|
|
if(status != null) {
|
2018-06-23 04:43:18 +02:00
|
|
|
|
2018-01-04 19:52:25 +01:00
|
|
|
// タグを覚えておく
|
|
|
|
val s = status.decoded_content
|
|
|
|
val span_list = s.getSpans(0, s.length, MyClickableSpan::class.java)
|
|
|
|
if(span_list != null) {
|
|
|
|
val tag_list = ArrayList<String?>(span_list.size)
|
|
|
|
for(span in span_list) {
|
|
|
|
val start = s.getSpanStart(span)
|
|
|
|
val end = s.getSpanEnd(span)
|
|
|
|
val text = s.subSequence(start, end).toString()
|
|
|
|
if(text.startsWith("#")) {
|
|
|
|
tag_list.add(text.substring(1))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
val count = tag_list.size
|
|
|
|
if(count > 0) {
|
|
|
|
TagSet.saveList(System.currentTimeMillis(), tag_list, 0, count)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2018-06-23 04:43:18 +02:00
|
|
|
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun handleResult(result : TootApiResult?) {
|
|
|
|
result ?: return // cancelled.
|
|
|
|
|
|
|
|
val status = this.status
|
|
|
|
if(status != null) {
|
|
|
|
// 連投してIdempotency が同じだった場合もエラーにはならず、ここを通る
|
|
|
|
callback(account, status)
|
|
|
|
} else {
|
2018-01-21 13:46:36 +01:00
|
|
|
showToast(activity, true, result.error)
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2018-08-15 04:06:25 +02:00
|
|
|
})
|
|
|
|
)
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// 入力補完機能
|
|
|
|
|
|
|
|
private val picker_caption_emoji : String by lazy {
|
|
|
|
activity.getString(R.string.open_picker_emoji)
|
|
|
|
}
|
|
|
|
// private val picker_caption_tag : String by lazy {
|
|
|
|
// activity.getString(R.string.open_picker_tag)
|
|
|
|
// }
|
|
|
|
// private val picker_caption_mention : String by lazy {
|
|
|
|
// activity.getString(R.string.open_picker_mention)
|
|
|
|
// }
|
|
|
|
|
|
|
|
private var callback2 : Callback2? = null
|
|
|
|
private var et : MyEditText? = null
|
|
|
|
private var popup : PopupAutoCompleteAcct? = null
|
|
|
|
private var formRoot : View? = null
|
|
|
|
private var bMainScreen : Boolean = false
|
|
|
|
|
|
|
|
private var instance : String? = null
|
2018-08-20 02:07:55 +02:00
|
|
|
private var isMisskey = false
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-01-21 17:47:13 +01:00
|
|
|
private val onEmojiListLoad : (list : ArrayList<CustomEmoji>) -> Unit =
|
2018-11-12 18:19:57 +01:00
|
|
|
{
|
2018-01-21 17:47:13 +01:00
|
|
|
val popup = this@PostHelper.popup
|
|
|
|
if(popup?.isShowing == true) proc_text_changed.run()
|
|
|
|
}
|
2018-01-10 16:47:35 +01:00
|
|
|
|
2018-01-04 19:52:25 +01:00
|
|
|
private val proc_text_changed = object : Runnable {
|
|
|
|
override fun run() {
|
2018-01-10 16:47:35 +01:00
|
|
|
val et = this@PostHelper.et
|
2018-01-16 07:48:17 +01:00
|
|
|
if(et == null || callback2?.canOpenPopup() != true) {
|
2018-01-04 19:52:25 +01:00
|
|
|
closeAcctPopup()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-01-16 07:48:17 +01:00
|
|
|
var start = et.selectionStart
|
|
|
|
val end = et.selectionEnd
|
2018-01-04 19:52:25 +01:00
|
|
|
if(start != end) {
|
|
|
|
closeAcctPopup()
|
|
|
|
return
|
|
|
|
}
|
2018-01-16 07:48:17 +01:00
|
|
|
val src = et.text.toString()
|
2018-01-04 19:52:25 +01:00
|
|
|
var count_atMark = 0
|
|
|
|
val pos_atMark = IntArray(2)
|
|
|
|
while(true) {
|
|
|
|
if(count_atMark >= 2) break
|
|
|
|
|
|
|
|
if(start == 0) break
|
|
|
|
val c = src[start - 1]
|
|
|
|
|
|
|
|
if(c == '@') {
|
|
|
|
-- start
|
|
|
|
pos_atMark[count_atMark ++] = start
|
|
|
|
continue
|
|
|
|
} else if('0' <= c && c <= '9'
|
|
|
|
|| 'A' <= c && c <= 'Z'
|
|
|
|
|| 'a' <= c && c <= 'z'
|
|
|
|
|| c == '_' || c == '-' || c == '.') {
|
|
|
|
-- start
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// その他の文字種が出たら探索打ち切り
|
|
|
|
break
|
|
|
|
}
|
|
|
|
// 登場した@の数
|
|
|
|
start = when(count_atMark) {
|
|
|
|
1 -> pos_atMark[0]
|
|
|
|
2 -> pos_atMark[1]
|
|
|
|
|
|
|
|
else -> {
|
|
|
|
// 次はAcctじゃなくてHashtagの補完を試みる
|
|
|
|
checkTag()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 最低でも2文字ないと補完しない
|
|
|
|
// 最低でも2文字ないと補完しない
|
|
|
|
if(end - start < 2) {
|
|
|
|
closeAcctPopup()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
val limit = 100
|
|
|
|
val s = src.substring(start, end)
|
|
|
|
val acct_list = AcctSet.searchPrefix(s, limit)
|
|
|
|
log.d("search for %s, result=%d", s, acct_list.size)
|
|
|
|
if(acct_list.isEmpty()) {
|
|
|
|
closeAcctPopup()
|
|
|
|
} else {
|
2018-01-16 07:48:17 +01:00
|
|
|
openPopup()?.setList(et, start, end, acct_list, null, null)
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private fun checkTag() {
|
|
|
|
val et = this@PostHelper.et ?: return
|
|
|
|
|
|
|
|
val end = et.selectionEnd
|
|
|
|
|
|
|
|
val src = et.text.toString()
|
|
|
|
val last_sharp = src.lastIndexOf('#', end - 1)
|
|
|
|
|
|
|
|
if(last_sharp == - 1 || end - last_sharp < 2) {
|
|
|
|
checkEmoji()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
val part = src.substring(last_sharp + 1, end)
|
|
|
|
if(reCharsNotTag.matcher(part).find()) {
|
2018-01-28 20:03:04 +01:00
|
|
|
// warning.d( "checkTag: character not tag in string %s", part );
|
2018-01-04 19:52:25 +01:00
|
|
|
checkEmoji()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
val limit = 100
|
|
|
|
val s = src.substring(last_sharp + 1, end)
|
|
|
|
val tag_list = TagSet.searchPrefix(s, limit)
|
|
|
|
log.d("search for %s, result=%d", s, tag_list.size)
|
|
|
|
if(tag_list.isEmpty()) {
|
|
|
|
closeAcctPopup()
|
|
|
|
} else {
|
|
|
|
openPopup()?.setList(et, last_sharp, end, tag_list, null, null)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private fun checkEmoji() {
|
|
|
|
val et = this@PostHelper.et ?: return
|
|
|
|
|
|
|
|
val end = et.selectionEnd
|
|
|
|
val src = et.text.toString()
|
|
|
|
val last_colon = src.lastIndexOf(':', end - 1)
|
|
|
|
|
|
|
|
if(last_colon == - 1 || end - last_colon < 1) {
|
|
|
|
closeAcctPopup()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
val part = src.substring(last_colon + 1, end)
|
|
|
|
|
|
|
|
if(reCharsNotEmoji.matcher(part).find()) {
|
2018-03-22 14:49:22 +01:00
|
|
|
log.d("checkEmoji: character not short code in string.")
|
2018-01-04 19:52:25 +01:00
|
|
|
closeAcctPopup()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// : の手前は始端か改行か空白でなければならない
|
2018-06-23 04:43:18 +02:00
|
|
|
if(! EmojiDecoder.canStartShortCode(src, last_colon)) {
|
2018-01-04 19:52:25 +01:00
|
|
|
log.d("checkEmoji: invalid character before shortcode.")
|
|
|
|
closeAcctPopup()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if(part.isEmpty()) {
|
|
|
|
openPopup()?.setList(
|
|
|
|
et, last_colon, end, null, picker_caption_emoji, open_picker_emoji
|
|
|
|
)
|
|
|
|
} else {
|
2018-11-06 02:29:33 +01:00
|
|
|
|
|
|
|
val code_list = ArrayList<CharSequence>()
|
2018-01-04 19:52:25 +01:00
|
|
|
val limit = 100
|
|
|
|
|
|
|
|
// カスタム絵文字を検索
|
|
|
|
val instance = this@PostHelper.instance
|
2018-11-06 02:29:33 +01:00
|
|
|
if(instance != null && instance.isNotEmpty()) {
|
|
|
|
val custom_list = App1.custom_emoji_lister.getListWithAliases(
|
|
|
|
instance,
|
|
|
|
isMisskey,
|
|
|
|
onEmojiListLoad
|
|
|
|
)
|
2018-01-04 19:52:25 +01:00
|
|
|
if(custom_list != null) {
|
|
|
|
val needle = src.substring(last_colon + 1, end)
|
2018-11-06 02:29:33 +01:00
|
|
|
|
2018-01-04 19:52:25 +01:00
|
|
|
for(item in custom_list) {
|
|
|
|
if(code_list.size >= limit) break
|
|
|
|
if(! item.shortcode.contains(needle)) continue
|
|
|
|
|
|
|
|
val sb = SpannableStringBuilder()
|
|
|
|
sb.append(' ')
|
2018-01-21 17:47:13 +01:00
|
|
|
sb.setSpan(
|
|
|
|
NetworkEmojiSpan(item.url),
|
|
|
|
0,
|
|
|
|
sb.length,
|
|
|
|
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
|
|
|
|
)
|
2018-01-04 19:52:25 +01:00
|
|
|
sb.append(' ')
|
2018-11-06 02:29:33 +01:00
|
|
|
if(item.alias != null) {
|
|
|
|
val start = sb.length
|
|
|
|
sb.append(":")
|
|
|
|
sb.append(item.alias)
|
|
|
|
sb.append(": → ")
|
|
|
|
sb.setSpan(
|
|
|
|
ForegroundColorSpan(
|
|
|
|
Styler.getAttributeColor(
|
|
|
|
activity,
|
|
|
|
R.attr.colorTimeSmall
|
|
|
|
)
|
|
|
|
),
|
|
|
|
start,
|
|
|
|
sb.length,
|
|
|
|
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2018-01-04 19:52:25 +01:00
|
|
|
sb.append(':')
|
|
|
|
sb.append(item.shortcode)
|
|
|
|
sb.append(':')
|
2018-11-06 02:29:33 +01:00
|
|
|
|
2018-01-04 19:52:25 +01:00
|
|
|
code_list.add(sb)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-06 02:29:33 +01:00
|
|
|
// 通常の絵文字を部分一致で検索
|
|
|
|
val remain = limit - code_list.size
|
|
|
|
if(remain > 0) {
|
|
|
|
val s = src.substring(last_colon + 1, end).toLowerCase().replace('-', '_')
|
2018-11-12 18:19:57 +01:00
|
|
|
val matches = EmojiDecoder.searchShortCode(activity, s, remain)
|
|
|
|
log.d("checkEmoji: search for %s, result=%d", s, matches.size)
|
|
|
|
code_list.addAll(matches)
|
2018-11-06 02:29:33 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2018-01-21 17:47:13 +01:00
|
|
|
openPopup()?.setList(
|
|
|
|
et,
|
|
|
|
last_colon,
|
|
|
|
end,
|
|
|
|
code_list,
|
|
|
|
picker_caption_emoji,
|
|
|
|
open_picker_emoji
|
|
|
|
)
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private fun openPopup() : PopupAutoCompleteAcct? {
|
|
|
|
var popup = this@PostHelper.popup
|
|
|
|
if(popup?.isShowing == true) return popup
|
|
|
|
val et = this@PostHelper.et ?: return null
|
|
|
|
val formRoot = this@PostHelper.formRoot ?: return null
|
|
|
|
popup = PopupAutoCompleteAcct(activity, et, formRoot, bMainScreen)
|
|
|
|
this@PostHelper.popup = popup
|
|
|
|
return popup
|
|
|
|
}
|
|
|
|
|
|
|
|
interface Callback2 {
|
|
|
|
fun onTextUpdate()
|
|
|
|
|
|
|
|
fun canOpenPopup() : Boolean
|
|
|
|
}
|
|
|
|
|
2018-08-20 02:07:55 +02:00
|
|
|
fun setInstance(_instance : String?, isMisskey : Boolean) {
|
2018-01-04 19:52:25 +01:00
|
|
|
val instance = _instance?.toLowerCase()
|
|
|
|
this.instance = instance
|
2018-08-20 02:07:55 +02:00
|
|
|
this.isMisskey = isMisskey
|
2018-01-04 19:52:25 +01:00
|
|
|
|
2018-11-06 02:29:33 +01:00
|
|
|
if(instance != null) {
|
|
|
|
App1.custom_emoji_lister.getList(instance, isMisskey, onEmojiListLoad)
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
val popup = this.popup
|
|
|
|
if(popup?.isShowing == true) {
|
|
|
|
proc_text_changed.run()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fun closeAcctPopup() {
|
|
|
|
popup?.dismiss()
|
|
|
|
popup = null
|
|
|
|
}
|
|
|
|
|
|
|
|
fun onScrollChanged() {
|
2018-01-10 16:47:35 +01:00
|
|
|
if(popup?.isShowing == true) {
|
|
|
|
popup?.updatePosition()
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fun onDestroy() {
|
|
|
|
handler.removeCallbacks(proc_text_changed)
|
|
|
|
closeAcctPopup()
|
|
|
|
}
|
|
|
|
|
2018-01-21 17:47:13 +01:00
|
|
|
fun attachEditText(
|
|
|
|
_formRoot : View,
|
|
|
|
et : MyEditText,
|
|
|
|
bMainScreen : Boolean,
|
|
|
|
_callback2 : Callback2
|
|
|
|
) {
|
2018-01-04 19:52:25 +01:00
|
|
|
this.formRoot = _formRoot
|
2018-01-10 16:47:35 +01:00
|
|
|
this.et = et
|
2018-01-04 19:52:25 +01:00
|
|
|
this.callback2 = _callback2
|
|
|
|
this.bMainScreen = bMainScreen
|
|
|
|
|
2018-01-16 07:48:17 +01:00
|
|
|
et.addTextChangedListener(object : TextWatcher {
|
2018-01-21 17:47:13 +01:00
|
|
|
override fun beforeTextChanged(
|
|
|
|
s : CharSequence,
|
|
|
|
start : Int,
|
|
|
|
count : Int,
|
|
|
|
after : Int
|
|
|
|
) {
|
2018-01-04 19:52:25 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
override fun onTextChanged(s : CharSequence, start : Int, before : Int, count : Int) {
|
|
|
|
handler.removeCallbacks(proc_text_changed)
|
2018-01-16 07:48:17 +01:00
|
|
|
handler.postDelayed(proc_text_changed, if(popup?.isShowing == true) 100L else 500L)
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
override fun afterTextChanged(s : Editable) {
|
2018-01-10 16:47:35 +01:00
|
|
|
callback2?.onTextUpdate()
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2018-01-16 07:48:17 +01:00
|
|
|
et.setOnSelectionChangeListener(object : MyEditText.OnSelectionChangeListener {
|
2018-01-04 19:52:25 +01:00
|
|
|
override fun onSelectionChanged(selStart : Int, selEnd : Int) {
|
|
|
|
if(selStart != selEnd) {
|
|
|
|
// 範囲選択されてるならポップアップは閉じる
|
|
|
|
log.d("onSelectionChanged: range selected")
|
|
|
|
closeAcctPopup()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
// 全然動いてなさそう…
|
|
|
|
// et.setCustomSelectionActionModeCallback( action_mode_callback );
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2018-02-11 09:45:15 +01:00
|
|
|
private fun SpannableStringBuilder.appendEmoji(
|
|
|
|
name : String,
|
|
|
|
instance : String?,
|
|
|
|
bInstanceHasCustomEmoji : Boolean
|
|
|
|
) : SpannableStringBuilder {
|
|
|
|
|
|
|
|
val item = EmojiMap201709.sShortNameToImageId[name]
|
|
|
|
if(item == null || instance != null) {
|
|
|
|
// カスタム絵文字は常にshortcode表現
|
2018-03-22 14:49:22 +01:00
|
|
|
if(! EmojiDecoder.canStartShortCode(this, this.length)) this.append(' ')
|
2018-02-11 09:45:15 +01:00
|
|
|
this.append(SpannableString(":$name:"))
|
|
|
|
} else if(! bInstanceHasCustomEmoji) {
|
|
|
|
// 古いタンスだとshortcodeを使う。見た目は絵文字に変える。
|
2018-03-22 14:49:22 +01:00
|
|
|
if(! EmojiDecoder.canStartShortCode(this, this.length)) this.append(' ')
|
2018-02-11 09:45:15 +01:00
|
|
|
this.append(DecodeOptions(activity).decodeEmoji(":$name:"))
|
|
|
|
} else {
|
|
|
|
// 十分に新しいタンスなら絵文字のunicodeを使う。見た目は絵文字に変える。
|
|
|
|
this.append(DecodeOptions(activity).decodeEmoji(item.unified))
|
|
|
|
}
|
|
|
|
return this
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2018-01-16 07:48:17 +01:00
|
|
|
private val open_picker_emoji : Runnable = Runnable {
|
2018-08-20 02:07:55 +02:00
|
|
|
EmojiPicker(activity, instance, isMisskey) { name, instance, bInstanceHasCustomEmoji ->
|
2018-01-14 10:14:39 +01:00
|
|
|
val et = this.et ?: return@EmojiPicker
|
2018-01-16 07:48:17 +01:00
|
|
|
|
2018-09-27 16:21:37 +02:00
|
|
|
val src = et.text ?: ""
|
2018-01-16 07:48:17 +01:00
|
|
|
val src_length = src.length
|
2018-06-23 04:43:18 +02:00
|
|
|
val end = Math.min(src_length, et.selectionEnd)
|
2018-01-16 07:48:17 +01:00
|
|
|
val start = src.lastIndexOf(':', end - 1)
|
2018-06-23 04:43:18 +02:00
|
|
|
if(start == - 1 || end - start < 1) return@EmojiPicker
|
2018-02-11 09:20:49 +01:00
|
|
|
|
2018-02-11 09:45:15 +01:00
|
|
|
val sb = SpannableStringBuilder()
|
2018-01-16 07:48:17 +01:00
|
|
|
.append(src.subSequence(0, start))
|
2018-02-11 09:45:15 +01:00
|
|
|
.appendEmoji(name, instance, bInstanceHasCustomEmoji)
|
2018-02-11 09:20:49 +01:00
|
|
|
|
2018-02-11 09:45:15 +01:00
|
|
|
val newSelection = sb.length
|
2018-11-06 02:29:33 +01:00
|
|
|
if(end < src_length) sb.append(src.subSequence(end, src_length))
|
2018-01-14 10:14:39 +01:00
|
|
|
|
2018-02-11 09:45:15 +01:00
|
|
|
et.text = sb
|
2018-02-11 09:20:49 +01:00
|
|
|
et.setSelection(newSelection)
|
2018-01-14 10:14:39 +01:00
|
|
|
|
|
|
|
proc_text_changed.run()
|
|
|
|
|
|
|
|
// キーボードを再度表示する
|
2018-01-21 13:46:36 +01:00
|
|
|
Handler(activity.mainLooper).post { et.showKeyboard() }
|
2018-01-14 10:14:39 +01:00
|
|
|
|
|
|
|
}.show()
|
|
|
|
}
|
|
|
|
|
2018-01-16 07:48:17 +01:00
|
|
|
fun openEmojiPickerFromMore() {
|
2018-08-20 02:07:55 +02:00
|
|
|
EmojiPicker(activity, instance, isMisskey) { name, instance, bInstanceHasCustomEmoji ->
|
2018-01-16 07:48:17 +01:00
|
|
|
val et = this.et ?: return@EmojiPicker
|
|
|
|
|
2018-09-27 16:21:37 +02:00
|
|
|
val src = et.text ?: ""
|
2018-01-16 07:48:17 +01:00
|
|
|
val src_length = src.length
|
|
|
|
val start = Math.min(src_length, et.selectionStart)
|
|
|
|
val end = Math.min(src_length, et.selectionEnd)
|
2018-01-14 10:14:39 +01:00
|
|
|
|
2018-02-11 09:45:15 +01:00
|
|
|
val sb = SpannableStringBuilder()
|
2018-11-06 02:29:33 +01:00
|
|
|
.append(src.subSequence(0, start))
|
2018-02-11 09:45:15 +01:00
|
|
|
.appendEmoji(name, instance, bInstanceHasCustomEmoji)
|
2018-02-11 09:20:49 +01:00
|
|
|
|
2018-02-11 09:45:15 +01:00
|
|
|
val newSelection = sb.length
|
2018-11-06 02:29:33 +01:00
|
|
|
if(end < src_length) sb.append(src.subSequence(end, src_length))
|
2018-01-14 10:14:39 +01:00
|
|
|
|
2018-02-11 09:45:15 +01:00
|
|
|
et.text = sb
|
2018-02-11 09:20:49 +01:00
|
|
|
et.setSelection(newSelection)
|
2018-01-14 10:14:39 +01:00
|
|
|
|
|
|
|
proc_text_changed.run()
|
|
|
|
}.show()
|
2018-01-04 19:52:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// final ActionMode.Callback action_mode_callback = new ActionMode.Callback() {
|
|
|
|
// @Override public boolean onCreateActionMode( ActionMode actionMode, Menu menu ){
|
|
|
|
// actionMode.getMenuInflater().inflate(R.menu.toot_long_tap, menu);
|
|
|
|
// return true;
|
|
|
|
// }
|
|
|
|
// @Override public void onDestroyActionMode( ActionMode actionMode ){
|
|
|
|
//
|
|
|
|
// }
|
|
|
|
// @Override public boolean onPrepareActionMode( ActionMode actionMode, Menu menu ){
|
|
|
|
// return false;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// @Override
|
|
|
|
// public boolean onActionItemClicked( ActionMode actionMode, MenuItem item ){
|
|
|
|
// if (item.getItemId() == R.id.action_pick_emoji) {
|
|
|
|
// actionMode.finish();
|
|
|
|
// EmojiPicker.open( activity, instance, new EmojiPicker.Callback() {
|
|
|
|
// @Override public void onPickedEmoji( String name ){
|
|
|
|
// int end = et.getSelectionEnd();
|
|
|
|
// String src = et.getText().toString();
|
|
|
|
// CharSequence svInsert = ":" + name + ":";
|
|
|
|
// src = src.substring( 0, end ) + svInsert + " " + ( end >= src.length() ? "" : src.substring( end ) );
|
|
|
|
// et.setText( src );
|
|
|
|
// et.setSelection( end + svInsert.length() + 1 );
|
|
|
|
//
|
|
|
|
// proc_text_changed.run();
|
|
|
|
// }
|
|
|
|
// } );
|
|
|
|
// return true;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// return false;
|
|
|
|
// }
|
|
|
|
// };
|
|
|
|
|
|
|
|
}
|