HomeContract.kt

package ru.aquaticsaver.ui.fragments.home

import io.reactivex.Observable
import ru.aquaticsaver.data.entity.Device
import ru.aquaticsaver.ui.BaseContract

interface HomeContract {

    interface View: BaseContract.View {

        fun showStub(show: Boolean)

        fun showLoading(show: Boolean)

        fun showAddDeviceDialog()

        fun startDeviceListRefreshing()

        fun stopDeviceListRefreshing()

        fun updateDevices(devices: List<Device>)

    }

    interface Presenter: BaseContract.Presenter {

        fun onResume()

        fun onStartDeviceListRefreshing()

        fun onDeviceItemClicked(deviceId: Int)

        fun onAddDeviceMenuItemClicked()

        fun onAddDeviceDialogDataSet(deviceName: String, imei: String, simNumber: String)

    }

}

HomeFragment.kt

package ru.aquaticsaver.ui.fragments.home

import android.os.Bundle
import android.support.v7.app.AlertDialog
import android.support.v7.widget.LinearLayoutManager
import android.view.*
import android.widget.EditText
import com.arellomobile.mvp.presenter.InjectPresenter
import com.arellomobile.mvp.presenter.ProvidePresenter
import kotlinx.android.synthetic.main.fragment_home.view.*
import kotlinx.android.synthetic.main.layout_stub.view.*
import ru.aquaticsaver.R
import ru.aquaticsaver.data.entity.Device
import ru.aquaticsaver.data.helper.CacheHelper
import ru.aquaticsaver.data.helper.PreferencesHelper
import ru.aquaticsaver.data.service.TraccarService
import ru.aquaticsaver.domain.usecase.FetchDevicesUseCase
import ru.aquaticsaver.data.repository.DevicesRepositoryImpl
import ru.aquaticsaver.domain.usecase.AddDeviceUseCase
import ru.aquaticsaver.ui.BaseFragment
import ru.aquaticsaver.ui.fragments.home.adapter.DeviceListAdapter
import ru.aquaticsaver.ui.fragments.root.RootFragment

class HomeFragment: BaseFragment(), HomeContract.View {
    private val deviceListAdapter = DeviceListAdapter()

    @InjectPresenter
    lateinit var presenter: HomePresenter

    @ProvidePresenter
    fun providePresenter(): HomePresenter{
        val rootRouter = (parentBaseFragment as RootFragment).router
        val devicesRepository = DevicesRepositoryImpl(TraccarService.instance, CacheHelper)
        val fetchDevicesUseCase = FetchDevicesUseCase(devicesRepository, PreferencesHelper, CacheHelper)
        val addDeviceUseCase = AddDeviceUseCase(devicesRepository, PreferencesHelper)
        return HomePresenter(rootRouter, fetchDevicesUseCase, addDeviceUseCase)
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        return inflater.inflate(R.layout.fragment_home, container, false).apply {

            swipe_refresh_layout.setOnRefreshListener {
                presenter.onStartDeviceListRefreshing()
            }

            add_tracker_button.setOnClickListener {
                presenter.onAddDeviceMenuItemClicked()
            }

            recycler_view.layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
            recycler_view.adapter = deviceListAdapter

            deviceListAdapter.setOnClickListener { presenter.onDeviceItemClicked(it) }
        }
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        return when(item.itemId) {
            R.id.action_add_tracker -> { presenter.onAddDeviceMenuItemClicked(); true }
            else -> false
        }
    }

    override fun onResume() {
        super.onResume()
        presenter.onResume()
    }

    override fun startDeviceListRefreshing() {
        swipe_refresh_layout.isRefreshing = true
    }

    override fun stopDeviceListRefreshing() {
        swipe_refresh_layout.isRefreshing = false
    }

    override fun showStub(show: Boolean) {
        stub_view.visibility = if (show) View.VISIBLE else View.GONE
        recycler_view.visibility = if (show) View.GONE else View.VISIBLE
    }

    override fun showLoading(show: Boolean) {
        loading_view.visibility = if (show == true) View.VISIBLE else View.GONE
    }

    override fun updateDevices(devices: List<Device>) {
        deviceListAdapter.updateDevices(devices)
    }

    override fun showAddDeviceDialog() {
        val view = LayoutInflater.from(context).inflate(R.layout.dialog_add_device, null, false)
        val deviceNameField = view.findViewById<EditText>(R.id.device_name_field)
        val imeiField = view.findViewById<EditText>(R.id.device_imei_field)
        val simNumberField = view.findViewById<EditText>(R.id.device_sim_number_field)

        AlertDialog.Builder(context!!)
                .setView(view)
                .setTitle(R.string.dialog_title_new_device)
                .setPositiveButton(android.R.string.ok) { p0, p1 ->
                    presenter.onAddDeviceDialogDataSet(
                            deviceNameField.text.toString(),
                            imeiField.text.toString(),
                            simNumberField.text.toString())
                }
                .setNegativeButton(android.R.string.cancel, null)
                .create()
                .show()
    }

    override fun getLogTag() = this::class.java.simpleName

    override fun getTitle() = R.string.screen_title_home

    override fun getOptionsMenuResId() = R.menu.home

    override fun isInnerFragment() = false

    companion object {
        fun newInstance() = HomeFragment()
    }
}

HomePresenter.kt

package ru.aquaticsaver.ui.fragments.home

import android.os.Bundle
import com.arellomobile.mvp.InjectViewState
import com.arellomobile.mvp.MvpPresenter
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.disposables.Disposable
import io.reactivex.schedulers.Schedulers
import ru.aquaticsaver.domain.usecase.AddDeviceUseCase
import ru.aquaticsaver.domain.usecase.FetchDevicesUseCase
import ru.aquaticsaver.ui.fragments.root.RootContract

@InjectViewState
class HomePresenter(
        private val rootRouter: RootContract.Router,
        private val fetchDevicesUseCase: FetchDevicesUseCase,
        private val addDeviceUseCase: AddDeviceUseCase
): MvpPresenter<HomeContract.View>(), HomeContract.Presenter {

    private var retrieveDevicesDisposable: Disposable? = null
    private var addDeviceDisposable: Disposable? = null

    override fun onResume() {
        viewState.startDeviceListRefreshing()
        onStartDeviceListRefreshing()
    }

    override fun onDestroy() {
        super.onDestroy()
        retrieveDevicesDisposable?.dispose()
        addDeviceDisposable?.dispose()
    }

    override fun onStartDeviceListRefreshing() {
        retrieveDevicesDisposable = fetchDevicesUseCase.execute(Bundle.EMPTY)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    { devices ->
                        viewState.stopDeviceListRefreshing()
                        if (!devices.isEmpty()) {
                            viewState.showStub(false)
                            viewState.updateDevices(devices)
                        } else {
                            viewState.showStub(true)
                        }
                    },
                    { exception ->
                        viewState.showStub(true)
                        viewState.showMessage(exception.localizedMessage)
                    })
    }

    override fun onAddDeviceMenuItemClicked() {
        viewState.showAddDeviceDialog()
    }

    override fun onDeviceItemClicked(deviceId: Int) {
        rootRouter.navigateToDevice(deviceId)
    }

    override fun onAddDeviceDialogDataSet(deviceName: String, imei: String, simNumber: String) {
        viewState.showLoading(true)
        addDeviceDisposable = addDeviceUseCase.execute(
                Bundle().apply {
                    putString(AddDeviceUseCase.DEVICE_NAME_PARAM, deviceName)
                    putString(AddDeviceUseCase.SIM_NUMBER_PARAM, simNumber)
                    putLong(AddDeviceUseCase.DEVICE_IMEI_PARAM, imei.toLongOrNull() ?: 0)
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe({
                    viewState.showLoading(false)
                    onResume()
                }, {
                    viewState.showLoading(false)
                    viewState.showMessage(it.localizedMessage)
                })
    }
}