Equinox/com.tecknobit.equinox/FetcherManager

Fetcher Manager

class FetcherManager(val refreshRoutine: CoroutineScope)

The FetcherManager class is useful to manage the requests to the backend executing these requests with a CoroutineScope so to execute in background and not working in the main UI thread

Author

N7ghtm4r3 - Tecknobit

Parameters

refreshRoutine

: the coroutine used to execute the refresh routines

Constructors

FetcherManager

constructor(refreshRoutine: CoroutineScope)

Types

Companion

object Companion

FetcherManagerWrapper

interface FetcherManagerWrapper

The FetcherManagerWrapper interface is useful for wrapping and facilitating operation with the FetcherManager, so the inheriting classes will invoke just the wrapper methods for a clean readability of the code, for example:

FetcherRoutine

private data class FetcherRoutine(val currentContext: Class<*>, val routine: () -> Unit, val repeatRoutine: Boolean = true, val refreshDelay: Long = 1000)

The FetcherRoutine data class is useful to memorize the last routine executed by the execute method

GenericFetcher

interface GenericFetcher : FetcherManager.ItemFetcher, FetcherManager.ListFetcher

The GenericFetcher interface is useful to manage the requests to refresh a list of items and a single item

ItemFetcher

interface ItemFetcher

The ItemFetcher interface is useful to manage the requests to refresh a single item

ListFetcher

interface ListFetcher

The ListFetcher interface is useful to manage the requests to refresh a list of items

Properties

isRefreshing

private var isRefreshing: Boolean

isRefreshing -> whether the refreshRoutine is already refreshing

lastRoutineExecuted

private lateinit var lastRoutineExecuted: FetcherManager.FetcherRoutine

lastRoutineExecuted -> the last routine executed by the execute method must re-launched after the suspend method has been invoked

refreshRoutine

private val refreshRoutine: CoroutineScope

Functions

canStart

fun canStart(): Boolean

Function to get whether the refreshRoutine can start, so if there aren't other jobs that routine is already executing

continueToFetch

fun continueToFetch(currentContext: Class<*>): Boolean

Function to check if the refreshRoutine can continue to refresh or need to be stopped, this for example when the UI displayed changes and the requests to refresh the UI data also changes

execute

fun execute(currentContext: Class<*>, routine: () -> Unit, repeatRoutine: Boolean = true, refreshDelay: Long = 1000)

Function to execute the refresh routine designed

restart

fun restart()

Function to restart the current refreshRoutine after other requests has been executed, the isRefreshing instance will be set as true to deny the restart of the routine after executing the other requests

suspend

fun suspend()

Function to suspend the current refreshRoutine to execute other requests to the backend, the isRefreshing instance will be set as false to allow the restart of the routine after executing the other requests