mListeners = new CopyOnWriteArrayList<>();
48 | private final Object mLock = new Object();
49 | private final Executor mRetryService;
50 | @GuardedBy("mLock")
51 | private final RequestQueue[] mRequestQueues = new RequestQueue[]
52 | {new RequestQueue(RequestType.INITIAL),
53 | new RequestQueue(RequestType.BEFORE),
54 | new RequestQueue(RequestType.AFTER)};
55 |
56 | /**
57 | * Creates a new PagingRequestHelper with the given {@link Executor} which is used to run
58 | * retry actions.
59 | *
60 | * @param retryService The {@link Executor} that can run the retry actions.
61 | */
62 | public PagingRequestHelper(@NonNull Executor retryService) {
63 | mRetryService = retryService;
64 | }
65 |
66 | /**
67 | * Adds a new listener that will be notified when any request changes {@link Status state}.
68 | *
69 | * @param listener The listener that will be notified each time a request's status changes.
70 | * @return True if it is added, false otherwise (e.g. it already exists in the list).
71 | */
72 | @AnyThread
73 | public boolean addListener(@NonNull Listener listener) {
74 | return mListeners.add(listener);
75 | }
76 |
77 | /**
78 | * Removes the given listener from the listeners list.
79 | *
80 | * @param listener The listener that will be removed.
81 | * @return True if the listener is removed, false otherwise (e.g. it never existed)
82 | */
83 | public boolean removeListener(@NonNull Listener listener) {
84 | return mListeners.remove(listener);
85 | }
86 |
87 | /**
88 | * Runs the given {@link Request} if no other requests in the given request type is already
89 | * running.
90 | *
91 | * If run, the request will be run in the current thread.
92 | *
93 | * @param type The type of the request.
94 | * @param request The request to run.
95 | * @return True if the request is run, false otherwise.
96 | */
97 | @SuppressWarnings("WeakerAccess")
98 | @AnyThread
99 | public boolean runIfNotRunning(@NonNull RequestType type, @NonNull Request request) {
100 | boolean hasListeners = !mListeners.isEmpty();
101 | StatusReport report = null;
102 | synchronized (mLock) {
103 | RequestQueue queue = mRequestQueues[type.ordinal()];
104 | if (queue.mRunning != null) {
105 | return false;
106 | }
107 | queue.mRunning = request;
108 | queue.mStatus = Status.RUNNING;
109 | queue.mFailed = null;
110 | queue.mLastError = null;
111 | if (hasListeners) {
112 | report = prepareStatusReportLocked();
113 | }
114 | }
115 | if (report != null) {
116 | dispatchReport(report);
117 | }
118 | final RequestWrapper wrapper = new RequestWrapper(request, this, type);
119 | wrapper.run();
120 | return true;
121 | }
122 |
123 | @GuardedBy("mLock")
124 | private StatusReport prepareStatusReportLocked() {
125 | Throwable[] errors = new Throwable[]{
126 | mRequestQueues[0].mLastError,
127 | mRequestQueues[1].mLastError,
128 | mRequestQueues[2].mLastError
129 | };
130 | return new StatusReport(
131 | getStatusForLocked(RequestType.INITIAL),
132 | getStatusForLocked(RequestType.BEFORE),
133 | getStatusForLocked(RequestType.AFTER),
134 | errors
135 | );
136 | }
137 |
138 | @GuardedBy("mLock")
139 | private Status getStatusForLocked(RequestType type) {
140 | return mRequestQueues[type.ordinal()].mStatus;
141 | }
142 |
143 | @AnyThread
144 | @VisibleForTesting
145 | void recordResult(@NonNull RequestWrapper wrapper, @Nullable Throwable throwable) {
146 | StatusReport report = null;
147 | final boolean success = throwable == null;
148 | boolean hasListeners = !mListeners.isEmpty();
149 | synchronized (mLock) {
150 | RequestQueue queue = mRequestQueues[wrapper.mType.ordinal()];
151 | queue.mRunning = null;
152 | queue.mLastError = throwable;
153 | if (success) {
154 | queue.mFailed = null;
155 | queue.mStatus = Status.SUCCESS;
156 | } else {
157 | queue.mFailed = wrapper;
158 | queue.mStatus = Status.FAILED;
159 | }
160 | if (hasListeners) {
161 | report = prepareStatusReportLocked();
162 | }
163 | }
164 | if (report != null) {
165 | dispatchReport(report);
166 | }
167 | }
168 |
169 | private void dispatchReport(StatusReport report) {
170 | for (Listener listener : mListeners) {
171 | listener.onStatusChange(report);
172 | }
173 | }
174 |
175 | /**
176 | * Retries all failed requests.
177 | *
178 | * @return True if any request is retried, false otherwise.
179 | */
180 | public boolean retryAllFailed() {
181 | final RequestWrapper[] toBeRetried = new RequestWrapper[RequestType.values().length];
182 | boolean retried = false;
183 | synchronized (mLock) {
184 | for (int i = 0; i < RequestType.values().length; i++) {
185 | toBeRetried[i] = mRequestQueues[i].mFailed;
186 | mRequestQueues[i].mFailed = null;
187 | }
188 | }
189 | for (RequestWrapper failed : toBeRetried) {
190 | if (failed != null) {
191 | failed.retry(mRetryService);
192 | retried = true;
193 | }
194 | }
195 | return retried;
196 | }
197 |
198 | /**
199 | * Represents the status of a Request for each {@link RequestType}.
200 | */
201 | public enum Status {
202 | /**
203 | * There is current a running request.
204 | */
205 | RUNNING,
206 | /**
207 | * The last request has succeeded or no such requests have ever been run.
208 | */
209 | SUCCESS,
210 | /**
211 | * The last request has failed.
212 | */
213 | FAILED
214 | }
215 |
216 | /**
217 | * Available request types.
218 | */
219 | public enum RequestType {
220 | /**
221 | * Corresponds to an initial request made to a {@link DataSource} or the empty state for
222 | * a {@link android.arch.paging.PagedList.BoundaryCallback BoundaryCallback}.
223 | */
224 | INITIAL,
225 | /**
226 | * Corresponds to the {@code loadBefore} calls in {@link DataSource} or
227 | * {@code onItemAtFrontLoaded} in
228 | * {@link android.arch.paging.PagedList.BoundaryCallback BoundaryCallback}.
229 | */
230 | BEFORE,
231 | /**
232 | * Corresponds to the {@code loadAfter} calls in {@link DataSource} or
233 | * {@code onItemAtEndLoaded} in
234 | * {@link android.arch.paging.PagedList.BoundaryCallback BoundaryCallback}.
235 | */
236 | AFTER
237 | }
238 |
239 | /**
240 | * Runner class that runs a request tracked by the {@link PagingRequestHelper}.
241 | *
242 | * When a request is invoked, it must call one of {@link Callback#recordFailure(Throwable)}
243 | * or {@link Callback#recordSuccess()} once and only once. This call
244 | * can be made any time. Until that method call is made, {@link PagingRequestHelper} will
245 | * consider the request is running.
246 | */
247 | @FunctionalInterface
248 | public interface Request {
249 | /**
250 | * Should run the request and call the given {@link Callback} with the result of the
251 | * request.
252 | *
253 | * @param callback The callback that should be invoked with the result.
254 | */
255 | void run(Callback callback);
256 |
257 | /**
258 | * Callback class provided to the {@link #run(Callback)} method to report the result.
259 | */
260 | class Callback {
261 | private final AtomicBoolean mCalled = new AtomicBoolean();
262 | private final RequestWrapper mWrapper;
263 | private final PagingRequestHelper mHelper;
264 |
265 | Callback(RequestWrapper wrapper, PagingRequestHelper helper) {
266 | mWrapper = wrapper;
267 | mHelper = helper;
268 | }
269 |
270 | /**
271 | * Call this method when the request succeeds and new data is fetched.
272 | */
273 | @SuppressWarnings("unused")
274 | public final void recordSuccess() {
275 | if (mCalled.compareAndSet(false, true)) {
276 | mHelper.recordResult(mWrapper, null);
277 | } else {
278 | throw new IllegalStateException(
279 | "already called recordSuccess or recordFailure");
280 | }
281 | }
282 |
283 | /**
284 | * Call this method with the failure message and the request can be retried via
285 | * {@link #retryAllFailed()}.
286 | *
287 | * @param throwable The error that occured while carrying out the request.
288 | */
289 | @SuppressWarnings("unused")
290 | public final void recordFailure(@NonNull Throwable throwable) {
291 | //noinspection ConstantConditions
292 | if (throwable == null) {
293 | throw new IllegalArgumentException("You must provide a throwable describing"
294 | + " the error to record the failure");
295 | }
296 | if (mCalled.compareAndSet(false, true)) {
297 | mHelper.recordResult(mWrapper, throwable);
298 | } else {
299 | throw new IllegalStateException(
300 | "already called recordSuccess or recordFailure");
301 | }
302 | }
303 | }
304 | }
305 |
306 | /**
307 | * Listener interface to get notified by request status changes.
308 | */
309 | public interface Listener {
310 | /**
311 | * Called when the status for any of the requests has changed.
312 | *
313 | * @param report The current status report that has all the information about the requests.
314 | */
315 | void onStatusChange(@NonNull StatusReport report);
316 | }
317 |
318 | static class RequestWrapper implements Runnable {
319 | @NonNull
320 | final Request mRequest;
321 | @NonNull
322 | final PagingRequestHelper mHelper;
323 | @NonNull
324 | final RequestType mType;
325 |
326 | RequestWrapper(@NonNull Request request, @NonNull PagingRequestHelper helper,
327 | @NonNull RequestType type) {
328 | mRequest = request;
329 | mHelper = helper;
330 | mType = type;
331 | }
332 |
333 | @Override
334 | public void run() {
335 | mRequest.run(new Request.Callback(this, mHelper));
336 | }
337 |
338 | void retry(Executor service) {
339 | service.execute(new Runnable() {
340 | @Override
341 | public void run() {
342 | mHelper.runIfNotRunning(mType, mRequest);
343 | }
344 | });
345 | }
346 | }
347 |
348 | /**
349 | * Data class that holds the information about the current status of the ongoing requests
350 | * using this helper.
351 | */
352 | public static final class StatusReport {
353 | /**
354 | * Status of the latest request that were submitted with {@link RequestType#INITIAL}.
355 | */
356 | @NonNull
357 | public final Status initial;
358 | /**
359 | * Status of the latest request that were submitted with {@link RequestType#BEFORE}.
360 | */
361 | @NonNull
362 | public final Status before;
363 | /**
364 | * Status of the latest request that were submitted with {@link RequestType#AFTER}.
365 | */
366 | @NonNull
367 | public final Status after;
368 | @NonNull
369 | private final Throwable[] mErrors;
370 |
371 | StatusReport(@NonNull Status initial, @NonNull Status before, @NonNull Status after,
372 | @NonNull Throwable[] errors) {
373 | this.initial = initial;
374 | this.before = before;
375 | this.after = after;
376 | this.mErrors = errors;
377 | }
378 |
379 | /**
380 | * Convenience method to check if there are any running requests.
381 | *
382 | * @return True if there are any running requests, false otherwise.
383 | */
384 | public boolean hasRunning() {
385 | return initial == Status.RUNNING
386 | || before == Status.RUNNING
387 | || after == Status.RUNNING;
388 | }
389 |
390 | /**
391 | * Convenience method to check if there are any requests that resulted in an error.
392 | *
393 | * @return True if there are any requests that finished with error, false otherwise.
394 | */
395 | public boolean hasError() {
396 | return initial == Status.FAILED
397 | || before == Status.FAILED
398 | || after == Status.FAILED;
399 | }
400 |
401 | /**
402 | * Returns the error for the given request type.
403 | *
404 | * @param type The request type for which the error should be returned.
405 | * @return The {@link Throwable} returned by the failing request with the given type or
406 | * {@code null} if the request for the given type did not fail.
407 | */
408 | @Nullable
409 | public Throwable getErrorFor(@NonNull RequestType type) {
410 | return mErrors[type.ordinal()];
411 | }
412 |
413 | @Override
414 | public String toString() {
415 | return "StatusReport{"
416 | + "initial=" + initial
417 | + ", before=" + before
418 | + ", after=" + after
419 | + ", mErrors=" + Arrays.toString(mErrors)
420 | + '}';
421 | }
422 |
423 | @Override
424 | public boolean equals(Object o) {
425 | if (this == o) return true;
426 | if (o == null || getClass() != o.getClass()) return false;
427 | StatusReport that = (StatusReport) o;
428 | if (initial != that.initial) return false;
429 | if (before != that.before) return false;
430 | if (after != that.after) return false;
431 | // Probably incorrect - comparing Object[] arrays with Arrays.equals
432 | return Arrays.equals(mErrors, that.mErrors);
433 | }
434 |
435 | @Override
436 | public int hashCode() {
437 | int result = initial.hashCode();
438 | result = 31 * result + before.hashCode();
439 | result = 31 * result + after.hashCode();
440 | result = 31 * result + Arrays.hashCode(mErrors);
441 | return result;
442 | }
443 | }
444 |
445 | class RequestQueue {
446 | @NonNull
447 | final RequestType mRequestType;
448 | @Nullable
449 | RequestWrapper mFailed;
450 | @Nullable
451 | Request mRunning;
452 | @Nullable
453 | Throwable mLastError;
454 | @NonNull
455 | Status mStatus = Status.SUCCESS;
456 |
457 | RequestQueue(@NonNull RequestType requestType) {
458 | mRequestType = requestType;
459 | }
460 | }
461 | }
462 |
--------------------------------------------------------------------------------
/app/src/main/java/com/spiraldev/mvvmpaging/data/remote/vo/MovieModel.kt:
--------------------------------------------------------------------------------
1 | package com.spiraldev.mvvmpaging.data.remote.vo
2 |
3 | import com.google.gson.annotations.SerializedName
4 | import com.spiraldev.mvvmpaging.data.local.MovieEntity
5 | import com.spiraldev.mvvmpaging.data.remote.Api.IMAGES_URL
6 |
7 | data class MovieModel(
8 | @SerializedName("id") val id: Int,
9 | @SerializedName("title") val title: String,
10 | @SerializedName("popularity") val popularity: Double,
11 | @SerializedName("vote_average") val voteAverage: Double,
12 | @SerializedName("poster_path") val posterPath: String,
13 | @SerializedName("release_date") val releaseDate: String
14 | )
15 |
16 | fun MovieModel.toMovieEntity() =
17 | MovieEntity(0, title, popularity, voteAverage, getPosterURL(posterPath), releaseDate)
18 |
19 | private fun getPosterURL(posterPath: String) = IMAGES_URL + posterPath
20 |
--------------------------------------------------------------------------------
/app/src/main/java/com/spiraldev/mvvmpaging/data/remote/vo/ResponseModel.kt:
--------------------------------------------------------------------------------
1 | package com.spiraldev.mvvmpaging.data.remote.vo
2 |
3 | import com.google.gson.annotations.SerializedName
4 |
5 |
6 | data class ResponseModel(
7 | val page: Int,
8 | @SerializedName("results")
9 | val movieList: List,
10 | @SerializedName("total_pages")
11 | val totalPages: Int,
12 | @SerializedName("total_results")
13 | val totalResults: Int
14 | )
--------------------------------------------------------------------------------
/app/src/main/java/com/spiraldev/mvvmpaging/di/modules/ApplicationModule.kt:
--------------------------------------------------------------------------------
1 | package com.example.seemenstask.di.modules
2 |
3 | import android.app.Application
4 | import android.content.Context
5 | import com.spiraldev.mvvmpaging.data.local.MoviesDao
6 | import com.spiraldev.mvvmpaging.data.local.MoviesDatabase
7 | import com.spiraldev.mvvmpaging.data.remote.Api
8 | import com.spiraldev.mvvmpaging.data.remote.ApiService
9 | import dagger.Module
10 | import dagger.Provides
11 | import dagger.hilt.InstallIn
12 | import dagger.hilt.android.components.ApplicationComponent
13 | import dagger.hilt.android.qualifiers.ApplicationContext
14 | import okhttp3.Interceptor
15 | import okhttp3.OkHttpClient
16 | import okhttp3.logging.HttpLoggingInterceptor
17 | import retrofit2.Retrofit
18 | import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
19 | import retrofit2.converter.gson.GsonConverterFactory
20 | import java.util.concurrent.TimeUnit
21 | import javax.inject.Singleton
22 |
23 |
24 | @Module
25 | @InstallIn(ApplicationComponent::class)
26 | class ApplicationModule {
27 |
28 | @Provides
29 | @Singleton
30 | fun provideOkHttpClient(): OkHttpClient {
31 | val requestInterceptor = Interceptor { chain ->
32 |
33 | val url = chain.request()
34 | .url()
35 | .newBuilder()
36 | .build()
37 |
38 | val request = chain.request()
39 | .newBuilder()
40 | .url(url)
41 | .build()
42 |
43 | return@Interceptor chain.proceed(request)
44 | }
45 |
46 | return OkHttpClient.Builder()
47 | .addInterceptor(requestInterceptor)
48 | .connectTimeout(60, TimeUnit.SECONDS)
49 | .build()
50 | }
51 |
52 | @Provides
53 | @Singleton
54 | fun provideRetrofit(okHttpClient: OkHttpClient): Retrofit {
55 |
56 | return Retrofit.Builder()
57 | .addConverterFactory(GsonConverterFactory.create())
58 | .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
59 | .baseUrl(Api.THE_MOVIE_URL)
60 | .client(okHttpClient)
61 | .build()
62 | }
63 |
64 | @Provides
65 | @Singleton
66 | fun provideApiClient(retrofit: Retrofit): ApiService {
67 | return retrofit.create(ApiService::class.java)
68 | }
69 |
70 | @Singleton
71 | @Provides
72 | fun providesMoviesDatabase(@ApplicationContext context: Context): MoviesDatabase =
73 | MoviesDatabase.buildDatabase(context)
74 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/spiraldev/mvvmpaging/ui/MainActivity.kt:
--------------------------------------------------------------------------------
1 | package com.spiraldev.mvvmpaging.ui
2 |
3 | import android.os.Bundle
4 | import android.view.View
5 | import androidx.activity.viewModels
6 | import androidx.appcompat.app.AppCompatActivity
7 | import androidx.lifecycle.Observer
8 | import androidx.recyclerview.widget.GridLayoutManager
9 | import androidx.recyclerview.widget.RecyclerView
10 | import com.spiraldev.mvvmpaging.R
11 | import com.spiraldev.mvvmpaging.adapters.MoviesPagedListAdapter
12 | import com.spiraldev.mvvmpaging.data.remote.NetworkState
13 | import dagger.hilt.android.AndroidEntryPoint
14 | import kotlinx.android.synthetic.main.activity_main.*
15 |
16 | @AndroidEntryPoint
17 | class MainActivity : AppCompatActivity() {
18 |
19 | val viewModel: MainActivityViewModel by viewModels()
20 |
21 | lateinit var moviesAdapter: MoviesPagedListAdapter
22 |
23 | override fun onCreate(savedInstanceState: Bundle?) {
24 | super.onCreate(savedInstanceState)
25 | setContentView(R.layout.activity_main)
26 | initRecycler()
27 | initObserver()
28 | }
29 |
30 | private fun initRecycler() {
31 | moviesAdapter = MoviesPagedListAdapter {
32 | viewModel.retry()
33 | }
34 |
35 | val gridLayoutManager = GridLayoutManager(this, 4, RecyclerView.VERTICAL, false)
36 |
37 | gridLayoutManager.spanSizeLookup = object : GridLayoutManager.SpanSizeLookup() {
38 | override fun getSpanSize(position: Int): Int {
39 | val viewType = moviesAdapter.getItemViewType(position)
40 | if (viewType == R.layout.movie_list_item) return 1
41 | else return 4
42 | }
43 | }
44 |
45 | movies_recycler.adapter = moviesAdapter
46 | movies_recycler.layoutManager = gridLayoutManager
47 | movies_recycler.setHasFixedSize(true)
48 | }
49 |
50 | private fun initObserver() {
51 | viewModel.moviePagedList.observe(this, Observer {
52 | moviesAdapter.submitList(it)
53 | })
54 |
55 | viewModel.getNetworkState()
56 | .observe(this, Observer {
57 | progress_bar_main.visibility =
58 | if (viewModel.listIsEmpty() && it == NetworkState.LOADING) View.VISIBLE else View.GONE
59 |
60 | txt_error_main.visibility =
61 | if (viewModel.listIsEmpty() && it.message != null) View.VISIBLE else View.GONE
62 |
63 | moviesAdapter.setNetworkState(it)
64 | })
65 | }
66 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/spiraldev/mvvmpaging/ui/MainActivityViewModel.kt:
--------------------------------------------------------------------------------
1 | package com.spiraldev.mvvmpaging.ui
2 |
3 | import androidx.hilt.lifecycle.ViewModelInject
4 | import androidx.lifecycle.LiveData
5 | import androidx.lifecycle.ViewModel
6 | import androidx.paging.LivePagedListBuilder
7 | import androidx.paging.PagedList
8 | import com.spiraldev.mvvmpaging.data.local.MovieEntity
9 | import com.spiraldev.mvvmpaging.data.local.MoviesDatabase
10 | import com.spiraldev.mvvmpaging.data.remote.ApiService
11 | import com.spiraldev.mvvmpaging.data.remote.NetworkState
12 | import com.spiraldev.mvvmpaging.data.remote.POST_PER_PAGE
13 | import com.spiraldev.mvvmpaging.data.remote.datasources.PagedListMovieBoundaryCallback
14 | import io.reactivex.disposables.CompositeDisposable
15 | import javax.inject.Inject
16 |
17 | class MainActivityViewModel @ViewModelInject constructor(
18 | private val apiService: ApiService,
19 | private val moviesDb: MoviesDatabase
20 | ) : ViewModel() {
21 |
22 | private val compositeDisposable = CompositeDisposable()
23 | var moviePagedList: LiveData>
24 |
25 | private val boundaryCallback: PagedListMovieBoundaryCallback =
26 | PagedListMovieBoundaryCallback(
27 | apiService,
28 | moviesDb,
29 | compositeDisposable
30 | )
31 |
32 | init {
33 | val config = PagedList.Config.Builder()
34 | .setPageSize(POST_PER_PAGE)
35 | .setEnablePlaceholders(false)
36 | .build()
37 |
38 | moviePagedList =
39 | LivePagedListBuilder(moviesDb.moviesDao().allMovies(), config)
40 | .setBoundaryCallback(boundaryCallback)
41 | .build()
42 | }
43 |
44 | fun listIsEmpty(): Boolean {
45 | return moviePagedList.value?.isEmpty() ?: true
46 | }
47 |
48 | fun retry() {
49 | boundaryCallback.retry()
50 | }
51 |
52 | fun getNetworkState(): LiveData {
53 | return boundaryCallback.networkState
54 | }
55 |
56 | override fun onCleared() {
57 | super.onCleared()
58 | compositeDisposable.dispose()
59 | }
60 | }
--------------------------------------------------------------------------------
/app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
1 |
7 |
8 |
9 |
15 |
8 | 
9 | 
34 |