ChatRoomActivity.kt 6.23 KB
Newer Older
1 2
package chat.rocket.android.chatroom.ui

3
import DrawableHelper
4 5 6
import android.content.Context
import android.content.Intent
import android.os.Bundle
7 8
import androidx.fragment.app.Fragment
import androidx.appcompat.app.AppCompatActivity
9 10
import android.text.SpannableStringBuilder
import androidx.core.view.isVisible
11
import chat.rocket.android.R
12
import chat.rocket.android.chatroom.presentation.ChatRoomNavigator
13 14
import chat.rocket.android.server.domain.GetCurrentServerInteractor
import chat.rocket.android.server.infraestructure.ConnectionManagerFactory
15
import chat.rocket.android.util.extensions.addFragment
16
import chat.rocket.android.util.extensions.textContent
17
import chat.rocket.common.model.RoomType
Lucio Maciel's avatar
Lucio Maciel committed
18
import chat.rocket.common.model.roomTypeOf
19 20 21 22 23 24 25
import dagger.android.AndroidInjection
import dagger.android.AndroidInjector
import dagger.android.DispatchingAndroidInjector
import dagger.android.support.HasSupportFragmentInjector
import kotlinx.android.synthetic.main.app_bar_chat_room.*
import javax.inject.Inject

26 27 28 29 30 31
fun Context.chatRoomIntent(
    chatRoomId: String,
    chatRoomName: String,
    chatRoomType: String,
    isChatRoomReadOnly: Boolean,
    chatRoomLastSeen: Long,
32
    isChatRoomSubscribed: Boolean = true,
33
    isChatRoomCreator: Boolean = false,
34
    chatRoomMessage: String? = null
35
): Intent {
36 37 38 39
    return Intent(this, ChatRoomActivity::class.java).apply {
        putExtra(INTENT_CHAT_ROOM_ID, chatRoomId)
        putExtra(INTENT_CHAT_ROOM_NAME, chatRoomName)
        putExtra(INTENT_CHAT_ROOM_TYPE, chatRoomType)
40
        putExtra(INTENT_CHAT_ROOM_IS_READ_ONLY, isChatRoomReadOnly)
41
        putExtra(INTENT_CHAT_ROOM_LAST_SEEN, chatRoomLastSeen)
42
        putExtra(INTENT_CHAT_IS_SUBSCRIBED, isChatRoomSubscribed)
43
        putExtra(INTENT_CHAT_ROOM_IS_CREATOR, isChatRoomCreator)
44
        putExtra(INTENT_CHAT_ROOM_MESSAGE, chatRoomMessage)
45 46 47 48 49 50
    }
}

private const val INTENT_CHAT_ROOM_ID = "chat_room_id"
private const val INTENT_CHAT_ROOM_NAME = "chat_room_name"
private const val INTENT_CHAT_ROOM_TYPE = "chat_room_type"
51
private const val INTENT_CHAT_ROOM_IS_READ_ONLY = "chat_room_is_read_only"
52
private const val INTENT_CHAT_ROOM_IS_CREATOR = "chat_room_is_creator"
53
private const val INTENT_CHAT_ROOM_LAST_SEEN = "chat_room_last_seen"
54
private const val INTENT_CHAT_IS_SUBSCRIBED = "is_chat_room_subscribed"
55
private const val INTENT_CHAT_ROOM_MESSAGE = "chat_room_message"
56

57
class ChatRoomActivity : AppCompatActivity(), HasSupportFragmentInjector {
58 59
    @Inject
    lateinit var fragmentDispatchingAndroidInjector: DispatchingAndroidInjector<Fragment>
60 61

    // TODO - workaround for now... We will move to a single activity
62 63 64 65 66 67
    @Inject
    lateinit var serverInteractor: GetCurrentServerInteractor
    @Inject
    lateinit var navigator: ChatRoomNavigator
    @Inject
    lateinit var managerFactory: ConnectionManagerFactory
68 69

    override fun onCreate(savedInstanceState: Bundle?) {
Lucio Maciel's avatar
Lucio Maciel committed
70
        AndroidInjection.inject(this)
71 72 73
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_chat_room)

74
        // Workaround for when we are coming to the app via the recents app and the app was killed.
75 76 77 78 79 80 81
        val serverUrl = serverInteractor.get()
        if (serverUrl != null) {
            managerFactory.create(serverUrl).connect()
        } else {
            navigator.toNewServer()
            return
        }
82

83
        val chatRoomId = intent.getStringExtra(INTENT_CHAT_ROOM_ID)
84 85
        requireNotNull(chatRoomId) { "no chat_room_id provided in Intent extras" }

86
        val chatRoomName = intent.getStringExtra(INTENT_CHAT_ROOM_NAME)
87 88
        requireNotNull(chatRoomName) { "no chat_room_name provided in Intent extras" }

89
        val chatRoomType = intent.getStringExtra(INTENT_CHAT_ROOM_TYPE)
90 91
        requireNotNull(chatRoomType) { "no chat_room_type provided in Intent extras" }

92
        val isChatRoomReadOnly = intent.getBooleanExtra(INTENT_CHAT_ROOM_IS_READ_ONLY, true)
93

94
        val isChatRoomCreator = intent.getBooleanExtra(INTENT_CHAT_ROOM_IS_CREATOR, false)
95

96
        val chatRoomLastSeen = intent.getLongExtra(INTENT_CHAT_ROOM_LAST_SEEN, -1)
97

98
        val isChatRoomSubscribed = intent.getBooleanExtra(INTENT_CHAT_IS_SUBSCRIBED, true)
99

100
        val chatRoomMessage = intent.getStringExtra(INTENT_CHAT_ROOM_MESSAGE)
101

102
        setupToolbar()
103

104 105
        if (supportFragmentManager.findFragmentByTag(TAG_CHAT_ROOM_FRAGMENT) == null) {
            addFragment(TAG_CHAT_ROOM_FRAGMENT, R.id.fragment_container) {
106 107 108 109
                newInstance(
                    chatRoomId, chatRoomName, chatRoomType, isChatRoomReadOnly, chatRoomLastSeen,
                    isChatRoomSubscribed, isChatRoomCreator, chatRoomMessage
                )
110
            }
111 112 113
        }
    }

114
    override fun onBackPressed() {
115
        finishActivity()
116
    }
117 118 119 120 121

    override fun supportFragmentInjector(): AndroidInjector<Fragment> {
        return fragmentDispatchingAndroidInjector
    }

122
    private fun setupToolbar() {
123 124
        setSupportActionBar(toolbar)
        supportActionBar?.setDisplayShowTitleEnabled(false)
125 126
        toolbar.setNavigationIcon(R.drawable.ic_arrow_back_white_24dp)
        toolbar.setNavigationOnClickListener { finishActivity() }
127 128
    }

129 130 131
    fun showToolbarTitle(title: String) {
        text_room_name.textContent = title
    }
132

133 134 135 136
    fun showToolbarChatRoomIcon(chatRoomType: String) {
        val drawable = when (roomTypeOf(chatRoomType)) {
            is RoomType.Channel -> {
                DrawableHelper.getDrawableFromId(R.drawable.ic_hashtag_black_12dp, this)
137
            }
138 139 140 141
            is RoomType.PrivateGroup -> {
                DrawableHelper.getDrawableFromId(R.drawable.ic_lock_black_12_dp, this)
            }
            else -> null
142
        }
143

144 145 146 147 148
        drawable?.let {
            val wrappedDrawable = DrawableHelper.wrapDrawable(it)
            val mutableDrawable = wrappedDrawable.mutate()
            DrawableHelper.tintDrawable(mutableDrawable, this, R.color.colorWhite)
            DrawableHelper.compoundDrawable(text_room_name, mutableDrawable)
149 150 151
        }
    }

152 153
    fun hideToolbarChatRoomIcon() {
        text_room_name.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0)
154 155
    }

156 157 158 159
    private fun finishActivity() {
        super.onBackPressed()
        overridePendingTransition(R.anim.close_enter, R.anim.close_exit)
    }
160 161 162 163

    companion object {
        const val TAG_CHAT_ROOM_FRAGMENT = "ChatRoomFragment"
    }
164
}