Twidere-App-Android-Twitter.../twidere/src/main/kotlin/org/mariotaku/twidere/activity/ComposeActivity.kt

1779 lines
71 KiB
Kotlin
Raw Normal View History

2016-07-02 05:54:53 +02:00
/*
* Twidere - Twitter client for Android
*
* Copyright (C) 2012-2014 Mariotaku Lee <mariotaku.lee@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.mariotaku.twidere.activity
2016-12-04 04:58:03 +01:00
import android.accounts.AccountManager
2016-07-02 05:54:53 +02:00
import android.app.Activity
import android.app.Dialog
2017-02-14 13:32:15 +01:00
import android.content.ActivityNotFoundException
import android.content.ContentValues
import android.content.DialogInterface
import android.content.Intent
2016-07-02 05:54:53 +02:00
import android.graphics.Canvas
import android.graphics.PorterDuff.Mode
import android.location.*
import android.net.Uri
import android.os.AsyncTask
import android.os.Bundle
import android.os.Parcelable
import android.provider.BaseColumns
2017-01-22 18:13:31 +01:00
import android.support.v4.app.ActivityCompat
2016-07-02 05:54:53 +02:00
import android.support.v4.app.DialogFragment
import android.support.v7.app.AlertDialog
import android.support.v7.view.SupportMenuInflater
import android.support.v7.widget.ActionMenuView.OnMenuItemClickListener
2016-12-18 06:21:24 +01:00
import android.support.v7.widget.DefaultItemAnimator
import android.support.v7.widget.FixedLinearLayoutManager
import android.support.v7.widget.LinearLayoutManager
import android.support.v7.widget.RecyclerView
2017-02-14 13:32:15 +01:00
import android.support.v7.widget.RecyclerView.ViewHolder
2016-07-02 05:54:53 +02:00
import android.support.v7.widget.helper.ItemTouchHelper
import android.text.*
import android.text.style.ImageSpan
import android.text.style.SuggestionSpan
import android.text.style.UpdateAppearance
import android.util.Log
import android.view.*
import android.view.View.OnClickListener
import android.view.View.OnLongClickListener
import android.widget.TextView
import android.widget.Toast
import com.twitter.Extractor
2017-02-28 08:34:00 +01:00
import com.twitter.Validator
2016-07-02 05:54:53 +02:00
import kotlinx.android.synthetic.main.activity_compose.*
import org.apache.commons.lang3.ArrayUtils
import org.apache.commons.lang3.ObjectUtils
import org.mariotaku.abstask.library.AbstractTask
import org.mariotaku.abstask.library.TaskStarter
2016-12-13 04:06:07 +01:00
import org.mariotaku.kpreferences.get
2017-02-16 07:50:25 +01:00
import org.mariotaku.ktextension.checkAnySelfPermissionsGranted
import org.mariotaku.ktextension.getTypedArray
import org.mariotaku.ktextension.setItemChecked
import org.mariotaku.ktextension.toTypedArray
2017-01-22 18:13:31 +01:00
import org.mariotaku.pickncrop.library.MediaPickerActivity
2016-07-02 05:54:53 +02:00
import org.mariotaku.twidere.Constants.*
import org.mariotaku.twidere.R
import org.mariotaku.twidere.TwidereConstants
2016-07-02 05:54:53 +02:00
import org.mariotaku.twidere.adapter.BaseRecyclerViewAdapter
2017-02-14 13:32:15 +01:00
import org.mariotaku.twidere.adapter.MediaPreviewAdapter
2016-12-13 04:06:07 +01:00
import org.mariotaku.twidere.constant.*
2017-02-05 14:42:20 +01:00
import org.mariotaku.twidere.extension.applyTheme
2016-12-29 06:50:18 +01:00
import org.mariotaku.twidere.extension.model.getAccountUser
2017-02-28 08:34:00 +01:00
import org.mariotaku.twidere.extension.model.textLimit
import org.mariotaku.twidere.extension.model.unique_id_non_null
2016-07-02 05:54:53 +02:00
import org.mariotaku.twidere.fragment.BaseDialogFragment
2017-02-15 06:53:53 +01:00
import org.mariotaku.twidere.fragment.EditAltTextDialogFragment
2016-12-13 04:06:07 +01:00
import org.mariotaku.twidere.fragment.PermissionRequestDialog
import org.mariotaku.twidere.fragment.PermissionRequestDialog.PermissionRequestCancelCallback
2016-07-02 05:54:53 +02:00
import org.mariotaku.twidere.fragment.ProgressDialogFragment
import org.mariotaku.twidere.model.*
import org.mariotaku.twidere.model.draft.UpdateStatusActionExtras
2016-12-04 04:58:03 +01:00
import org.mariotaku.twidere.model.util.AccountUtils
2016-07-02 05:54:53 +02:00
import org.mariotaku.twidere.model.util.ParcelableLocationUtils
import org.mariotaku.twidere.preference.ServicePickerPreference
import org.mariotaku.twidere.provider.TwidereDataStore.Drafts
2017-01-05 14:08:49 +01:00
import org.mariotaku.twidere.service.LengthyOperationsService
2017-02-14 13:32:15 +01:00
import org.mariotaku.twidere.task.compose.AbsAddMediaTask
2017-02-15 06:32:45 +01:00
import org.mariotaku.twidere.task.compose.AbsDeleteMediaTask
2016-07-02 05:54:53 +02:00
import org.mariotaku.twidere.text.MarkForDeleteSpan
import org.mariotaku.twidere.text.style.EmojiSpan
import org.mariotaku.twidere.util.*
import org.mariotaku.twidere.util.EditTextEnterHandler.EnterListener
import org.mariotaku.twidere.util.dagger.GeneralComponentHelper
import org.mariotaku.twidere.view.CheckableLinearLayout
import org.mariotaku.twidere.view.ExtendedRecyclerView
import org.mariotaku.twidere.view.ShapedImageView
import org.mariotaku.twidere.view.helper.SimpleItemTouchHelperCallback
2017-02-14 13:32:15 +01:00
import org.mariotaku.twidere.view.holder.compose.MediaPreviewViewHolder
import java.io.IOException
2016-07-02 05:54:53 +02:00
import java.lang.ref.WeakReference
import java.util.*
import javax.inject.Inject
2016-12-13 04:06:07 +01:00
import android.Manifest.permission as AndroidPermission
2016-07-02 05:54:53 +02:00
2016-12-13 04:06:07 +01:00
class ComposeActivity : BaseActivity(), OnMenuItemClickListener, OnClickListener, OnLongClickListener,
2017-02-15 06:53:53 +01:00
ActionMode.Callback, PermissionRequestCancelCallback, EditAltTextDialogFragment.EditAltTextCallback {
2016-07-02 05:54:53 +02:00
// Utility classes
@Inject
lateinit var extractor: Extractor
@Inject
2017-02-28 08:34:00 +01:00
lateinit var validator: Validator
2016-09-09 05:58:26 +02:00
@Inject
2017-01-21 05:08:47 +01:00
lateinit var locationManager: LocationManager
2016-07-02 05:54:53 +02:00
private lateinit var itemTouchHelper: ItemTouchHelper
2016-12-13 01:45:14 +01:00
private val supportMenuInflater by lazy { SupportMenuInflater(this) }
private var currentTask: AsyncTask<Any, Any, *>? = null
2016-07-02 05:54:53 +02:00
2016-07-08 03:44:43 +02:00
private val backTimeoutRunnable = Runnable { navigateBackPressed = false }
2016-07-02 05:54:53 +02:00
// Adapters
2016-12-06 06:15:22 +01:00
private lateinit var mediaPreviewAdapter: MediaPreviewAdapter
private lateinit var accountsAdapter: AccountIconsAdapter
2016-07-02 05:54:53 +02:00
// Data fields
2016-07-07 05:42:08 +02:00
private var recentLocation: ParcelableLocation? = null
2016-07-08 03:44:43 +02:00
private var inReplyToStatus: ParcelableStatus? = null
private var mentionUser: ParcelableUser? = null
private var originalText: String? = null
2016-07-04 03:31:17 +02:00
private var possiblySensitive: Boolean = false
private var shouldSaveAccounts: Boolean = false
2016-07-08 03:44:43 +02:00
private var imageUploaderUsed: Boolean = false
private var statusShortenerUsed: Boolean = false
private var navigateBackPressed: Boolean = false
2016-07-05 15:19:51 +02:00
private var textChanged: Boolean = false
2016-07-08 03:44:43 +02:00
private var composeKeyMetaState: Int = 0
private var draft: Draft? = null
private var nameFirst: Boolean = false
private var draftUniqueId: String? = null
private var shouldSkipDraft: Boolean = false
2016-07-02 05:54:53 +02:00
// Listeners
private var locationListener: LocationListener? = null
2016-07-02 05:54:53 +02:00
override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
2016-07-02 05:54:53 +02:00
when (requestCode) {
2017-01-22 18:13:31 +01:00
REQUEST_TAKE_PHOTO, REQUEST_PICK_MEDIA -> {
2016-07-05 15:19:51 +02:00
if (resultCode == Activity.RESULT_OK && intent != null) {
2017-01-22 18:13:31 +01:00
val src = MediaPickerActivity.getMediaUris(intent)
2017-02-15 06:32:45 +01:00
TaskStarter.execute(AddMediaTask(this, src, false, false))
2016-07-02 05:54:53 +02:00
}
}
REQUEST_EDIT_IMAGE -> {
2016-07-05 15:19:51 +02:00
if (resultCode == Activity.RESULT_OK && intent != null) {
2016-07-02 05:54:53 +02:00
if (intent.data != null) {
setMenu()
updateTextCount()
}
}
}
REQUEST_EXTENSION_COMPOSE -> {
2016-07-05 15:19:51 +02:00
if (resultCode == Activity.RESULT_OK && intent != null) {
2016-07-02 05:54:53 +02:00
val text = intent.getStringExtra(EXTRA_TEXT)
val append = intent.getStringExtra(EXTRA_APPEND_TEXT)
val imageUri = intent.getParcelableExtra<Uri>(EXTRA_IMAGE_URI)
if (text != null) {
editText.setText(text)
} else if (append != null) {
editText.append(append)
}
if (imageUri != null) {
}
setMenu()
updateTextCount()
}
}
}
}
2016-12-06 02:42:44 +01:00
2016-07-02 05:54:53 +02:00
override fun onBackPressed() {
2016-12-13 01:45:14 +01:00
if (currentTask?.status == AsyncTask.Status.RUNNING) return
if (!shouldSkipDraft && hasComposingStatus()) {
saveToDrafts()
2017-01-26 14:28:43 +01:00
Toast.makeText(this, R.string.message_toast_status_saved_to_draft, Toast.LENGTH_SHORT).show()
shouldSkipDraft = true
finish()
2016-07-02 05:54:53 +02:00
} else {
shouldSkipDraft = true
2016-07-02 05:54:53 +02:00
discardTweet()
}
}
2016-12-06 02:42:44 +01:00
override fun onDestroy() {
2016-12-18 03:38:43 +01:00
if (!shouldSkipDraft && hasComposingStatus() && isFinishing) {
2016-12-06 02:42:44 +01:00
saveToDrafts()
2017-01-26 14:28:43 +01:00
Toast.makeText(this, R.string.message_toast_status_saved_to_draft, Toast.LENGTH_SHORT).show()
2016-12-06 02:42:44 +01:00
}
super.onDestroy()
}
2016-12-06 06:15:22 +01:00
private fun discardTweet() {
2016-12-13 01:45:14 +01:00
if (isFinishing || currentTask?.status == AsyncTask.Status.RUNNING) return
2016-12-06 02:42:44 +01:00
currentTask = AsyncTaskUtils.executeTask(DiscardTweetTask(this))
2016-07-02 05:54:53 +02:00
}
2016-12-06 06:15:22 +01:00
private fun hasComposingStatus(): Boolean {
2016-07-02 05:54:53 +02:00
val text = if (editText != null) ParseUtils.parseString(editText.text) else null
2016-07-08 03:44:43 +02:00
val textChanged = text != null && !text.isEmpty() && text != originalText
2016-07-02 05:54:53 +02:00
val isEditingDraft = INTENT_ACTION_EDIT_DRAFT == intent.action
return textChanged || hasMedia() || isEditingDraft
}
override fun onSaveInstanceState(outState: Bundle) {
2016-12-06 06:15:22 +01:00
outState.putParcelableArray(EXTRA_ACCOUNT_KEYS, accountsAdapter.selectedAccountKeys)
2016-07-02 05:54:53 +02:00
outState.putParcelableArrayList(EXTRA_MEDIA, ArrayList<Parcelable>(mediaList))
2016-07-04 03:31:17 +02:00
outState.putBoolean(EXTRA_IS_POSSIBLY_SENSITIVE, possiblySensitive)
2016-07-08 03:44:43 +02:00
outState.putParcelable(EXTRA_STATUS, inReplyToStatus)
outState.putParcelable(EXTRA_USER, mentionUser)
outState.putParcelable(EXTRA_DRAFT, draft)
2016-07-04 03:31:17 +02:00
outState.putBoolean(EXTRA_SHOULD_SAVE_ACCOUNTS, shouldSaveAccounts)
2016-07-08 03:44:43 +02:00
outState.putString(EXTRA_ORIGINAL_TEXT, originalText)
outState.putString(EXTRA_DRAFT_UNIQUE_ID, draftUniqueId)
2016-07-02 05:54:53 +02:00
super.onSaveInstanceState(outState)
}
override fun onStart() {
super.onStart()
2017-01-21 05:08:47 +01:00
imageUploaderUsed = !ServicePickerPreference.isNoneValue(kPreferences[mediaUploaderKey])
statusShortenerUsed = !ServicePickerPreference.isNoneValue(kPreferences[statusShortenerKey])
if (kPreferences[attachLocationKey]) {
2016-12-13 04:06:07 +01:00
if (checkAnySelfPermissionsGranted(AndroidPermission.ACCESS_COARSE_LOCATION, AndroidPermission.ACCESS_FINE_LOCATION)) {
try {
startLocationUpdateIfEnabled()
} catch (e: SecurityException) {
locationSwitch.checkedPosition = LOCATION_OPTIONS.indexOf(LOCATION_VALUE_NONE)
}
} else {
locationSwitch.checkedPosition = LOCATION_OPTIONS.indexOf(LOCATION_VALUE_NONE)
}
2016-07-02 05:54:53 +02:00
}
setMenu()
updateTextCount()
2017-01-16 17:38:50 +01:00
val textSize = preferences[textSizeKey]
2016-07-02 05:54:53 +02:00
editText.textSize = textSize * 1.25f
}
override fun onStop() {
saveAccountSelection()
try {
if (locationListener != null) {
2016-12-13 01:45:14 +01:00
locationManager.removeUpdates(locationListener)
locationListener = null
2016-07-02 05:54:53 +02:00
}
} catch (ignore: SecurityException) {
// That should not happen
}
super.onStop()
}
override fun onClick(view: View) {
2016-07-08 03:44:43 +02:00
when (view) {
updateStatus -> {
2016-07-02 05:54:53 +02:00
confirmAndUpdateStatus()
}
2016-07-08 03:44:43 +02:00
accountSelectorContainer -> {
2016-07-02 05:54:53 +02:00
isAccountSelectorVisible = false
}
2016-07-08 03:44:43 +02:00
accountSelectorButton -> {
2016-07-02 05:54:53 +02:00
isAccountSelectorVisible = !isAccountSelectorVisible
}
2016-07-08 03:44:43 +02:00
replyLabel -> {
2016-07-02 05:54:53 +02:00
if (replyLabel.visibility != View.VISIBLE) return
replyLabel.setSingleLine(replyLabel.lineCount > 1)
}
}
}
private var isAccountSelectorVisible: Boolean
2016-07-08 03:44:43 +02:00
get() = accountSelectorContainer.visibility == View.VISIBLE
2016-07-02 05:54:53 +02:00
set(visible) {
2016-07-08 03:44:43 +02:00
accountSelectorContainer.visibility = if (visible) View.VISIBLE else View.GONE
2016-07-02 05:54:53 +02:00
}
private fun confirmAndUpdateStatus() {
if (isQuotingProtectedStatus) {
RetweetProtectedStatusWarnFragment().show(supportFragmentManager,
"retweet_protected_status_warning_message")
} else {
updateStatus()
}
}
override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
return true
}
override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
return true
}
override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
return false
}
override fun onDestroyActionMode(mode: ActionMode) {
val window = window
val contentView = window.findViewById(android.R.id.content)
contentView.setPadding(contentView.paddingLeft, 0,
contentView.paddingRight, contentView.paddingBottom)
}
override fun onLongClick(v: View): Boolean {
2016-07-08 03:44:43 +02:00
when (v) {
updateStatus -> {
2016-12-28 08:30:50 +01:00
Utils.showMenuItemToast(v, getString(R.string.action_send), true)
2016-07-02 05:54:53 +02:00
return true
}
}
return false
}
override fun onMenuItemClick(item: MenuItem): Boolean {
when (item.itemId) {
2017-01-23 16:24:58 +01:00
R.id.take_photo -> {
requestOrOpenCamera()
}
2016-07-02 05:54:53 +02:00
R.id.add_image, R.id.add_image_sub_item -> {
2017-01-22 18:13:31 +01:00
requestOrPickMedia()
2016-07-02 05:54:53 +02:00
}
R.id.drafts -> {
IntentUtils.openDrafts(this)
}
R.id.delete -> {
2017-02-15 06:32:45 +01:00
TaskStarter.execute(DeleteMediaTask(this, media))
2016-07-02 05:54:53 +02:00
}
R.id.toggle_sensitive -> {
if (!hasMedia()) return false
2016-07-04 03:31:17 +02:00
possiblySensitive = !possiblySensitive
2016-07-02 05:54:53 +02:00
setMenu()
updateTextCount()
}
else -> {
val intent = item.intent
if (intent != null) {
try {
val action = intent.action
if (INTENT_ACTION_EXTENSION_COMPOSE == action) {
2016-12-06 06:15:22 +01:00
val accountKeys = accountsAdapter.selectedAccountKeys
2016-07-02 05:54:53 +02:00
intent.putExtra(EXTRA_TEXT, ParseUtils.parseString(editText.text))
intent.putExtra(EXTRA_ACCOUNT_KEYS, accountKeys)
2016-12-06 06:15:22 +01:00
if (accountKeys.isNotEmpty()) {
val accountKey = accountKeys.first()
2016-07-02 05:54:53 +02:00
intent.putExtra(EXTRA_NAME, DataStoreUtils.getAccountName(this, accountKey))
intent.putExtra(EXTRA_SCREEN_NAME, DataStoreUtils.getAccountScreenName(this, accountKey))
}
2016-12-13 01:45:14 +01:00
inReplyToStatus?.let {
intent.putExtra(EXTRA_IN_REPLY_TO_ID, it.id)
intent.putExtra(EXTRA_IN_REPLY_TO_NAME, it.user_name)
intent.putExtra(EXTRA_IN_REPLY_TO_SCREEN_NAME, it.user_screen_name)
2016-07-02 05:54:53 +02:00
}
startActivityForResult(intent, REQUEST_EXTENSION_COMPOSE)
} else {
startActivity(intent)
}
} catch (e: ActivityNotFoundException) {
Log.w(LOGTAG, e)
return false
}
}
}
}
return true
}
override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
when (ev.actionMasked) {
MotionEvent.ACTION_DOWN -> {
val x = ev.rawX
val y = ev.rawY
2016-07-08 03:44:43 +02:00
if (isAccountSelectorVisible && !TwidereViewUtils.hitView(x, y, accountSelectorButton)) {
var clickedItem = false
val layoutManager = accountSelector.layoutManager
for (i in 0..layoutManager.childCount - 1) {
if (TwidereViewUtils.hitView(x, y, layoutManager.getChildAt(i))) {
clickedItem = true
break
2016-07-02 05:54:53 +02:00
}
}
2016-07-08 03:44:43 +02:00
if (!clickedItem) {
isAccountSelectorVisible = false
return true
}
2016-07-02 05:54:53 +02:00
}
}
}
return super.dispatchTouchEvent(ev)
}
override fun onTouchEvent(event: MotionEvent): Boolean {
if (event.action == MotionEvent.ACTION_DOWN) {
val x = event.rawX
val y = event.rawY
val window = window
if (!TwidereViewUtils.hitView(x, y, window.decorView)
&& window.peekDecorView() != null && !hasComposingStatus()) {
onBackPressed()
return true
}
}
return super.onTouchEvent(event)
}
override fun getMenuInflater(): MenuInflater {
2016-07-07 05:42:08 +02:00
return supportMenuInflater
2016-07-02 05:54:53 +02:00
}
fun removeAllMedia(list: List<ParcelableMediaUpdate>) {
2016-12-06 06:15:22 +01:00
mediaPreviewAdapter.removeAll(list)
2016-07-02 05:54:53 +02:00
}
2016-12-06 02:42:44 +01:00
fun saveToDrafts(): Uri {
2016-07-02 05:54:53 +02:00
val text = editText.text.toString()
val draft = Draft()
draft.unique_id = this.draftUniqueId ?: UUID.randomUUID().toString()
2016-07-02 05:54:53 +02:00
draft.action_type = getDraftAction(intent.action)
2016-12-06 06:15:22 +01:00
draft.account_keys = accountsAdapter.selectedAccountKeys
2016-07-02 05:54:53 +02:00
draft.text = text
draft.media = media
2016-07-07 05:42:08 +02:00
draft.location = recentLocation
draft.timestamp = System.currentTimeMillis()
draft.action_extras = UpdateStatusActionExtras().apply {
2016-12-05 12:28:17 +01:00
this.inReplyToStatus = this@ComposeActivity.inReplyToStatus
this.isPossiblySensitive = this@ComposeActivity.possiblySensitive
}
2016-07-02 05:54:53 +02:00
val values = DraftValuesCreator.create(draft)
val draftUri = contentResolver.insert(Drafts.CONTENT_URI, values)
displayNewDraftNotification(text, draftUri)
2016-12-06 02:42:44 +01:00
return draftUri
2016-07-02 05:54:53 +02:00
}
2016-12-04 04:58:03 +01:00
fun setSelectedAccounts(vararg accounts: AccountDetails) {
2016-07-02 05:54:53 +02:00
if (accounts.size == 1) {
2016-07-08 03:44:43 +02:00
accountsCount.setText(null)
2016-07-02 05:54:53 +02:00
val account = accounts[0]
2016-12-04 04:58:03 +01:00
mediaLoader.displayProfileImage(accountProfileImage, account.user)
2016-07-08 03:44:43 +02:00
accountProfileImage.setBorderColor(account.color)
2016-07-02 05:54:53 +02:00
} else {
2016-07-08 03:44:43 +02:00
accountsCount.setText(accounts.size.toString())
2016-07-02 05:54:53 +02:00
mediaLoader.cancelDisplayTask(accountProfileImage)
2016-07-08 03:44:43 +02:00
accountProfileImage.setImageDrawable(null)
accountProfileImage.setBorderColors(*Utils.getAccountColors(accounts))
2016-07-02 05:54:53 +02:00
}
}
override fun onActionModeStarted(mode: ActionMode) {
super.onActionModeStarted(mode)
ThemeUtils.applyColorFilterToMenuIcon(mode.menu, ThemeUtils.getContrastActionBarItemColor(this),
0, 0, Mode.MULTIPLY)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
GeneralComponentHelper.build(this).inject(this)
2016-12-15 02:33:47 +01:00
nameFirst = preferences[nameFirstKey]
2016-07-02 05:54:53 +02:00
setContentView(R.layout.activity_compose)
2017-02-14 13:32:15 +01:00
mediaPreviewAdapter = MediaPreviewAdapter(this)
mediaPreviewAdapter.listener = object : MediaPreviewAdapter.Listener {
override fun onEditClick(position: Int, holder: MediaPreviewViewHolder) {
attachedMediaPreview.showContextMenuForChild(holder.itemView)
}
override fun onRemoveClick(position: Int, holder: MediaPreviewViewHolder) {
mediaPreviewAdapter.remove(position)
updateAttachedMediaView()
}
override fun onStartDrag(viewHolder: ViewHolder) {
itemTouchHelper.startDrag(viewHolder)
}
}
itemTouchHelper = ItemTouchHelper(AttachedMediaItemTouchHelperCallback(mediaPreviewAdapter.touchAdapter))
2016-07-02 05:54:53 +02:00
setFinishOnTouchOutside(false)
2016-12-15 02:33:47 +01:00
val am = AccountManager.get(this)
val accounts = AccountUtils.getAccounts(am)
2016-12-03 06:48:40 +01:00
if (accounts.isEmpty()) {
2017-01-26 14:28:43 +01:00
Toast.makeText(this, R.string.message_toast_no_account, Toast.LENGTH_SHORT).show()
shouldSkipDraft = true
2016-07-02 05:54:53 +02:00
finish()
return
}
2016-12-15 06:11:32 +01:00
val accountDetails = AccountUtils.getAllAccountDetails(am, accounts, true)
2016-12-15 02:33:47 +01:00
val defaultAccountIds = accountDetails.map(AccountDetails::key).toTypedArray()
2016-07-08 03:44:43 +02:00
menuBar.setOnMenuItemClickListener(this)
2016-07-02 05:54:53 +02:00
setupEditText()
2016-07-08 03:44:43 +02:00
accountSelectorContainer.setOnClickListener(this)
accountSelectorButton.setOnClickListener(this)
2016-07-02 05:54:53 +02:00
replyLabel.setOnClickListener(this)
2016-07-08 03:44:43 +02:00
locationSwitch.max = LOCATION_OPTIONS.size
2017-01-21 05:08:47 +01:00
val attachLocation = kPreferences[attachLocationKey]
val attachPreciseLocation = kPreferences[attachPreciseLocationKey]
2016-07-02 05:54:53 +02:00
if (attachLocation) {
if (attachPreciseLocation) {
2016-08-17 15:46:18 +02:00
locationSwitch.checkedPosition = LOCATION_OPTIONS.indexOf(LOCATION_VALUE_COORDINATE)
2016-07-02 05:54:53 +02:00
} else {
2016-08-17 15:46:18 +02:00
locationSwitch.checkedPosition = LOCATION_OPTIONS.indexOf(LOCATION_VALUE_PLACE)
2016-07-02 05:54:53 +02:00
}
} else {
2016-08-17 15:46:18 +02:00
locationSwitch.checkedPosition = LOCATION_OPTIONS.indexOf(LOCATION_VALUE_NONE)
2016-07-02 05:54:53 +02:00
}
2016-07-08 03:44:43 +02:00
locationSwitch.setOnCheckedChangeListener {
val value = LOCATION_OPTIONS[locationSwitch.checkedPosition]
2016-07-02 05:54:53 +02:00
var attachLocationChecked = false
var attachPreciseLocationChecked = false
when (value) {
LOCATION_VALUE_COORDINATE -> {
attachLocationChecked = true
attachPreciseLocationChecked = true
2016-12-13 01:45:14 +01:00
locationText.tag = null
2016-07-02 05:54:53 +02:00
}
LOCATION_VALUE_PLACE -> {
attachLocationChecked = true
attachPreciseLocationChecked = false
}
}
2017-01-21 05:08:47 +01:00
kPreferences.edit {
this[attachLocationKey] = attachLocationChecked
this[attachPreciseLocationKey] = attachPreciseLocationChecked
}
2016-07-02 05:54:53 +02:00
if (attachLocationChecked) {
requestOrUpdateLocation()
} else if (locationListener != null) {
2016-07-02 05:54:53 +02:00
try {
2016-12-13 01:45:14 +01:00
locationManager.removeUpdates(locationListener)
locationListener = null
2016-07-02 05:54:53 +02:00
} catch (e: SecurityException) {
//Ignore
}
}
updateLocationState()
setMenu()
updateTextCount()
}
accountSelector.layoutManager = FixedLinearLayoutManager(this).apply {
orientation = LinearLayoutManager.VERTICAL
stackFromEnd = true
}
2016-07-08 03:44:43 +02:00
accountSelector.itemAnimator = DefaultItemAnimator()
accountsAdapter = AccountIconsAdapter(this).apply {
2016-12-15 02:33:47 +01:00
setAccounts(accountDetails)
}
2016-07-08 03:44:43 +02:00
accountSelector.adapter = accountsAdapter
2016-07-02 05:54:53 +02:00
2017-02-14 13:32:15 +01:00
attachedMediaPreview.layoutManager = LinearLayoutManager(this, LinearLayoutManager.HORIZONTAL, false)
2016-07-07 05:42:08 +02:00
attachedMediaPreview.adapter = mediaPreviewAdapter
2016-07-02 05:54:53 +02:00
registerForContextMenu(attachedMediaPreview)
itemTouchHelper.attachToRecyclerView(attachedMediaPreview)
2017-02-14 13:32:15 +01:00
attachedMediaPreview.addItemDecoration(PreviewGridItemDecoration(resources.getDimensionPixelSize(R.dimen.element_spacing_small)))
2016-07-02 05:54:53 +02:00
if (savedInstanceState != null) {
// Restore from previous saved state
2017-02-02 16:50:30 +01:00
val selected = savedInstanceState.getTypedArray(EXTRA_ACCOUNT_KEYS, UserKey.CREATOR)
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(*selected)
2016-07-04 03:31:17 +02:00
possiblySensitive = savedInstanceState.getBoolean(EXTRA_IS_POSSIBLY_SENSITIVE)
2016-07-02 05:54:53 +02:00
val mediaList = savedInstanceState.getParcelableArrayList<ParcelableMediaUpdate>(EXTRA_MEDIA)
if (mediaList != null) {
addMedia(mediaList)
}
inReplyToStatus = savedInstanceState.getParcelable(EXTRA_STATUS)
mentionUser = savedInstanceState.getParcelable(EXTRA_USER)
draft = savedInstanceState.getParcelable(EXTRA_DRAFT)
2016-07-04 03:31:17 +02:00
shouldSaveAccounts = savedInstanceState.getBoolean(EXTRA_SHOULD_SAVE_ACCOUNTS)
2016-07-08 03:44:43 +02:00
originalText = savedInstanceState.getString(EXTRA_ORIGINAL_TEXT)
draftUniqueId = savedInstanceState.getString(EXTRA_DRAFT_UNIQUE_ID)
2016-07-02 05:54:53 +02:00
setLabel(intent)
} else {
// The context was first created
val notificationId = intent.getIntExtra(EXTRA_NOTIFICATION_ID, -1)
val notificationAccount = intent.getParcelableExtra<UserKey>(EXTRA_NOTIFICATION_ACCOUNT)
if (notificationId != -1) {
twitterWrapper.clearNotificationAsync(notificationId, notificationAccount)
}
if (!handleIntent(intent)) {
handleDefaultIntent(intent)
}
setLabel(intent)
2016-12-06 06:15:22 +01:00
val selectedAccountIds = accountsAdapter.selectedAccountKeys
2016-07-02 05:54:53 +02:00
if (ArrayUtils.isEmpty(selectedAccountIds)) {
2017-01-21 05:08:47 +01:00
val idsInPrefs: Array<UserKey> = kPreferences[composeAccountsKey] ?: emptyArray()
2016-07-02 05:54:53 +02:00
val intersection: Array<UserKey> = defaultAccountIds.intersect(listOf(*idsInPrefs)).toTypedArray()
if (intersection.isEmpty()) {
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(*defaultAccountIds)
2016-07-02 05:54:53 +02:00
} else {
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(*intersection)
2016-07-02 05:54:53 +02:00
}
}
2016-07-08 03:44:43 +02:00
originalText = ParseUtils.parseString(editText.text)
2016-07-02 05:54:53 +02:00
}
2016-07-08 03:44:43 +02:00
val menu = menuBar.menu
2016-07-07 05:42:08 +02:00
supportMenuInflater.inflate(R.menu.menu_compose, menu)
2016-07-02 05:54:53 +02:00
ThemeUtils.wrapMenuIcon(menuBar)
2016-07-08 03:44:43 +02:00
updateStatus.setOnClickListener(this)
updateStatus.setOnLongClickListener(this)
2016-07-02 05:54:53 +02:00
val composeExtensionsIntent = Intent(INTENT_ACTION_EXTENSION_COMPOSE)
MenuUtils.addIntentToMenu(this, menu, composeExtensionsIntent, MENU_GROUP_COMPOSE_EXTENSION)
val imageExtensionsIntent = Intent(INTENT_ACTION_EXTENSION_EDIT_IMAGE)
val mediaMenuItem = menu.findItem(R.id.media_menu)
if (mediaMenuItem != null && mediaMenuItem.hasSubMenu()) {
MenuUtils.addIntentToMenu(this, mediaMenuItem.subMenu, imageExtensionsIntent, MENU_GROUP_IMAGE_EXTENSION)
}
2017-01-07 15:45:33 +01:00
updateViewStyle()
2016-07-02 05:54:53 +02:00
setMenu()
updateLocationState()
notifyAccountSelectionChanged()
2016-07-05 15:19:51 +02:00
textChanged = false
2016-07-02 05:54:53 +02:00
updateAttachedMediaView()
}
2017-01-07 15:45:33 +01:00
private fun updateViewStyle() {
accountProfileImage.style = preferences[profileImageStyleKey]
}
2016-07-02 05:54:53 +02:00
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
val keyCode = event.keyCode
if (KeyEvent.isModifierKey(keyCode)) {
val action = event.action
if (action == MotionEvent.ACTION_DOWN) {
2016-07-08 03:44:43 +02:00
composeKeyMetaState = composeKeyMetaState or KeyboardShortcutsHandler.getMetaStateForKeyCode(keyCode)
2016-07-02 05:54:53 +02:00
} else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
2016-07-08 03:44:43 +02:00
composeKeyMetaState = composeKeyMetaState and KeyboardShortcutsHandler.getMetaStateForKeyCode(keyCode).inv()
2016-07-02 05:54:53 +02:00
}
}
return super.dispatchKeyEvent(event)
}
override fun onCreateContextMenu(menu: ContextMenu, v: View, menuInfo: ContextMenu.ContextMenuInfo) {
2017-02-16 07:50:25 +01:00
if (menuInfo !is ExtendedRecyclerView.ContextMenuInfo) return
when (menuInfo.recyclerViewId) {
R.id.attachedMediaPreview -> {
menu.setHeaderTitle(R.string.edit_media)
supportMenuInflater.inflate(R.menu.menu_attached_media_edit, menu)
}
2016-07-02 05:54:53 +02:00
}
}
override fun onContextItemSelected(item: MenuItem): Boolean {
2017-02-16 07:50:25 +01:00
val menuInfo = item.menuInfo as? ExtendedRecyclerView.ContextMenuInfo ?: run {
return super.onContextItemSelected(item)
}
when (menuInfo.recyclerViewId) {
R.id.attachedMediaPreview -> {
when (item.itemId) {
R.id.edit_description -> {
val position = menuInfo.position
val altText = mediaPreviewAdapter.getItem(position).alt_text
executeAfterFragmentResumed { activity ->
EditAltTextDialogFragment.show(activity.supportFragmentManager, position,
altText)
}
2017-02-15 06:53:53 +01:00
}
2016-07-02 05:54:53 +02:00
}
2017-02-16 07:50:25 +01:00
return true
2016-07-02 05:54:53 +02:00
}
}
return super.onContextItemSelected(item)
}
private fun setupEditText() {
val sendByEnter = preferences.getBoolean(KEY_QUICK_SEND)
EditTextEnterHandler.attach(editText, ComposeEnterListener(this), sendByEnter)
editText.addTextChangedListener(object : TextWatcher {
override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {
}
override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
setMenu()
updateTextCount()
if (s is Spannable && count == 1 && before == 0) {
val imageSpans = s.getSpans(start, start + count, ImageSpan::class.java)
val imageSources = ArrayList<String>()
for (imageSpan in imageSpans) {
imageSources.add(imageSpan.source)
s.setSpan(MarkForDeleteSpan(), start, start + count,
Spanned.SPAN_INCLUSIVE_INCLUSIVE)
}
if (!imageSources.isEmpty()) {
2017-01-22 18:13:31 +01:00
val intent = ThemedMediaPickerActivity.withThemed(this@ComposeActivity)
.getMedia(Uri.parse(imageSources[0]))
.build()
startActivityForResult(intent, REQUEST_PICK_MEDIA)
2016-07-02 05:54:53 +02:00
}
}
}
override fun afterTextChanged(s: Editable) {
2016-12-06 06:15:22 +01:00
textChanged = s.isEmpty()
2016-07-02 05:54:53 +02:00
val deletes = s.getSpans(0, s.length, MarkForDeleteSpan::class.java)
for (delete in deletes) {
s.delete(s.getSpanStart(delete), s.getSpanEnd(delete))
s.removeSpan(delete)
}
for (span in s.getSpans(0, s.length, UpdateAppearance::class.java)) {
trimSpans(s, span)
}
}
private fun trimSpans(s: Editable, span: Any) {
if (span is EmojiSpan) return
if (span is SuggestionSpan) return
s.removeSpan(span)
}
})
editText.customSelectionActionModeCallback = this
}
override fun handleKeyboardShortcutSingle(handler: KeyboardShortcutsHandler, keyCode: Int, event: KeyEvent, metaState: Int): Boolean {
val action = handler.getKeyAction(KeyboardShortcutConstants.CONTEXT_TAG_NAVIGATION, keyCode, event, metaState)
if (KeyboardShortcutConstants.ACTION_NAVIGATION_BACK == action) {
2016-07-05 15:19:51 +02:00
if (editText.length() == 0 && !textChanged) {
2016-07-08 03:44:43 +02:00
if (!navigateBackPressed) {
2017-01-26 14:28:43 +01:00
Toast.makeText(this, getString(R.string.message_toast_press_again_to_close), Toast.LENGTH_SHORT).show()
2016-07-07 05:42:08 +02:00
editText.removeCallbacks(backTimeoutRunnable)
editText.postDelayed(backTimeoutRunnable, 2000)
2016-07-02 05:54:53 +02:00
} else {
onBackPressed()
}
2016-07-08 03:44:43 +02:00
navigateBackPressed = true
2016-07-02 05:54:53 +02:00
} else {
2016-07-05 15:19:51 +02:00
textChanged = false
2016-07-02 05:54:53 +02:00
}
return true
}
return super.handleKeyboardShortcutSingle(handler, keyCode, event, metaState)
}
override fun handleKeyboardShortcutRepeat(handler: KeyboardShortcutsHandler, keyCode: Int,
repeatCount: Int, event: KeyEvent, metaState: Int): Boolean {
2016-07-02 05:54:53 +02:00
return super.handleKeyboardShortcutRepeat(handler, keyCode, repeatCount, event, metaState)
}
private fun addMedia(media: List<ParcelableMediaUpdate>) {
2016-12-06 06:15:22 +01:00
mediaPreviewAdapter.addAll(media)
2016-07-02 05:54:53 +02:00
updateAttachedMediaView()
}
private fun clearMedia() {
2016-12-06 06:15:22 +01:00
mediaPreviewAdapter.clear()
2016-07-02 05:54:53 +02:00
updateAttachedMediaView()
}
private fun updateAttachedMediaView() {
val hasMedia = hasMedia()
attachedMediaPreview.visibility = if (hasMedia) View.VISIBLE else View.GONE
if (hasMedia) {
editText.minLines = resources.getInteger(R.integer.media_compose_min_lines)
} else {
editText.minLines = resources.getInteger(R.integer.default_compose_min_lines)
}
setMenu()
}
private fun displayNewDraftNotification(text: String, draftUri: Uri) {
val values = ContentValues()
values.put(BaseColumns._ID, draftUri.lastPathSegment)
contentResolver.insert(Drafts.CONTENT_URI_NOTIFICATIONS, values)
}
private val media: Array<ParcelableMediaUpdate>
2016-09-09 05:58:26 +02:00
get() = mediaList.toTypedArray()
2016-07-02 05:54:53 +02:00
private val mediaList: List<ParcelableMediaUpdate>
2017-01-22 19:20:10 +01:00
get() = mediaPreviewAdapter.asList()
2016-07-02 05:54:53 +02:00
private fun handleDefaultIntent(intent: Intent?): Boolean {
if (intent == null) return false
val action = intent.action
val hasAccountIds: Boolean
if (intent.hasExtra(EXTRA_ACCOUNT_KEYS)) {
2016-08-30 14:23:59 +02:00
val accountKeys = intent.getParcelableArrayExtra(EXTRA_ACCOUNT_KEYS).toTypedArray(UserKey.CREATOR)
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(*accountKeys)
2016-07-02 05:54:53 +02:00
hasAccountIds = true
} else if (intent.hasExtra(EXTRA_ACCOUNT_KEY)) {
val accountKey = intent.getParcelableExtra<UserKey>(EXTRA_ACCOUNT_KEY)
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(accountKey)
2016-07-02 05:54:53 +02:00
hasAccountIds = true
} else {
hasAccountIds = false
}
if (Intent.ACTION_SEND == action) {
2016-07-04 03:31:17 +02:00
shouldSaveAccounts = false
2016-07-02 05:54:53 +02:00
val stream = intent.getParcelableExtra<Uri>(Intent.EXTRA_STREAM)
if (stream != null) {
val src = arrayOf(stream)
2017-02-15 06:32:45 +01:00
TaskStarter.execute(AddMediaTask(this, src, true, false))
2016-07-02 05:54:53 +02:00
}
} else if (Intent.ACTION_SEND_MULTIPLE == action) {
2016-07-04 03:31:17 +02:00
shouldSaveAccounts = false
2016-07-02 05:54:53 +02:00
val extraStream = intent.getParcelableArrayListExtra<Uri>(Intent.EXTRA_STREAM)
if (extraStream != null) {
val src = extraStream.toTypedArray()
2017-02-15 06:32:45 +01:00
TaskStarter.execute(AddMediaTask(this, src, true, false))
2016-07-02 05:54:53 +02:00
}
} else {
2016-07-04 03:31:17 +02:00
shouldSaveAccounts = !hasAccountIds
2016-07-02 05:54:53 +02:00
val data = intent.data
if (data != null) {
val src = arrayOf(data)
2017-02-15 06:32:45 +01:00
TaskStarter.execute(AddMediaTask(this, src, true, false))
2016-07-02 05:54:53 +02:00
}
}
val extraSubject = intent.getCharSequenceExtra(Intent.EXTRA_SUBJECT)
val extraText = intent.getCharSequenceExtra(Intent.EXTRA_TEXT)
editText.setText(Utils.getShareStatus(this, extraSubject, extraText))
val selectionEnd = editText.length()
editText.setSelection(selectionEnd)
return true
}
private fun handleEditDraftIntent(draft: Draft?): Boolean {
if (draft == null) return false
draftUniqueId = draft.unique_id_non_null
2016-07-02 05:54:53 +02:00
editText.setText(draft.text)
val selectionEnd = editText.length()
editText.setSelection(selectionEnd)
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(*draft.account_keys ?: emptyArray())
2016-07-02 05:54:53 +02:00
if (draft.media != null) {
addMedia(Arrays.asList(*draft.media))
}
2016-07-07 05:42:08 +02:00
recentLocation = draft.location
2016-12-13 01:45:14 +01:00
(draft.action_extras as? UpdateStatusActionExtras)?.let {
possiblySensitive = it.isPossiblySensitive
inReplyToStatus = it.inReplyToStatus
2016-07-02 05:54:53 +02:00
}
val tag = Uri.withAppendedPath(Drafts.CONTENT_URI, draft._id.toString()).toString()
notificationManager.cancel(tag, TwidereConstants.NOTIFICATION_ID_DRAFTS)
2016-07-02 05:54:53 +02:00
return true
}
private fun setLabel(intent: Intent): Boolean {
val action = intent.action
if (action == null) {
hideLabel()
return false
}
when (action) {
INTENT_ACTION_REPLY -> {
showReplyLabel(intent.getParcelableExtra<ParcelableStatus>(EXTRA_STATUS))
return true
}
INTENT_ACTION_QUOTE -> {
showQuoteLabel(intent.getParcelableExtra<ParcelableStatus>(EXTRA_STATUS))
return true
}
INTENT_ACTION_EDIT_DRAFT -> {
val draft = intent.getParcelableExtra<Draft>(EXTRA_DRAFT)
if (draft == null) {
hideLabel()
return false
}
if (draft.action_type == null) {
draft.action_type = Draft.Action.UPDATE_STATUS
}
when (draft.action_type) {
Draft.Action.REPLY -> {
if (draft.action_extras is UpdateStatusActionExtras) {
showReplyLabel((draft.action_extras as UpdateStatusActionExtras).inReplyToStatus)
2016-07-02 05:54:53 +02:00
} else {
hideLabel()
return false
}
}
Draft.Action.QUOTE -> {
if (draft.action_extras is UpdateStatusActionExtras) {
showQuoteLabel((draft.action_extras as UpdateStatusActionExtras).inReplyToStatus)
2016-07-02 05:54:53 +02:00
} else {
hideLabel()
return false
}
}
else -> {
hideLabel()
return false
}
}
return true
}
}
hideLabel()
return false
}
private fun handleIntent(intent: Intent): Boolean {
val action = intent.action ?: return false
2016-07-04 03:31:17 +02:00
shouldSaveAccounts = false
2016-12-13 04:06:07 +01:00
mentionUser = intent.getParcelableExtra(EXTRA_USER)
inReplyToStatus = intent.getParcelableExtra(EXTRA_STATUS)
2016-07-02 05:54:53 +02:00
when (action) {
INTENT_ACTION_REPLY -> {
2016-07-08 03:44:43 +02:00
return handleReplyIntent(inReplyToStatus)
2016-07-02 05:54:53 +02:00
}
INTENT_ACTION_QUOTE -> {
2016-07-08 03:44:43 +02:00
return handleQuoteIntent(inReplyToStatus)
2016-07-02 05:54:53 +02:00
}
INTENT_ACTION_EDIT_DRAFT -> {
2016-12-13 04:06:07 +01:00
draft = intent.getParcelableExtra(EXTRA_DRAFT)
2016-07-08 03:44:43 +02:00
return handleEditDraftIntent(draft)
2016-07-02 05:54:53 +02:00
}
INTENT_ACTION_MENTION -> {
2016-07-08 03:44:43 +02:00
return handleMentionIntent(mentionUser)
2016-07-02 05:54:53 +02:00
}
INTENT_ACTION_REPLY_MULTIPLE -> {
val screenNames = intent.getStringArrayExtra(EXTRA_SCREEN_NAMES)
val accountKey = intent.getParcelableExtra<UserKey>(EXTRA_ACCOUNT_KEYS)
val inReplyToStatus = intent.getParcelableExtra<ParcelableStatus>(EXTRA_IN_REPLY_TO_STATUS)
return handleReplyMultipleIntent(screenNames, accountKey, inReplyToStatus)
}
INTENT_ACTION_COMPOSE_TAKE_PHOTO -> {
2017-01-23 16:24:58 +01:00
requestOrOpenCamera()
2017-01-22 18:13:31 +01:00
return true
2016-07-02 05:54:53 +02:00
}
INTENT_ACTION_COMPOSE_PICK_IMAGE -> {
2017-01-22 18:13:31 +01:00
requestOrPickMedia()
return true
2016-07-02 05:54:53 +02:00
}
}
// Unknown action or no intent extras
return false
}
private fun handleMentionIntent(user: ParcelableUser?): Boolean {
if (user == null || user.key == null) return false
val accountScreenName = DataStoreUtils.getAccountScreenName(this, user.account_key)
if (TextUtils.isEmpty(accountScreenName)) return false
editText.setText(String.format("@%s ", user.screen_name))
val selection_end = editText.length()
editText.setSelection(selection_end)
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(user.account_key)
2016-07-02 05:54:53 +02:00
return true
}
private fun handleQuoteIntent(status: ParcelableStatus?): Boolean {
if (status == null) return false
editText.setText(Utils.getQuoteStatus(this, status))
editText.setSelection(0)
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(status.account_key)
2016-07-02 05:54:53 +02:00
showQuoteLabel(status)
return true
}
private fun showQuoteLabel(status: ParcelableStatus?) {
if (status == null) {
hideLabel()
return
}
val replyToName = userColorNameManager.getDisplayName(status, nameFirst)
2016-07-02 05:54:53 +02:00
replyLabel.text = getString(R.string.quote_name_text, replyToName, status.text_unescaped)
replyLabel.visibility = View.VISIBLE
2016-12-13 01:45:14 +01:00
replyLabelDivider.visibility = View.VISIBLE
2016-07-02 05:54:53 +02:00
}
private fun showReplyLabel(status: ParcelableStatus?) {
if (status == null) {
hideLabel()
return
}
val replyToName = userColorNameManager.getDisplayName(status, nameFirst)
2016-07-02 05:54:53 +02:00
replyLabel.text = getString(R.string.reply_to_name_text, replyToName, status.text_unescaped)
replyLabel.visibility = View.VISIBLE
2016-12-13 01:45:14 +01:00
replyLabelDivider.visibility = View.VISIBLE
2016-07-02 05:54:53 +02:00
}
private fun hideLabel() {
replyLabel.visibility = View.GONE
2016-12-13 01:45:14 +01:00
replyLabelDivider.visibility = View.GONE
2016-07-02 05:54:53 +02:00
}
private fun handleReplyIntent(status: ParcelableStatus?): Boolean {
if (status == null) return false
2016-12-15 06:11:32 +01:00
val am = AccountManager.get(this)
val accountUser = AccountUtils.findByAccountKey(am, status.account_key)?.getAccountUser(am) ?: return false
2016-07-02 05:54:53 +02:00
var selectionStart = 0
val mentions = TreeSet(String.CASE_INSENSITIVE_ORDER)
editText.append("@" + status.user_screen_name + " ")
// If replying status from current user, just exclude it's screen name from selection.
if (status.account_key != status.user_key) {
selectionStart = editText.length()
}
if (status.is_retweet && !TextUtils.isEmpty(status.retweeted_by_user_screen_name)) {
mentions.add(status.retweeted_by_user_screen_name)
}
if (status.is_quote && !TextUtils.isEmpty(status.quoted_user_screen_name)) {
mentions.add(status.quoted_user_screen_name)
}
if (!ArrayUtils.isEmpty(status.mentions)) {
2016-12-06 06:15:22 +01:00
status.mentions
.filterNot { it.key == status.account_key || it.screen_name.isNullOrEmpty() }
.mapTo(mentions) { it.screen_name }
2016-07-04 03:31:17 +02:00
mentions.addAll(extractor.extractMentionedScreennames(status.quoted_text_plain))
2016-07-02 05:54:53 +02:00
} else if (USER_TYPE_FANFOU_COM == status.account_key.host) {
addFanfouHtmlToMentions(status.text_unescaped, status.spans, mentions)
if (status.is_quote) {
addFanfouHtmlToMentions(status.quoted_text_unescaped, status.quoted_spans, mentions)
}
} else {
2016-07-04 03:31:17 +02:00
mentions.addAll(extractor.extractMentionedScreennames(status.text_plain))
2016-07-02 05:54:53 +02:00
if (status.is_quote) {
2016-07-04 03:31:17 +02:00
mentions.addAll(extractor.extractMentionedScreennames(status.quoted_text_plain))
2016-07-02 05:54:53 +02:00
}
}
2016-12-18 03:04:02 +01:00
mentions.filterNot {
it.equals(status.user_screen_name, ignoreCase = true)
|| it.equals(accountUser.screen_name, ignoreCase = true)
}
2016-12-06 06:15:22 +01:00
.forEach { editText.append("@$it ") }
2016-07-02 05:54:53 +02:00
val selectionEnd = editText.length()
editText.setSelection(selectionStart, selectionEnd)
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(status.account_key)
2016-07-02 05:54:53 +02:00
showReplyLabel(status)
return true
}
private fun addFanfouHtmlToMentions(text: String, spans: Array<SpanItem>?, mentions: MutableCollection<String>) {
if (spans == null) return
for (span in spans) {
val start = span.start
val end = span.end
if (start <= 0 || end > text.length || start > end) continue
val ch = text[start - 1]
if (ch == '@' || ch == '\uff20') {
mentions.add(text.substring(start, end))
}
}
}
private fun handleReplyMultipleIntent(screenNames: Array<String>?, accountId: UserKey?,
inReplyToStatus: ParcelableStatus): Boolean {
2016-12-06 06:15:22 +01:00
if (screenNames == null || screenNames.isEmpty() || accountId == null) return false
2016-07-02 05:54:53 +02:00
val myScreenName = DataStoreUtils.getAccountScreenName(this, accountId)
if (TextUtils.isEmpty(myScreenName)) return false
2016-12-06 06:15:22 +01:00
screenNames.filterNot { it.equals(myScreenName, ignoreCase = true) }
.forEach { editText.append("@$it ") }
2016-07-02 05:54:53 +02:00
editText.setSelection(editText.length())
2016-12-06 06:15:22 +01:00
accountsAdapter.setSelectedAccountIds(accountId)
2016-07-08 03:44:43 +02:00
this.inReplyToStatus = inReplyToStatus
2016-07-02 05:54:53 +02:00
return true
}
private fun hasMedia(): Boolean {
2016-12-06 06:15:22 +01:00
return mediaPreviewAdapter.itemCount > 0
2016-07-02 05:54:53 +02:00
}
private val isQuote: Boolean
get() = INTENT_ACTION_QUOTE == intent.action
private val isQuotingProtectedStatus: Boolean
get() {
2016-07-08 03:44:43 +02:00
val status = inReplyToStatus
2016-07-02 05:54:53 +02:00
if (!isQuote || status == null) return false
return status.user_is_protected && status.account_key != status.user_key
}
private fun noReplyContent(text: String?): Boolean {
if (text == null) return true
val action = intent.action
val is_reply = INTENT_ACTION_REPLY == action || INTENT_ACTION_REPLY_MULTIPLE == action
2016-07-08 03:44:43 +02:00
return is_reply && text == originalText
2016-07-02 05:54:53 +02:00
}
private fun notifyAccountSelectionChanged() {
2016-12-06 06:15:22 +01:00
val accounts = accountsAdapter.selectedAccounts
2016-07-02 05:54:53 +02:00
setSelectedAccounts(*accounts)
if (ArrayUtils.isEmpty(accounts)) {
2016-08-28 06:24:48 +02:00
editText.accountKey = Utils.getDefaultAccountKey(this)
2016-07-02 05:54:53 +02:00
} else {
2016-12-04 04:58:03 +01:00
editText.accountKey = accounts[0].key
2016-07-02 05:54:53 +02:00
}
2017-02-28 08:34:00 +01:00
statusTextCount.maxLength = accounts.textLimit
2016-07-02 05:54:53 +02:00
setMenu()
}
2017-01-23 16:24:58 +01:00
private fun requestOrOpenCamera() {
2017-01-22 18:13:31 +01:00
if (checkAnySelfPermissionsGranted(AndroidPermission.WRITE_EXTERNAL_STORAGE)) {
2017-01-23 16:24:58 +01:00
openCamera()
2017-01-22 18:13:31 +01:00
return
}
ActivityCompat.requestPermissions(this, arrayOf(AndroidPermission.WRITE_EXTERNAL_STORAGE),
2017-01-23 16:24:58 +01:00
REQUEST_OPEN_CAMERA_PERMISSION)
2017-01-22 18:13:31 +01:00
}
2017-01-23 16:24:58 +01:00
private fun openCamera(): Boolean {
val builder = ThemedMediaPickerActivity.withThemed(this)
if (intent.action == INTENT_ACTION_COMPOSE_TAKE_PHOTO) {
builder.takePhoto()
} else {
builder.pickSources(arrayOf(MediaPickerActivity.SOURCE_CAMERA, MediaPickerActivity.SOURCE_CAMCORDER))
builder.containsVideo(true)
builder.videoOnly(false)
}
startActivityForResult(builder.build(), REQUEST_TAKE_PHOTO)
2017-01-22 18:13:31 +01:00
return true
}
private fun requestOrPickMedia() {
if (checkAnySelfPermissionsGranted(AndroidPermission.WRITE_EXTERNAL_STORAGE)) {
pickMedia()
return
}
ActivityCompat.requestPermissions(this, arrayOf(AndroidPermission.WRITE_EXTERNAL_STORAGE),
REQUEST_PICK_MEDIA_PERMISSION)
}
private fun pickMedia(): Boolean {
val intent = ThemedMediaPickerActivity.withThemed(this)
2017-01-23 16:24:58 +01:00
.pickMedia()
2017-01-22 18:13:31 +01:00
.containsVideo(true)
.videoOnly(false)
.allowMultiple(true)
.build()
startActivityForResult(intent, REQUEST_PICK_MEDIA)
2016-07-02 05:54:53 +02:00
return true
}
private fun saveAccountSelection() {
2016-07-04 03:31:17 +02:00
if (!shouldSaveAccounts) return
2016-07-02 05:54:53 +02:00
val editor = preferences.edit()
2016-08-17 15:46:18 +02:00
2016-12-06 06:15:22 +01:00
editor.putString(KEY_COMPOSE_ACCOUNTS, accountsAdapter.selectedAccountKeys.joinToString(","))
2016-07-02 05:54:53 +02:00
editor.apply()
}
private fun setMenu() {
if (menuBar == null) return
2016-07-08 03:44:43 +02:00
val menu = menuBar.menu
2016-07-02 05:54:53 +02:00
val hasMedia = hasMedia()
/*
* No media & Not reply: [Take photo][Add image][Attach location][Drafts]
* Has media & Not reply: [Take photo][Media menu][Attach location][Drafts]
* Is reply: [Media menu][View status][Attach location][Drafts]
*/
2016-07-04 03:31:17 +02:00
MenuUtils.setItemAvailability(menu, R.id.add_image, !hasMedia)
MenuUtils.setItemAvailability(menu, R.id.media_menu, hasMedia)
MenuUtils.setItemAvailability(menu, R.id.toggle_sensitive, hasMedia)
MenuUtils.setItemAvailability(menu, R.id.schedule, scheduleSupported)
2016-07-02 05:54:53 +02:00
menu.setGroupEnabled(MENU_GROUP_IMAGE_EXTENSION, hasMedia)
menu.setGroupVisible(MENU_GROUP_IMAGE_EXTENSION, hasMedia)
2016-07-04 03:31:17 +02:00
menu.setItemChecked(R.id.toggle_sensitive, hasMedia && possiblySensitive)
2016-07-02 05:54:53 +02:00
ThemeUtils.resetCheatSheet(menuBar)
// mMenuBar.show();
}
2016-07-04 03:31:17 +02:00
private val scheduleSupported: Boolean
2016-07-02 05:54:53 +02:00
get() {
2016-12-06 06:15:22 +01:00
val accounts = accountsAdapter.selectedAccounts
2016-07-02 05:54:53 +02:00
if (ArrayUtils.isEmpty(accounts)) return false
2016-12-04 04:58:03 +01:00
return false
2016-07-02 05:54:53 +02:00
}
private fun setProgressVisible(visible: Boolean) {
if (isFinishing) return
2016-07-07 09:39:32 +02:00
executeAfterFragmentResumed { activity ->
val composeActivity = activity as ComposeActivity
val fm = composeActivity.supportFragmentManager
val f = fm.findFragmentByTag(DISCARD_STATUS_DIALOG_FRAGMENT_TAG)
if (!visible && f is DialogFragment) {
f.dismiss()
} else if (visible) {
val df = ProgressDialogFragment()
df.show(fm, DISCARD_STATUS_DIALOG_FRAGMENT_TAG)
df.isCancelable = false
}
}
2016-07-02 05:54:53 +02:00
}
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
2016-12-13 04:06:07 +01:00
when (requestCode) {
REQUEST_ATTACH_LOCATION_PERMISSION -> {
if (checkAnySelfPermissionsGranted(AndroidPermission.ACCESS_FINE_LOCATION, AndroidPermission.ACCESS_COARSE_LOCATION)) {
try {
startLocationUpdateIfEnabled()
} catch (e: SecurityException) {
// That should not happen
}
} else {
2017-01-26 14:28:43 +01:00
Toast.makeText(this, R.string.message_toast_cannot_get_location, Toast.LENGTH_SHORT).show()
2016-12-13 04:06:07 +01:00
kPreferences.edit {
this[attachLocationKey] = false
this[attachPreciseLocationKey] = false
}
locationSwitch.checkedPosition = LOCATION_OPTIONS.indexOf(LOCATION_VALUE_NONE)
}
2016-07-02 05:54:53 +02:00
}
2017-01-23 16:24:58 +01:00
REQUEST_OPEN_CAMERA_PERMISSION -> {
2017-01-22 18:13:31 +01:00
if (!checkAnySelfPermissionsGranted(AndroidPermission.WRITE_EXTERNAL_STORAGE)) {
2017-01-26 14:28:43 +01:00
Toast.makeText(this, R.string.message_toast_compose_write_storage_no_permission, Toast.LENGTH_SHORT).show()
2017-01-22 18:13:31 +01:00
}
2017-01-23 16:24:58 +01:00
openCamera()
2017-01-22 18:13:31 +01:00
}
REQUEST_PICK_MEDIA_PERMISSION -> {
if (!checkAnySelfPermissionsGranted(AndroidPermission.WRITE_EXTERNAL_STORAGE)) {
2017-01-26 14:28:43 +01:00
Toast.makeText(this, R.string.message_toast_compose_write_storage_no_permission, Toast.LENGTH_SHORT).show()
2017-01-22 18:13:31 +01:00
}
pickMedia()
}
2016-12-13 04:06:07 +01:00
}
}
2016-07-02 05:54:53 +02:00
2016-12-13 04:06:07 +01:00
override fun onPermissionRequestCancelled(requestCode: Int) {
when (requestCode) {
REQUEST_ATTACH_LOCATION_PERMISSION -> {
locationSwitch.checkedPosition = LOCATION_OPTIONS.indexOf(LOCATION_VALUE_NONE)
}
2016-07-02 05:54:53 +02:00
}
}
private fun setRecentLocation(location: ParcelableLocation?) {
if (location != null) {
2016-12-13 04:06:07 +01:00
val attachPreciseLocation = kPreferences[attachPreciseLocationKey]
2016-07-02 05:54:53 +02:00
if (attachPreciseLocation) {
2016-12-13 01:45:14 +01:00
locationText.text = ParcelableLocationUtils.getHumanReadableString(location, 3)
2016-07-02 05:54:53 +02:00
} else {
2016-12-13 01:45:14 +01:00
if (locationText.tag == null || location != recentLocation) {
2016-07-02 05:54:53 +02:00
val task = DisplayPlaceNameTask(this)
2016-07-04 03:31:17 +02:00
task.params = location
2016-08-25 04:10:53 +02:00
task.callback = locationText
2016-07-02 05:54:53 +02:00
TaskStarter.execute(task)
}
}
} else {
2016-12-13 01:45:14 +01:00
locationText.setText(R.string.unknown_location)
2016-07-02 05:54:53 +02:00
}
2016-07-07 05:42:08 +02:00
recentLocation = location
2016-07-02 05:54:53 +02:00
}
/**
* The Location Manager manages location providers. This code searches for
* the best provider of data (GPS, WiFi/cell phone tower lookup, some other
* mechanism) and finds the last known location.
*/
@Throws(SecurityException::class)
private fun startLocationUpdateIfEnabled(): Boolean {
if (locationListener != null) return true
2016-12-13 04:06:07 +01:00
val attachLocation = kPreferences[attachLocationKey]
2016-07-02 05:54:53 +02:00
if (!attachLocation) {
return false
}
2016-12-13 04:06:07 +01:00
val attachPreciseLocation = kPreferences[attachPreciseLocationKey]
2016-07-02 05:54:53 +02:00
val criteria = Criteria()
if (attachPreciseLocation) {
criteria.accuracy = Criteria.ACCURACY_FINE
} else {
criteria.accuracy = Criteria.ACCURACY_COARSE
}
2016-12-13 01:45:14 +01:00
val provider = locationManager.getBestProvider(criteria, true)
2016-07-02 05:54:53 +02:00
if (provider != null) {
2016-12-13 01:45:14 +01:00
locationText.setText(R.string.getting_location)
locationListener = ComposeLocationListener(this)
2016-12-13 01:45:14 +01:00
locationManager.requestLocationUpdates(provider, 0, 0f, locationListener)
2016-07-02 05:54:53 +02:00
val location = Utils.getCachedLocation(this)
if (location != null) {
2016-12-13 01:45:14 +01:00
locationListener?.onLocationChanged(location)
2016-07-02 05:54:53 +02:00
}
} else {
2017-01-26 14:28:43 +01:00
Toast.makeText(this, R.string.message_toast_cannot_get_location, Toast.LENGTH_SHORT).show()
2016-07-02 05:54:53 +02:00
}
return provider != null
}
private fun requestOrUpdateLocation() {
2016-12-13 04:06:07 +01:00
if (checkAnySelfPermissionsGranted(AndroidPermission.ACCESS_COARSE_LOCATION, AndroidPermission.ACCESS_FINE_LOCATION)) {
2016-07-02 05:54:53 +02:00
try {
startLocationUpdateIfEnabled()
} catch (e: SecurityException) {
2017-01-26 14:28:43 +01:00
Toast.makeText(this, R.string.message_toast_cannot_get_location, Toast.LENGTH_SHORT).show()
2016-07-02 05:54:53 +02:00
}
} else {
2016-12-13 04:06:07 +01:00
val permissions = arrayOf(AndroidPermission.ACCESS_COARSE_LOCATION, AndroidPermission.ACCESS_FINE_LOCATION)
PermissionRequestDialog.show(supportFragmentManager, getString(R.string.message_permission_request_compose_location),
permissions, REQUEST_ATTACH_LOCATION_PERMISSION)
2016-07-02 05:54:53 +02:00
}
}
private fun updateLocationState() {
2016-12-13 04:06:07 +01:00
val attachLocation = kPreferences[attachLocationKey]
2016-12-13 01:45:14 +01:00
locationIcon.isActivated = attachLocation
2016-07-02 05:54:53 +02:00
if (!attachLocation) {
2016-12-13 01:45:14 +01:00
locationText.setText(R.string.no_location)
2016-07-07 05:42:08 +02:00
} else if (recentLocation != null) {
setRecentLocation(recentLocation)
2016-07-02 05:54:53 +02:00
} else {
2016-12-13 01:45:14 +01:00
locationText.setText(R.string.getting_location)
2016-07-02 05:54:53 +02:00
}
}
private fun updateStatus() {
2017-02-28 08:34:00 +01:00
if (isFinishing || editText == null) return
2016-07-02 05:54:53 +02:00
val hasMedia = hasMedia()
2017-02-28 08:34:00 +01:00
val text = editText.text.toString()
2016-07-07 09:39:32 +02:00
val tweetLength = validator.getTweetLength(text)
2016-07-02 05:54:53 +02:00
val maxLength = statusTextCount.maxLength
2016-12-06 06:15:22 +01:00
if (accountsAdapter.isSelectionEmpty) {
2017-01-26 14:28:43 +01:00
editText.error = getString(R.string.message_toast_no_account_selected)
2016-07-02 05:54:53 +02:00
return
} else if (!hasMedia && (TextUtils.isEmpty(text) || noReplyContent(text))) {
editText.error = getString(R.string.error_message_no_content)
return
2016-07-08 03:44:43 +02:00
} else if (maxLength > 0 && !statusShortenerUsed && tweetLength > maxLength) {
2016-07-02 05:54:53 +02:00
editText.error = getString(R.string.error_message_status_too_long)
val textLength = editText.length()
editText.setSelection(textLength - (tweetLength - maxLength), textLength)
return
}
2016-12-13 04:06:07 +01:00
val attachLocation = kPreferences[attachLocationKey]
val attachPreciseLocation = kPreferences[attachPreciseLocationKey]
2016-12-06 06:15:22 +01:00
val accountKeys = accountsAdapter.selectedAccountKeys
2016-07-04 03:31:17 +02:00
val isPossiblySensitive = hasMedia && possiblySensitive
2016-07-02 05:54:53 +02:00
val update = ParcelableStatusUpdate()
2016-12-05 12:28:17 +01:00
@Draft.Action val action = draft?.action_type ?: getDraftAction(intent.action)
2016-12-15 06:11:32 +01:00
update.accounts = AccountUtils.getAllAccountDetails(AccountManager.get(this), accountKeys, true)
2016-07-02 05:54:53 +02:00
update.text = text
if (attachLocation) {
2016-07-07 05:42:08 +02:00
update.location = recentLocation
2016-07-02 05:54:53 +02:00
update.display_coordinates = attachPreciseLocation
}
update.media = media
2016-07-08 03:44:43 +02:00
update.in_reply_to_status = inReplyToStatus
2016-07-02 05:54:53 +02:00
update.is_possibly_sensitive = isPossiblySensitive
update.attachment_url = (draft?.action_extras as? UpdateStatusActionExtras)?.attachmentUrl
2017-01-05 14:08:49 +01:00
LengthyOperationsService.updateStatusesAsync(this, action, update)
2016-12-13 04:06:07 +01:00
if (preferences[noCloseAfterTweetSentKey] && inReplyToStatus == null) {
2016-07-04 03:31:17 +02:00
possiblySensitive = false
shouldSaveAccounts = true
2016-07-08 03:44:43 +02:00
inReplyToStatus = null
mentionUser = null
draft = null
originalText = null
2016-07-02 05:54:53 +02:00
editText.text = null
clearMedia()
val intent = Intent(INTENT_ACTION_COMPOSE)
setIntent(intent)
handleIntent(intent)
setLabel(intent)
setMenu()
updateTextCount()
shouldSkipDraft = false
2016-07-02 05:54:53 +02:00
} else {
setResult(Activity.RESULT_OK)
shouldSkipDraft = true
2016-07-02 05:54:53 +02:00
finish()
}
}
private fun updateTextCount() {
2017-02-28 08:34:00 +01:00
val text = editText.text?.toString() ?: return
2016-09-09 05:58:26 +02:00
statusTextCount.textCount = validator.getTweetLength(text)
2016-07-02 05:54:53 +02:00
}
internal class ComposeLocationListener(activity: ComposeActivity) : LocationListener {
2017-02-28 08:34:00 +01:00
private val activityRef = WeakReference(activity)
2016-07-02 05:54:53 +02:00
override fun onLocationChanged(location: Location) {
2016-07-04 03:31:17 +02:00
val activity = activityRef.get() ?: return
2016-07-02 05:54:53 +02:00
activity.setRecentLocation(ParcelableLocationUtils.fromLocation(location))
}
override fun onStatusChanged(provider: String, status: Int, extras: Bundle) {
}
override fun onProviderEnabled(provider: String) {
}
override fun onProviderDisabled(provider: String) {
}
}
internal class AccountIconViewHolder(val adapter: AccountIconsAdapter, itemView: View) : ViewHolder(itemView), OnClickListener {
2017-02-28 08:34:00 +01:00
private val iconView = itemView.findViewById(android.R.id.icon) as ShapedImageView
private val nameView = itemView.findViewById(android.R.id.text1) as TextView
2016-07-02 05:54:53 +02:00
init {
itemView.setOnClickListener(this)
}
2016-12-04 04:58:03 +01:00
fun showAccount(adapter: AccountIconsAdapter, account: AccountDetails, isSelected: Boolean) {
2016-07-02 05:54:53 +02:00
itemView.alpha = if (isSelected) 1f else 0.33f
(itemView as CheckableLinearLayout).isChecked = isSelected
val loader = adapter.imageLoader
if (ObjectUtils.notEqual(account, iconView.tag) || iconView.drawable == null) {
iconView.tag = account
2016-12-04 04:58:03 +01:00
loader.displayProfileImage(iconView, account.user)
2016-07-02 05:54:53 +02:00
}
iconView.setBorderColor(account.color)
2016-12-04 04:58:03 +01:00
nameView.text = if (adapter.isNameFirst) account.user.name else "@" + account.user.screen_name
2016-07-02 05:54:53 +02:00
}
override fun onClick(v: View) {
(itemView as CheckableLinearLayout).toggle()
adapter.toggleSelection(layoutPosition)
}
}
2016-07-07 09:39:32 +02:00
internal class AccountIconsAdapter(private val activity: ComposeActivity) : BaseRecyclerViewAdapter<AccountIconViewHolder>(activity) {
2017-01-07 07:16:02 +01:00
private val inflater: LayoutInflater = activity.layoutInflater
private val selection: MutableMap<UserKey, Boolean> = HashMap()
val isNameFirst: Boolean = preferences[nameFirstKey]
2016-07-02 05:54:53 +02:00
2016-12-04 04:58:03 +01:00
private var accounts: Array<AccountDetails>? = null
2016-07-02 05:54:53 +02:00
init {
setHasStableIds(true)
}
val imageLoader: MediaLoaderWrapper
get() = mediaLoader
override fun getItemId(position: Int): Long {
2016-08-17 15:46:18 +02:00
return accounts!![position].hashCode().toLong()
2016-07-02 05:54:53 +02:00
}
val selectedAccountKeys: Array<UserKey>
get() {
2016-08-17 15:46:18 +02:00
val accounts = accounts ?: return emptyArray()
2016-12-04 04:58:03 +01:00
return accounts.filter { selection[it.key] ?: false }
.map { it.key }
2016-07-02 05:54:53 +02:00
.toTypedArray()
}
fun setSelectedAccountIds(vararg accountKeys: UserKey) {
2016-08-17 15:46:18 +02:00
selection.clear()
2016-07-02 05:54:53 +02:00
for (accountKey in accountKeys) {
2016-08-17 15:46:18 +02:00
selection.put(accountKey, true)
2016-07-02 05:54:53 +02:00
}
notifyDataSetChanged()
}
2016-12-04 04:58:03 +01:00
val selectedAccounts: Array<AccountDetails>
2016-07-02 05:54:53 +02:00
get() {
2016-08-17 15:46:18 +02:00
val accounts = accounts ?: return emptyArray()
2016-12-04 04:58:03 +01:00
return accounts.filter { selection[it.key] ?: false }.toTypedArray()
2016-07-02 05:54:53 +02:00
}
val isSelectionEmpty: Boolean
2016-12-03 06:48:40 +01:00
get() = selectedAccountKeys.isEmpty()
2016-07-02 05:54:53 +02:00
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): AccountIconViewHolder {
2017-01-07 07:16:02 +01:00
val view = inflater.inflate(R.layout.adapter_item_compose_account, parent, false)
2016-07-02 05:54:53 +02:00
return AccountIconViewHolder(this, view)
}
override fun onBindViewHolder(holder: AccountIconViewHolder, position: Int) {
2016-08-17 15:46:18 +02:00
val account = accounts!![position]
2016-12-04 04:58:03 +01:00
val isSelected = selection[account.key] ?: false
2016-07-02 05:54:53 +02:00
holder.showAccount(this, account, isSelected)
}
override fun getItemCount(): Int {
2016-08-17 15:46:18 +02:00
return if (accounts != null) accounts!!.size else 0
2016-07-02 05:54:53 +02:00
}
2016-12-04 04:58:03 +01:00
fun setAccounts(accounts: Array<AccountDetails>) {
2016-08-17 15:46:18 +02:00
this.accounts = accounts
2016-07-02 05:54:53 +02:00
notifyDataSetChanged()
}
internal fun toggleSelection(position: Int) {
2016-08-17 15:46:18 +02:00
if (accounts == null || position < 0) return
val account = accounts!![position]
2016-12-04 04:58:03 +01:00
selection.put(account.key, true != selection[account.key])
2016-07-07 09:39:32 +02:00
activity.notifyAccountSelectionChanged()
2016-07-02 05:54:53 +02:00
notifyDataSetChanged()
}
}
2017-01-22 19:20:10 +01:00
internal class AddMediaTask(
activity: ComposeActivity,
2017-02-14 13:32:15 +01:00
sources: Array<Uri>,
2017-02-15 06:32:45 +01:00
copySrc: Boolean,
2017-02-14 13:32:15 +01:00
deleteSrc: Boolean
2017-02-15 06:32:45 +01:00
) : AbsAddMediaTask<ComposeActivity>(activity, sources, copySrc, deleteSrc) {
2016-07-02 05:54:53 +02:00
2017-02-14 13:32:15 +01:00
init {
callback = activity
2016-07-02 05:54:53 +02:00
}
2017-02-14 13:32:15 +01:00
override fun afterExecute(activity: ComposeActivity?, result: List<ParcelableMediaUpdate>?) {
if (activity == null || result == null) return
2016-07-02 05:54:53 +02:00
activity.setProgressVisible(false)
2017-02-14 13:32:15 +01:00
activity.addMedia(result)
2016-07-02 05:54:53 +02:00
activity.setMenu()
activity.updateTextCount()
}
2017-02-14 13:32:15 +01:00
override fun beforeExecute() {
val activity = this.callback ?: return
2016-07-02 05:54:53 +02:00
activity.setProgressVisible(true)
}
2017-02-14 13:32:15 +01:00
2016-07-02 05:54:53 +02:00
}
2017-02-15 06:32:45 +01:00
internal class DeleteMediaTask(
activity: ComposeActivity,
val media: Array<ParcelableMediaUpdate>
) : AbsDeleteMediaTask<ComposeActivity>(activity, media.map { Uri.parse(it.uri) }.toTypedArray()) {
2016-07-02 05:54:53 +02:00
init {
2017-02-15 06:32:45 +01:00
this.callback = activity
2016-07-02 05:54:53 +02:00
}
2017-02-15 06:32:45 +01:00
override fun beforeExecute() {
callback?.setProgressVisible(true)
2016-07-02 05:54:53 +02:00
}
2017-02-15 06:32:45 +01:00
override fun afterExecute(callback: ComposeActivity?, result: BooleanArray?) {
if (callback == null || result == null) return
callback.setProgressVisible(false)
callback.removeAllMedia(media.filterIndexed { i, media -> result[i] })
callback.setMenu()
if (result.any { false }) {
Toast.makeText(callback, R.string.message_toast_error_occurred, Toast.LENGTH_SHORT).show()
2016-07-02 05:54:53 +02:00
}
}
}
internal class DiscardTweetTask(activity: ComposeActivity) : AsyncTask<Any, Any, Unit>() {
val activityRef: WeakReference<ComposeActivity>
private val media: List<ParcelableMediaUpdate>
init {
this.activityRef = WeakReference(activity)
this.media = activity.mediaList
}
2016-12-06 06:15:22 +01:00
override fun doInBackground(vararg params: Any) {
2017-01-26 16:15:05 +01:00
val activity = activityRef.get() ?: return
media.map { Uri.parse(it.uri) }.forEach { uri ->
Utils.deleteMedia(activity, uri)
2016-07-02 05:54:53 +02:00
}
}
override fun onPostExecute(result: Unit) {
val activity = activityRef.get() ?: return
activity.setProgressVisible(false)
activity.shouldSkipDraft = true
2016-07-02 05:54:53 +02:00
activity.finish()
}
override fun onPreExecute() {
val activity = activityRef.get() ?: return
activity.setProgressVisible(true)
}
}
2016-12-15 01:13:09 +01:00
internal class DisplayPlaceNameTask(
private val context: ComposeActivity
) : AbstractTask<ParcelableLocation, List<Address>, TextView>() {
2016-07-02 05:54:53 +02:00
override fun doLongOperation(location: ParcelableLocation): List<Address>? {
val gcd = Geocoder(context, Locale.getDefault())
try {
return gcd.getFromLocation(location.latitude, location.longitude, 1)
} catch (e: IOException) {
return null
}
}
override fun beforeExecute() {
val location = params
val textView = callback ?: return
val preferences = context.preferences
2016-12-13 04:06:07 +01:00
val attachLocation = preferences[attachLocationKey]
val attachPreciseLocation = preferences[attachPreciseLocationKey]
2016-07-02 05:54:53 +02:00
if (attachLocation) {
if (attachPreciseLocation) {
textView.text = ParcelableLocationUtils.getHumanReadableString(location, 3)
textView.tag = location
} else {
val tag = textView.tag
if (tag is Address) {
textView.text = tag.locality
} else if (tag is NoAddress) {
2017-01-26 14:28:43 +01:00
textView.setText(R.string.label_location_your_coarse_location)
2016-07-02 05:54:53 +02:00
} else {
textView.setText(R.string.getting_location)
}
}
} else {
textView.setText(R.string.no_location)
}
}
override fun afterExecute(textView: TextView?, addresses: List<Address>?) {
2016-12-13 01:45:14 +01:00
textView!!
2016-07-02 05:54:53 +02:00
val preferences = context.preferences
2016-12-13 04:06:07 +01:00
val attachLocation = preferences[attachLocationKey]
val attachPreciseLocation = preferences[attachPreciseLocationKey]
2016-07-02 05:54:53 +02:00
if (attachLocation) {
if (attachPreciseLocation) {
val location = params
2016-12-13 01:45:14 +01:00
textView.text = ParcelableLocationUtils.getHumanReadableString(location, 3)
2016-07-02 05:54:53 +02:00
textView.tag = location
} else if (addresses == null || addresses.isEmpty()) {
2016-12-13 01:45:14 +01:00
val tag = textView.tag
2016-07-02 05:54:53 +02:00
if (tag is Address) {
textView.text = tag.locality
} else {
2017-01-26 14:28:43 +01:00
textView.setText(R.string.label_location_your_coarse_location)
2016-07-02 05:54:53 +02:00
textView.tag = NoAddress()
}
} else {
val address = addresses[0]
2016-12-13 01:45:14 +01:00
textView.tag = address
2016-07-02 05:54:53 +02:00
textView.text = address.locality
}
} else {
2016-12-13 01:45:14 +01:00
textView.setText(R.string.no_location)
2016-07-02 05:54:53 +02:00
}
}
internal class NoAddress
}
2017-02-15 06:53:53 +01:00
override fun onSetAltText(position: Int, altText: String?) {
2016-12-06 06:15:22 +01:00
mediaPreviewAdapter.setAltText(position, altText)
2016-07-02 05:54:53 +02:00
}
class RetweetProtectedStatusWarnFragment : BaseDialogFragment(), DialogInterface.OnClickListener {
override fun onClick(dialog: DialogInterface, which: Int) {
val activity = activity
when (which) {
DialogInterface.BUTTON_POSITIVE -> {
if (activity is ComposeActivity) {
activity.updateStatus()
}
}
}
}
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
val context = activity
val builder = AlertDialog.Builder(context)
builder.setMessage(R.string.quote_protected_status_warning_message)
builder.setPositiveButton(R.string.send_anyway, this)
builder.setNegativeButton(android.R.string.cancel, null)
2017-02-05 14:42:20 +01:00
val dialog = builder.create()
dialog.setOnShowListener {
it as AlertDialog
it.applyTheme()
}
return dialog
2016-07-02 05:54:53 +02:00
}
}
class AttachedMediaItemTouchHelperCallback(adapter: SimpleItemTouchHelperCallback.ItemTouchHelperAdapter) : SimpleItemTouchHelperCallback(adapter) {
override fun isLongPressDragEnabled(): Boolean {
return true
}
override fun isItemViewSwipeEnabled(): Boolean {
return false
}
override fun getMovementFlags(recyclerView: RecyclerView, viewHolder: ViewHolder): Int {
// Set movement flags based on the layout manager
val dragFlags = ItemTouchHelper.START or ItemTouchHelper.END
val swipeFlags = ItemTouchHelper.UP or ItemTouchHelper.DOWN
return ItemTouchHelper.Callback.makeMovementFlags(dragFlags, swipeFlags)
}
override fun onChildDraw(c: Canvas, recyclerView: RecyclerView, viewHolder: ViewHolder, dX: Float, dY: Float, actionState: Int, isCurrentlyActive: Boolean) {
if (actionState == ItemTouchHelper.ACTION_STATE_SWIPE) {
// Fade out the view as it is swiped out of the parent's bounds
val alpha = ALPHA_FULL - Math.abs(dY) / viewHolder.itemView.height.toFloat()
viewHolder.itemView.alpha = alpha
super.onChildDraw(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive)
} else {
super.onChildDraw(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive)
}
}
override fun getSwipeThreshold(viewHolder: ViewHolder?): Float {
return 0.75f
}
override fun clearView(recyclerView: RecyclerView?, viewHolder: ViewHolder) {
super.clearView(recyclerView, viewHolder)
viewHolder.itemView.alpha = ALPHA_FULL
}
companion object {
val ALPHA_FULL = 1.0f
}
}
private class ComposeEnterListener(private val activity: ComposeActivity?) : EnterListener {
override fun shouldCallListener(): Boolean {
2016-07-08 03:44:43 +02:00
return activity != null && activity.composeKeyMetaState == 0
2016-07-02 05:54:53 +02:00
}
override fun onHitEnter(): Boolean {
if (activity == null) return false
activity.confirmAndUpdateStatus()
return true
}
}
companion object {
// Constants
private const val EXTRA_SHOULD_SAVE_ACCOUNTS = "should_save_accounts"
private const val EXTRA_ORIGINAL_TEXT = "original_text"
private const val EXTRA_DRAFT_UNIQUE_ID = "draft_unique_id"
private const val DISCARD_STATUS_DIALOG_FRAGMENT_TAG = "discard_status"
2016-07-02 05:54:53 +02:00
val LOCATION_VALUE_PLACE = "place"
val LOCATION_VALUE_COORDINATE = "coordinate"
val LOCATION_VALUE_NONE = "none"
private val LOCATION_OPTIONS = arrayOf(LOCATION_VALUE_NONE, LOCATION_VALUE_PLACE, LOCATION_VALUE_COORDINATE)
2016-12-13 04:06:07 +01:00
private const val REQUEST_ATTACH_LOCATION_PERMISSION = 301
2017-01-22 18:13:31 +01:00
private const val REQUEST_PICK_MEDIA_PERMISSION = 302
2017-01-23 16:24:58 +01:00
private const val REQUEST_OPEN_CAMERA_PERMISSION = 303
2016-12-13 04:06:07 +01:00
2016-07-02 05:54:53 +02:00
internal fun getDraftAction(intentAction: String?): String {
if (intentAction == null) {
return Draft.Action.UPDATE_STATUS
}
when (intentAction) {
INTENT_ACTION_REPLY -> {
return Draft.Action.REPLY
}
INTENT_ACTION_QUOTE -> {
return Draft.Action.QUOTE
}
}
return Draft.Action.UPDATE_STATUS
}
}
}