Move blocked messages to their own screen

package com.moez.QKSMS.feature.blocking

import android.view.View

import androidx.core.view.isVisible

import com.bluelinelabs.conductor.RouterTransaction

import com.jakewharton.rxbinding2.view.clicks

import com.moez.QKSMS.R

import com.moez.QKSMS.common.util.Colors

import com.moez.QKSMS.common.util.extensions.animateLayoutChanges

import com.moez.QKSMS.feature.blocking.manager.BlockingManagerController

import com.moez.QKSMS.feature.blocking.messages.BlockedMessagesController

import com.moez.QKSMS.injection.appComponent

import kotlinx.android.synthetic.main.blocking_controller.*

import kotlinx.android.synthetic.main.settings_switch_widget.view.*

class BlockingController : QkController<BlockingView, BlockingState, BlockingPresenter>(), BlockingView {

    override val blockingManagerIntent by lazy { blockingManager.clicks() }

    override val blockedMessagesIntent by lazy { blockedNumbers.clicks() }

    override val dropClickedIntent by lazy { drop.clicks() }

    override val conversationClicks by lazy { blockingAdapter.clicks }

    @Inject lateinit var blockingAdapter: BlockingAdapter

    @Inject lateinit var colors: Colors

    @Inject override lateinit var presenter: BlockingPresenter

    override fun onViewCreated() {

        super.onViewCreated()

        blockingAdapter.emptyView = empty

        conversations.adapter = blockingAdapter

        parent.postDelayed({ parent?.animateLayoutChanges = true }, 100)

    }

    override fun render(state: BlockingState) {

        blockingManager.summary = state.blockingManager

        drop.checkbox.isChecked = state.dropEnabled

        blockedLabel.isVisible = state.data?.isNotEmpty() == true

        blockingAdapter.updateData(state.data)

    }

    override fun openBlockedMessages() {

        router.pushController(RouterTransaction.with(BlockedMessagesController())

                .pushChangeHandler(QkChangeHandler())

                .popChangeHandler(QkChangeHandler()))

    }

    override fun openBlockingManager() {

import android.content.Context

import com.moez.QKSMS.R

import com.moez.QKSMS.common.Navigator

import com.moez.QKSMS.common.base.QkPresenter

import com.moez.QKSMS.extensions.asObservable

import com.moez.QKSMS.repository.ConversationRepository

import com.moez.QKSMS.util.Preferences

import com.uber.autodispose.android.lifecycle.scope

import com.uber.autodispose.autoDisposable

class BlockingPresenter @Inject constructor(

    context: Context,

    conversationRepo: ConversationRepository,

    private val navigator: Navigator,

    private val prefs: Preferences

) : QkPresenter<BlockingView, BlockingState>(BlockingState()) {

    init {

        val blockedConversations = conversationRepo.getBlockedConversations()

        newState { copy(data = blockedConversations) }

        disposables += prefs.blockingManager.asObservable()

                .map { client ->

                    when (client) {

        disposables += prefs.drop.asObservable()

                .subscribe { enabled -> newState { copy(dropEnabled = enabled) } }

        // Trigger a refresh if we go between having some/no blocked conversations, otherwise the header won't update

        disposables += blockedConversations

                .asObservable()

                .filter { it.isValid && it.isLoaded }

                .map { it.isEmpty() }

                .distinctUntilChanged()

                .subscribe { newState { copy() } }

    }

    override fun bindIntents(view: BlockingView) {

                .autoDisposable(view.scope())

                .subscribe { view.openBlockingManager() }

        view.dropClickedIntent

        view.blockedMessagesIntent

                .autoDisposable(view.scope())

                .subscribe { prefs.drop.set(!prefs.drop.get()) }

                .subscribe { view.openBlockedMessages() }

        view.conversationClicks

        view.dropClickedIntent

                .autoDisposable(view.scope())

                .subscribe { threadId -> navigator.showConversation(threadId) }

                .subscribe { prefs.drop.set(!prefs.drop.get()) }

    }

}

 */

package com.moez.QKSMS.feature.blocking

import com.moez.QKSMS.model.Conversation

import io.realm.RealmResults

data class BlockingState(

    val blockingManager: String = "",

    val dropEnabled: Boolean = false,

    val data: RealmResults<Conversation>? = null

    val dropEnabled: Boolean = false

)

interface BlockingView : QkViewContract<BlockingState> {

    val blockingManagerIntent: Observable<*>

    val blockedMessagesIntent: Observable<*>

    val dropClickedIntent: Observable<*>

    val conversationClicks: Observable<Long>

    fun openBlockingManager()

    fun openBlockedMessages()

}

/*

 * Copyright (C) 2017 Moez Bhatti <moez.bhatti@gmail.com>

 * Copyright (C) 2019 Moez Bhatti <moez.bhatti@gmail.com>

 *

 * This file is part of QKSMS.

 *

 * You should have received a copy of the GNU General Public License

 * along with QKSMS.  If not, see <http://www.gnu.org/licenses/>.

 */

package com.moez.QKSMS.feature.blocking

package com.moez.QKSMS.feature.blocking.messages

import android.view.LayoutInflater

import android.view.ViewGroup

import kotlinx.android.synthetic.main.blocked_list_item.view.*

import javax.inject.Inject

class BlockingAdapter @Inject constructor() : QkRealmAdapter<Conversation>() {

class BlockedMessagesAdapter @Inject constructor() : QkRealmAdapter<Conversation>() {

    val clicks: PublishSubject<Long> = PublishSubject.create()