Android-CleanArchitecture | sample app that is part of a series of blog posts | Architecture library

by android10 Java Version: Current License: Apache-2.0

Download this library from

kandi X-RAY | Android-CleanArchitecture Summary

Android-CleanArchitecture is a Java library typically used in Architecture applications. Android-CleanArchitecture has no vulnerabilities, it has build file available, it has a Permissive License and it has medium support. However Android-CleanArchitecture has 3 bugs. You can download it from GitHub.

This is a sample app that is part of a series of blog posts I have written about how to architect an android application using Uncle Bob's clean architecture approach.

Support

Quality

Security

License

Reuse

kandi-support Support

Android-CleanArchitecture has a medium active ecosystem.
It has 14887 star(s) with 3309 fork(s). There are 859 watchers for this library.
It had no major release in the last 12 months.
There are 127 open issues and 122 have been closed. On average issues are closed in 68 days. There are 17 open pull requests and 0 closed requests.
It has a neutral sentiment in the developer community.
The latest version of Android-CleanArchitecture is current.

This Library - Support

Best in #Architecture

Average in #Architecture

This Library - Support

Best in #Architecture

Average in #Architecture

quality kandi Quality

Android-CleanArchitecture has 3 bugs (2 blocker, 0 critical, 0 major, 1 minor) and 47 code smells.

This Library - Quality

Best in #Architecture

Average in #Architecture

This Library - Quality

Best in #Architecture

Average in #Architecture

security Security

Android-CleanArchitecture has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
Android-CleanArchitecture code analysis shows 0 unresolved vulnerabilities.
There are 3 security hotspots that need review.

This Library - Security

Best in #Architecture

Average in #Architecture

This Library - Security

Best in #Architecture

Average in #Architecture

license License

Android-CleanArchitecture is licensed under the Apache-2.0 License. This license is Permissive.
Permissive licenses have the least restrictions, and you can use them in most projects.

This Library - License

Best in #Architecture

Average in #Architecture

This Library - License

Best in #Architecture

Average in #Architecture

build Reuse

Android-CleanArchitecture releases are not available. You will need to build from source code and install.
Build file is available. You can build the component from source.
Installation instructions are not available. Examples and code snippets are available.
Android-CleanArchitecture saves you 1362 person hours of effort in developing the same functionality from scratch.
It has 3051 lines of code, 379 functions and 95 files.
It has low code complexity. Code complexity directly impacts maintainability of the code.

This Library - Reuse

Best in #Architecture

Average in #Architecture

This Library - Reuse

Best in #Architecture

Average in #Architecture

Top functions reviewed by kandi - BETA

kandi has reviewed Android-CleanArchitecture and discovered the below as its top functions. This is intended to give you an instant insight into Android-CleanArchitecture implemented functionality, and help decide if they suit your requirements.

Download image from url .
Gets user entities .
Read the file content .
Retrieve user entity from cache .
Transform users model .
Connect to API
Creates a message from the given exception .
sets the onBindViewHolder on the ListViewHolder
Renders the user model .
Gets the error message .

Android-CleanArchitecture Key Features

This is a sample app that is part of a series of blog posts I have written about how to architect an android application using Uncle Bob's clean architecture approach.

Android-CleanArchitecture Examples and Code Snippets

See all related Code Snippets

New version available written in Kotlin:

Copy

Download

This is a sample app that is part of a blog post I have written about how to architect android application using the Uncle Bob's clean architecture approach.

[Architecting Android…The clean way?](http://fernandocejas.com/2014/09/03/architecting-android-the-clean-way/)

[Architecting Android…The evolution](http://fernandocejas.com/2015/07/18/architecting-android-the-evolution/)

[Tasting Dagger 2 on Android](http://fernandocejas.com/2015/04/11/tasting-dagger-2-on-android/)

[Clean Architecture…Dynamic Parameters in Use Cases](http://fernandocejas.com/2016/12/24/clean-architecture-dynamic-parameters-in-use-cases/)

[Demo video of this sample](http://youtu.be/XSjV4sG3ni0)

Clean architecture

Local Development

Copy

Download

Refer to the issues section: https://github.com/android10/Android-CleanArchitecture/issues


Code style
-----------

Here you can download and install the java codestyle.
https://github.com/android10/java-code-styles


License
--------

    Copyright 2018 Fernando Cejas

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.


![http://www.fernandocejas.com](https://github.com/android10/Sample-Data/blob/master/android10/android10_logo_big.png)

[![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-Android--CleanArchitecture-brightgreen.svg?style=flat)](https://android-arsenal.com/details/3/909)

&lt;a href="https://www.buymeacoffee.com/android10" target="_blank"&gt;&lt;img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" &gt;&lt;/a&gt;

Making synchronous calls to Cloud Firestore when running off the main thread

Copy

Download

suspend fun movieList(): List<MovieEntity>

launch(UI) {
    try {
        val list = movieList()
        ...
    } catch (e: FireException) {
        // handle
    }
}

-----------------------

suspend fun movieList(): List<MovieEntity>

launch(UI) {
    try {
        val list = movieList()
        ...
    } catch (e: FireException) {
        // handle
    }
}

-----------------------

private fun movieListResponse(): Call.Response<List<MovieEntity>> {
        return try {
            val taskResult = Tasks.await(FirebaseFirestore.getInstance().
                    collection(DataConfig.databasePath + MOVIES_PATH).get(), 2, TimeUnit.SECONDS)
            Call.Response(true, taskResult.mapTo(ArrayList()) { MovieEntity.fromSnapshot(it) }, null)
        } catch (e: ExecutionException) {
            Call.Response(false, null, Failure.ServerError())
        } catch (e: InterruptedException) {
            Call.Response(false, null, Failure.InterruptedError())
        } catch (e: TimeoutException) {
            Call.Response(false, null, Failure.TimeoutError())
        }
    }

disjoint union in Kotlin to get access in Java

Copy

Download

@Override public Unit invoke(
    Either<? extends Failure, ? extends TokenInfo> either) {
        either.either(f -> ..., tokenInfo -> ...);
        return Unit.INSTANCE;
}

Getting NullPointException when using Dagger2 and setRetainInstance(true);

Copy

Download

public abstract class BaseFragment extends Fragment {

    private boolean mIsInjected = false;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);

        try {
            mIsInjected = onInjectView();
        } catch (IllegalStateException e) {
            Log.e(e.getClass().getSimpleName(), e.getMessage());
            mIsInjected = false;
        }
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        if (mIsInjected) onViewInjected(savedInstanceState);
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        if (!mIsInjected) {
            mIsInjected = onInjectView();
            if (mIsInjected) onViewInjected(savedInstanceState);
        }
    }

    @SuppressWarnings("unchecked")
    protected <C> C getComponent(Class<C> componentType) throws IllegalStateException {
        C component = componentType.cast(((HasComponent<C>) getActivity()).getComponent());
        if (component == null) {
            throw new IllegalStateException(componentType.getSimpleName() + " has not been initialized yet.");
        }
        return component;
    }


    protected boolean onInjectView() throws IllegalStateException {
        // Return false by default.
        return false;
    }

    @CallSuper
    protected void onViewInjected(Bundle savedInstanceState) {
        // Intentionally left empty.
    }
 }

public class SampleFragment extends BaseFragment implements SampleView {

    @Inject
    SamplePresenter mSamplePresenter;

    @Override
    protected boolean onInjectView() throws IllegalStateException {
        getComponent(SampleComponent.class).inject(this);
        return true;
    }

    @Override
    protected void onViewInjected(Bundle savedInstanceState) {
        super.onViewInjected(savedInstanceState);
        this.mSamplePresenter.setView(this);
    }
}

-----------------------

public abstract class BaseFragment extends Fragment {

    private boolean mIsInjected = false;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);

        try {
            mIsInjected = onInjectView();
        } catch (IllegalStateException e) {
            Log.e(e.getClass().getSimpleName(), e.getMessage());
            mIsInjected = false;
        }
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        if (mIsInjected) onViewInjected(savedInstanceState);
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        if (!mIsInjected) {
            mIsInjected = onInjectView();
            if (mIsInjected) onViewInjected(savedInstanceState);
        }
    }

    @SuppressWarnings("unchecked")
    protected <C> C getComponent(Class<C> componentType) throws IllegalStateException {
        C component = componentType.cast(((HasComponent<C>) getActivity()).getComponent());
        if (component == null) {
            throw new IllegalStateException(componentType.getSimpleName() + " has not been initialized yet.");
        }
        return component;
    }


    protected boolean onInjectView() throws IllegalStateException {
        // Return false by default.
        return false;
    }

    @CallSuper
    protected void onViewInjected(Bundle savedInstanceState) {
        // Intentionally left empty.
    }
 }

public class SampleFragment extends BaseFragment implements SampleView {

    @Inject
    SamplePresenter mSamplePresenter;

    @Override
    protected boolean onInjectView() throws IllegalStateException {
        getComponent(SampleComponent.class).inject(this);
        return true;
    }

    @Override
    protected void onViewInjected(Bundle savedInstanceState) {
        super.onViewInjected(savedInstanceState);
        this.mSamplePresenter.setView(this);
    }
}

How to mock final class with Mockito 2 on Java Module in Android project?

Copy

Download

compile "org.mockito:mockito-core:$mockito_version"

compile "org.mockito:mockito-inline:$mockito_version"

-----------------------

compile "org.mockito:mockito-core:$mockito_version"

compile "org.mockito:mockito-inline:$mockito_version"

Publish to specific Observer using PublishSubject

Copy

Download

public class DataStore {

    private PublishSubject<DataItem> dataItemPublishSubject = PublishSubject.create();

    public Flowable<DataItem> getAllObservable() {
        return dataItemPublishSubject.toFlowable(BackpressureStrategy.BUFFER);
    }

    public Flowable<DataItem> getPopularObservable() {
        return dataItemPublishSubject.toFlowable(BackpressureStrategy.BUFFER)
                .filter(new Predicate<DataItem>() {
                    @Override
                    public boolean test(DataItem dataItem) throws Exception {
                        return dataItem.popular;
                    }
                });
    }

    public static class DataItem {
        public final boolean popular;

        public DataItem(boolean popular) {
            this.popular = popular;
        }
    }
}

    dataStore.getAllObservable()
            .doOnNext(new Consumer<DataStore.DataItem>() {
                @Override
                public void accept(DataStore.DataItem dataItem) throws Exception {
                    pagerAdapter.addDataAll(dataItem);      
                }
            })
            .filter(new Predicate<DataStore.DataItem>() {
                @Override
                public boolean test(DataStore.DataItem dataItem) throws Exception {
                    return dataItem.popular;
                }
            })
            .doOnNext(new Consumer<DataStore.DataItem>() {
                @Override
                public void accept(DataStore.DataItem dataItem) throws Exception {
                    pagerAdapter.addDataPopular(dataItem);
                }
            })
            .subscribe();

-----------------------

public class DataStore {

    private PublishSubject<DataItem> dataItemPublishSubject = PublishSubject.create();

    public Flowable<DataItem> getAllObservable() {
        return dataItemPublishSubject.toFlowable(BackpressureStrategy.BUFFER);
    }

    public Flowable<DataItem> getPopularObservable() {
        return dataItemPublishSubject.toFlowable(BackpressureStrategy.BUFFER)
                .filter(new Predicate<DataItem>() {
                    @Override
                    public boolean test(DataItem dataItem) throws Exception {
                        return dataItem.popular;
                    }
                });
    }

    public static class DataItem {
        public final boolean popular;

        public DataItem(boolean popular) {
            this.popular = popular;
        }
    }
}

    dataStore.getAllObservable()
            .doOnNext(new Consumer<DataStore.DataItem>() {
                @Override
                public void accept(DataStore.DataItem dataItem) throws Exception {
                    pagerAdapter.addDataAll(dataItem);      
                }
            })
            .filter(new Predicate<DataStore.DataItem>() {
                @Override
                public boolean test(DataStore.DataItem dataItem) throws Exception {
                    return dataItem.popular;
                }
            })
            .doOnNext(new Consumer<DataStore.DataItem>() {
                @Override
                public void accept(DataStore.DataItem dataItem) throws Exception {
                    pagerAdapter.addDataPopular(dataItem);
                }
            })
            .subscribe();

RxJava polling + manual refresh

Copy

Download

    // Specific example of a user manually requesting
    val request = Observable.create<String> { emitter ->
        refresh.setOnClickListener {
            emitter.onNext("Click Request")
        }
    }
            .observeOn(Schedulers.io())
            .flatMap {
                userRepository.users()
            }

    // Refresh based off of your original work, could use something like interval as well
    val interval = userRepository.users()
            .subscribeOn(Schedulers.io())
            .repeatWhen { objectObservable ->
                objectObservable.delay(1, TimeUnit.MINUTES)
            }

    // Combine them so that both emissions are received you can even add on another source
    Observable.merge(request,interval)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe({
                contents.text = it.toString()
            }, {
                contents.text = it.toString()
            },{
                println(contents.text)
            })

-----------------------

@Test
public void intervalObservableAndImmediateReaction() throws InterruptedException {
    Observable<String> obs = Observable.interval(1, TimeUnit.SECONDS)
                .cast(Object.class)                                          
                .mergeWith(
                          Observable.just("mockedUserClick")
                                    .delay(500, TimeUnit.MILLISECONDS))
                .flatMap(
                         timeOrClick -> Observable.just("Generated upon subscription")
                         );

    obs.subscribe(System.out::println);
    Thread.currentThread().sleep(3000); //to see the prints before ending the test
}

Observable.interval(1, TimeUnit.MINUTES)
            .mergeWith(RxView.clicks(buttonView))
            .flatMap(timeOrClick -> this.userRepository.users());

RxView.touches(yourViewVariable)
      .flatMatp(motionEvent -> this.userRepository.users())
      .subscribe(theObserver);

-----------------------

@Test
public void intervalObservableAndImmediateReaction() throws InterruptedException {
    Observable<String> obs = Observable.interval(1, TimeUnit.SECONDS)
                .cast(Object.class)                                          
                .mergeWith(
                          Observable.just("mockedUserClick")
                                    .delay(500, TimeUnit.MILLISECONDS))
                .flatMap(
                         timeOrClick -> Observable.just("Generated upon subscription")
                         );

    obs.subscribe(System.out::println);
    Thread.currentThread().sleep(3000); //to see the prints before ending the test
}

Observable.interval(1, TimeUnit.MINUTES)
            .mergeWith(RxView.clicks(buttonView))
            .flatMap(timeOrClick -> this.userRepository.users());

RxView.touches(yourViewVariable)
      .flatMatp(motionEvent -> this.userRepository.users())
      .subscribe(theObserver);

-----------------------

@Test
public void intervalObservableAndImmediateReaction() throws InterruptedException {
    Observable<String> obs = Observable.interval(1, TimeUnit.SECONDS)
                .cast(Object.class)                                          
                .mergeWith(
                          Observable.just("mockedUserClick")
                                    .delay(500, TimeUnit.MILLISECONDS))
                .flatMap(
                         timeOrClick -> Observable.just("Generated upon subscription")
                         );

    obs.subscribe(System.out::println);
    Thread.currentThread().sleep(3000); //to see the prints before ending the test
}

Observable.interval(1, TimeUnit.MINUTES)
            .mergeWith(RxView.clicks(buttonView))
            .flatMap(timeOrClick -> this.userRepository.users());

RxView.touches(yourViewVariable)
      .flatMatp(motionEvent -> this.userRepository.users())
      .subscribe(theObserver);

Kotlin+Mockito2: ClassNotFoundException for presenter tests

Copy

Download

sourceSets {
    main.java.srcDirs += 'src/main/java'
    main.java.srcDirs += [file("$buildDir/generated/source/kapt/main")]
    main.java.srcDirs += '../data/src/main/java'
    main.java.srcDirs += '../entities/src/main/java'
    main.java.srcDirs += '../domain/src/main/java'
  }

execute multiple Subscribers rxjava

Copy

Download

@Test
public void name() throws Exception {
    Observable<SearchResponseDomain> departureTrip = getCompanies();
    Observable<SearchResponseDomain> returnTrip = getCompanies();

    // Subs. to both observables. If one finishes -> whole stream closes
    Observable<List<SearchResponseDomain>> zip = Observable.zip(departureTrip, returnTrip, (d, r) -> {
        return Arrays.asList(d, r);
    });

    // Subscribe
    zip.observeOn(AndroidSchedulers.mainThread())
            .subscribe(searchResponseDomain -> {
                // show stuff in UI
            });

}

// TODO: add params to getCompanies...
private Observable<SearchResponseDomain> getCompanies() {
    return Observable.just(new SearchResponseDomain());
}

class SearchResponseDomain {

}

How can I trigger a model to give new data when a save occurs

Copy

Download

return bookRepository.getLibrary()
        .repeatWhen(e -> eventBus.toObservable()
                .filter(event -> event.equals(LIBRARY_CHANGED)));

public class EventBus {

    private final PublishSubject<Object> _bus = PublishSubject.create();

    public void post(Object event) {
        _bus.onNext(event);
    }

    public Observable<Object> toObservable() {
        return _bus;
    }
}

repository.searchLibrary(params.searchTerm)
    .doOnComplete(() -> eventBus.post(LIBRARY_CHANGED));

-----------------------

return bookRepository.getLibrary()
        .repeatWhen(e -> eventBus.toObservable()
                .filter(event -> event.equals(LIBRARY_CHANGED)));

public class EventBus {

    private final PublishSubject<Object> _bus = PublishSubject.create();

    public void post(Object event) {
        _bus.onNext(event);
    }

    public Observable<Object> toObservable() {
        return _bus;
    }
}

repository.searchLibrary(params.searchTerm)
    .doOnComplete(() -> eventBus.post(LIBRARY_CHANGED));

-----------------------

return bookRepository.getLibrary()
        .repeatWhen(e -> eventBus.toObservable()
                .filter(event -> event.equals(LIBRARY_CHANGED)));

public class EventBus {

    private final PublishSubject<Object> _bus = PublishSubject.create();

    public void post(Object event) {
        _bus.onNext(event);
    }

    public Observable<Object> toObservable() {
        return _bus;
    }
}

repository.searchLibrary(params.searchTerm)
    .doOnComplete(() -> eventBus.post(LIBRARY_CHANGED));

See all related Code Snippets

Community Discussions

Trending Discussions on Android-CleanArchitecture

In clean MVP, who should handle combining interactors?
Making synchronous calls to Cloud Firestore when running off the main thread
disjoint union in Kotlin to get access in Java
Clean architecture: Use CompositeDisposable in domain or presentation/app
How to setup a project for Clean architecture in gradle?
Getting NullPointException when using Dagger2 and setRetainInstance(true);
How to mock final class with Mockito 2 on Java Module in Android project?
Android app clean architecture: Should data layer have its own model classes?
Android library module does not compile when using classes from pure Kotlin module
Publish to specific Observer using PublishSubject

Trending Discussions on Android-CleanArchitecture

QUESTION

In clean MVP, who should handle combining interactors?

Asked 2019-Apr-12 at 16:21

I've seen good examples of MVP architecture (here and here). Both present only simple interactors, but I wonder how to deal with more complex use case, consisting of steps, which are repeated in other use cases.

For example, my API requires token to authenticate any call. I've created an interactor to get that token (GetToken). I want to get user's last login date (GetLastLoginDate) and then fetch a list of changes that occured between that date and now (GetVersionChanges).

Where those interactor should be chained? I want to keep them separate, because some of them are reused in other parts of the code. I've came up with two solutions.

Presenter should chain all interactors. This solution works as long the use case is not complex and doesn't have many preconditions. It seems to me it's not the right place, because it burdens presenter with another responsibility.
Interactor can use many repositories (no clean architecture rules are broken then). Why not use TokenRepository in other interactors? Because getting token is much more complex than just reaching to repository. Repeating the steps in other interactor does not reuse already existing code.

Both solutions have their flaws and are against basic principles (DRY, single responsibility principle).

ANSWER

Answered 2019-Apr-12 at 16:21

If I were you I would just put the logic of getting a token in a separate interactor (maybe named getTokenInteractor) and call that interactor from your others interactor who may need it. That way, it would be in an interactor that you chose either to use a token (and call or not your getTokenInteractor) and also in an interactor that you retrieve it and deal with errors. I would do the same for your "getVersionChanges" use case and let an interactor chain the calls.

Let's imagine you have a presenter who needs to display the version changes. He will call a first interactor (GetVersionChangesInteractor) who will first check if he has a token (by calling getTokenInteractor), then call GetLastLoginDateRepository for retrieving the date, and call GetVersionChangesRepository with that date and finally give the result to your presenter.

That way, your business logic can stay 100% in your interactor and your presenter can focus on how he will display that on screen.

By the way, if your API needs a token for every call you should move it in an Interceptor so you do not have to deal with it at every call.

Source https://stackoverflow.com/questions/47868684

QUESTION

Making synchronous calls to Cloud Firestore when running off the main thread

Asked 2019-Feb-27 at 13:31

I am building an app based off of the Android Clean Architecture Kotlin version (https://github.com/android10/Android-CleanArchitecture-Kotlin).

Using this architecture, each time you want to invoke a use case, a Kotlin coroutine is launched and the result is posted in the main thread. This is achieved by this code:

abstract class UseCase<out Type, in Params> where Type : Any {

abstract suspend fun run(params: Params): Either<Failure, Type>

fun execute(onResult: (Either<Failure, Type>) -> Unit, params: Params) {
    val job = async(CommonPool) { run(params) }
    launch(UI) { onResult.invoke(job.await()) }
}

In his example architecture, Mr. Android10 uses Retrofit to make a synchronous api call inside the kotlin couroutine. For example:

override fun movies(): Either<Failure, List<Movie>> {
            return when (networkHandler.isConnected) {
                true -> request(service.movies(), { it.map { it.toMovie() } }, emptyList())
                false, null -> Left(NetworkConnection())
            }
        }

private fun <T, R> request(call: Call<T>, transform: (T) -> R, default: T): Either<Failure, R> {
            return try {
                val response = call.execute()
                when (response.isSuccessful) {
                    true -> Right(transform((response.body() ?: default)))
                    false -> Left(ServerError())
                }
            } catch (exception: Throwable) {
                Left(ServerError())
            }
        }

'Either' represents a disjoint type, meaning the result will either be a Failure or the object of type T you want.

His service.movies() method is implemented like so (using retrofit)

@GET(MOVIES) fun movies(): Call<List<MovieEntity>>

Now here is my question. I am replacing retrofit with Google Cloud Firestore. I know that currently, Firebase/Firestore is an all async library. I want to know if anyone knows of a method more elegant way of making a synchronous API call to Firebase.

I implemented my own version of Call:

interface Call<T: Any> {
    fun execute(): Response<T>

    data class Response<T>(var isSuccessful: Boolean, var body: T?, var failure: Failure?)
}

and my API call is implemented here

override fun movieList(): Call<List<MovieEntity>> = object : Call<List<MovieEntity>> {
        override fun execute(): Call.Response<List<MovieEntity>> {
            return movieListResponse()
        }
    }

    private fun movieListResponse(): Call.Response<List<MovieEntity>> {
        var response: Call.Response<List<MovieEntity>>? = null
        FirebaseFirestore.getInstance().collection(DataConfig.databasePath + MOVIES_PATH).get().addOnCompleteListener { task ->
            response = when {
                !task.isSuccessful -> Call.Response(false, null, Failure.ServerError())
                task.result.isEmpty -> Call.Response(false, null, MovieFailure.ListNotAvailable())
                else -> Call.Response(true, task.result.mapTo(ArrayList()) { MovieEntity.fromSnapshot(it) }, null)
            }
        }
        while (response == null)
            Thread.sleep(50)

        return response as Call.Response<List<MovieEntity>>
    }

Of course, the while loop at the end bothers me. Is there any other, more elegant ways, to wait for the response to be assigned before returning from the movieListResponse method?

I tried calling await() on the Task that is returned from the Firebase get() method, but the movieListResponse method would return immediately anyway. Thanks for the help!

ANSWER

Answered 2018-Jun-13 at 00:59

That's is not the way how firebase works. Firebase is based on callback.

I recommend architecture component's livedata.

Please check the following example.

here is a link: https://android.jlelse.eu/android-architecture-components-with-firebase-907b7699f6a0

Source https://stackoverflow.com/questions/50825802

QUESTION

Clean architecture: Use CompositeDisposable in domain or presentation/app

Asked 2018-Aug-07 at 04:34

I just start learn and apply CleanArchitecture for my Android project.
I see there are 2 great source for following here
1) https://github.com/android10/Android-CleanArchitecture
2) https://github.com/fiveagency/Reedly (https://five.agency/android-architecture-part-4-applying-clean-architecture-on-android-hands-on/)

Currently, the first source use the CompositeDisposable in domain (inside UseCase) and the second source use in presentation/app(Presenter/ViewModel)

As my current understand, I see the benefit when we put CompositeDisposable in Presenter/ViewModel.

Easy to dispose (because if we CompositeDisposable in UseCase, for each UseCase we need to dispose call 1 time)
May easy to combine many UseCase (eg: UseCase1 execute then flatMap/zip... with UseCase2)

I see the benefit when we put CompositeDisposable in UseCase

It separate RX from presentation

I don't know if is there any other pros/cons of 2 approach. I never use CleanArchitecture for real project and I know when we follow any approach, it's quite hard to change to another approach.

For me, currently I think I will choose: put CompositeDisposable in UseCase. What should I use? Is there any other approach?
Any help or advice would be great appreciated.

ANSWER

Answered 2018-Aug-07 at 04:34

When it comes to clean architecture, I have been using 1) Android-CleanArchitecture for about a year now. And when it comes to disposing CompositeDisposable, I would do it in Presenter if I were you, because it is closely related to life-cycle of View and it controls data flow which CompositeDisposable in this case kind of belongs to.

Suggestion:

Convert 1) Android-CleanArchitecture from MVP to MVVM in Presentation layer with ViewModels and dispose your CompositeDisposable there. MVVM with Googles new ViewModel library eliminates headaches of managing life-cylce dependent objects yourself, which MVP in this CleanArchitecutre template fails to deliver.

Hope this cleared things up a bit. Good Luck :)

Source https://stackoverflow.com/questions/51630508

QUESTION

Getting NullPointException when using Dagger2 and setRetainInstance(true);

Asked 2018-Jan-26 at 10:45

So I was following Clean Architecture to design my application. I have an Activity with a view pager which has two Fragment in it. Im injecting the PagerAdapter for this through Dagger.

I understand that calling setRetainInstance(true) on a fragment prevents it from getting destroyed, and that getActivity() on such fragment may return a problem if the Activity is destroyed. I'm getting a NullPointException when trying to resume my activity after it has been on background and the activity has been (presumably) destroyed.

So my question is

Is there a better way to accomplish what I'm trying to do?
Any resource someone can point me to?
Also uncertain why the Fragment and the Adapter is still active if the fragment has been destroyed. I get no memory leaks with LeakCanary.

My activity has an Dagger Component MainActivityComponent which is injected as follows. And also extends HasComponent. For more info on this refer to HasComponent

MainActivity.java

DaggerMainActivityComponent.builder()
 .applicationComponent(getApplicationComponent())
 .activityModule(getActivityModule())
 // Module for each fragment
 .conversationListModule(new ConversationListModule(this)) 
 .friendsListModule(new FriendsListModule(this))
 .build()
 .inject(this);

Getting the Activity's component

// Cause of the NullPointException getActivity()
protected <C> C getComponent(Class<C> componentType) {
    return componentType.cast(((HasComponent<C>) getActivity()).getComponent());
}

Let me know if you guys have any confusion. I know my explanation is a mess. Thanks

Update

Seems even if I remove setRetainInstance(true) this error isn't prevented.

ANSWER

Answered 2018-Jan-26 at 10:45

Problem

The problem occured when the application stays in the background for a while and a recently displayed activity is recycled by Android. Bringing back the application causes NullPointerException (NPE) as the activity’s component is called by the fragment before it is initialized (both fragment and activity are recreated at the same time).

Solution

Introducing two lifecycle methods in BaseFragment class.

onInjectView() — called to do an optional injection on onCreate(Bundle) and if an exception is thrown or false returned, it is called on onActivityCreated(Bundle) again. Within this method you can get the injection component and inject the view. Retrun true if the injection was succesfull, then it will not be called again.
Based on returned value, the second method is called. The method is named onViewInjected(Bundle), as it is called only when the fragment has been injected and injected fields can be initialized.

Base Fragment

public abstract class BaseFragment extends Fragment {

    private boolean mIsInjected = false;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);

        try {
            mIsInjected = onInjectView();
        } catch (IllegalStateException e) {
            Log.e(e.getClass().getSimpleName(), e.getMessage());
            mIsInjected = false;
        }
    }

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        if (mIsInjected) onViewInjected(savedInstanceState);
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        if (!mIsInjected) {
            mIsInjected = onInjectView();
            if (mIsInjected) onViewInjected(savedInstanceState);
        }
    }

    @SuppressWarnings("unchecked")
    protected <C> C getComponent(Class<C> componentType) throws IllegalStateException {
        C component = componentType.cast(((HasComponent<C>) getActivity()).getComponent());
        if (component == null) {
            throw new IllegalStateException(componentType.getSimpleName() + " has not been initialized yet.");
        }
        return component;
    }


    protected boolean onInjectView() throws IllegalStateException {
        // Return false by default.
        return false;
    }

    @CallSuper
    protected void onViewInjected(Bundle savedInstanceState) {
        // Intentionally left empty.
    }
 }

Usage

public class SampleFragment extends BaseFragment implements SampleView {

    @Inject
    SamplePresenter mSamplePresenter;

    @Override
    protected boolean onInjectView() throws IllegalStateException {
        getComponent(SampleComponent.class).inject(this);
        return true;
    }

    @Override
    protected void onViewInjected(Bundle savedInstanceState) {
        super.onViewInjected(savedInstanceState);
        this.mSamplePresenter.setView(this);
    }
}

More info can be found on Efficient and bug-free fragment injection in Android MVP applications

Source https://stackoverflow.com/questions/47406449

QUESTION

Android app clean architecture: Should data layer have its own model classes?

Asked 2017-Dec-20 at 11:05

What´s the best approach when developing an Android app and trying to follow clean architecture guidelines (but not extremely strict - cause that may be overkill for smaller projects).

In my case, I am unsure which approach is the best (if there is a best one) regarding the data layer and if the data layer should operate on its own model classes or if it may operate directly on the domain layer models.

Also, if the data layer should operate on its own model classes, should data sources like DB or API have their own models (like for an API using Retrofit and Gson a model class with Gson annotations) and then map to data layer models OR should the data layer model itself be the model returned by DB and API (this means the data layer model must be annotated for Gson being able to parse it in case of Retrofit and Gson).

This is the case in this project: https://github.com/android10/Android-CleanArchitecture/blob/master/data/src/main/java/com/fernandocejas/android10/sample/data/entity/UserEntity.java

The following images should clarify the 3 approaches I mean:

In Image 1 the DB and API return specific model classes. In the case of the API it may look like (using Retrofit and Gson):

class ArticleResponse(@SerializedName("source") val source: SourceResponse,
                          @SerializedName("author") val author: String?,
                          @SerializedName("title") val title: String,
                          @SerializedName("description") val description: String?,
                          @SerializedName("url") val url: String,
                          @SerializedName("urlToImage") val urlToImage: String?,
                          @SerializedName("publishedAt") val publishedAt: String?)

These are then mapped by the Local/Remote data sources to Article models (which are used by the domain layer). Therefore the repository operates on domain layer models and is breaking boundaries right? That is approach 1.

In Image 2 the DB and API still return specific model classes. In the case of the API it may look like (using Retrofit and Gson):

class ArticleResponse(@SerializedName("source") val source: SourceResponse,
                              @SerializedName("author") val author: String?,
                              @SerializedName("title") val title: String,
                              @SerializedName("description") val description: String?,
                              @SerializedName("url") val url: String,
                              @SerializedName("urlToImage") val urlToImage: String?,
                              @SerializedName("publishedAt") val publishedAt: String?)

However, these models are then mapped to a data-layer model (ArticleEntity) which the data-layer operates on. When responding to the domain-layer the repository maps these ArticleEntity´s to the domain-layer model Article. This doesn´t break boundaries (right) but it needs some extra mapping in the data-layer. This is approach 2.

In Image 3 the DB and API already return the data-layer model ArticleEntity. Therefore this model class must contain all annotations needed to parse the API request (with Gson):

class ArticleEntity(@SerializedName("source") val source: SourceResponse,
                                  @SerializedName("author") val author: String?,
                                  @SerializedName("title") val title: String,
                                  @SerializedName("description") val description: String?,
                                  @SerializedName("url") val url: String,
                                  @SerializedName("urlToImage") val urlToImage: String?,
                                  @SerializedName("publishedAt") val publishedAt: String?)

If the DB also needs some kind of annotations then these would have to be added to this class too (right?). An advantage of this approach I can think of is that there are fewer model classes (because DB and API directly map to data-layer models). However, doesn´t this blow up the data-layer model class with annotations/properties from all different data sources (DB, API)? Isn´t the whole point of abstracting the data sources from the repository violated then because the data-layer model is dependent on the specific data source implementation (e.g using Gson to parse API request with exact API response names). So this was approach 3.

My question is: Which of the 3 approaches is the most flexible and future proof one?

ANSWER

Answered 2017-Dec-20 at 11:05

If I were you, I would go with the Image1 process. I think it is the job of your datasource to take whatever object is coming from your database or API or any endpoint you have and transform it into something easier to user in your repository.

Between Image1 and Image2, I think it depend of what data you want to store and what is the object you want to store. You may or may not need an ArticleEntity depending of your business rules. And if you don't need it, you don't have to create one.

But for some use case you may need to create that object to add some informations to your Article. For exemple, if you want to place in that a validity date or any other information that you will only use in your repository, you can go for Image2.

Source https://stackoverflow.com/questions/47903739

QUESTION

Android library module does not compile when using classes from pure Kotlin module

Asked 2017-Oct-04 at 13:10

I have a project using this structure: https://github.com/android10/Android-CleanArchitecture, and I am trying to convert it to Kotlin.

The domain module compiles just fine, but when I try compile the data module I get the following error:

Unresolved reference: ThreadExecutor`

and some other similar errors.

These errors are about interfaces, dataclass or Dagger singletons. It seems that the data module cannot find some objects from the domain module (though IntelliJ is not showing any error in the editor).

Here is the ThreadExecutor interface:

package com.company.app.domain.executor

import java.util.concurrent.Executor

interface ThreadExecutor : Executor

The domain module build.gradle file:

apply plugin: 'java'
apply plugin: 'kotlin'

//noinspection GroovyUnusedAssignment
sourceCompatibility = JavaVersion.VERSION_1_7
//noinspection GroovyUnusedAssignment
targetCompatibility = JavaVersion.VERSION_1_7

buildscript {
    repositories {
        mavenCentral()
    }
}

dependencies {
    testCompile 'junit:junit:4.12'
    compile 'io.reactivex.rxjava2:rxjava:2.1.3'
    compile 'io.reactivex.rxjava2:rxkotlin:2.1.0'
    compile 'com.google.guava:guava:22.0-android'
    compile 'javax.inject:javax.inject:1'
    compile 'joda-time:joda-time:2.9.9'
}
repositories {
    mavenCentral()
}
compileKotlin {
    kotlinOptions {
        jvmTarget = "1.6"
    }
}
compileTestKotlin {
    kotlinOptions {
        jvmTarget = "1.6"
    }
}

The global project build.gradle file:

// Top-level build file where you can add configuration options common to all sub-projects/modules.
apply plugin: 'kotlin'

buildscript {
    ext.kotlin_version = '1.1.4-3'

    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.3'
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

allprojects {
    repositories {
        jcenter()
        mavenCentral()
    }

    configurations.all {
        resolutionStrategy.force 'com.google.code.findbugs:jsr305:2.0.1'
    }
}

clean {
    delete rootProject.buildDir
}

And finally the data module build.gralde:

buildscript {
    repositories {
        mavenCentral()
    }
}

apply plugin: 'com.android.library'
apply plugin: 'kotlin-android'

android {
    publishNonDefault true

    compileSdkVersion 26
    buildToolsVersion "26.0.1"

    defaultConfig {
        minSdkVersion 23
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_7
        targetCompatibility JavaVersion.VERSION_1_7
    }
}

dependencies {
    compile project(':domain')
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
    compile 'io.reactivex.rxjava2:rxjava:2.1.3'
    compile 'io.reactivex.rxjava2:rxkotlin:2.1.0'
    compile 'com.google.code.gson:gson:2.8.1'
    compile 'com.squareup.okhttp3:okhttp:3.8.1'
    kapt 'com.google.dagger:dagger-compiler:2.11'
    compile 'com.google.dagger:dagger:2.11'
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:26.0.0-alpha1'
    testCompile 'junit:junit:4.12'
}

repositories {
    mavenCentral()
}

It looks like the domain jar compiled from Kotlin is not exposing these objects the way the data module expects to, but I currently have no clue as to why.

ANSWER

Answered 2017-Oct-04 at 13:10

I finally found why it was not compiling: I had to call "rebuild project" rather than "make project" in order for Android Studio to take all the changes into account.

Source https://stackoverflow.com/questions/46380379

QUESTION

Publish to specific Observer using PublishSubject

Asked 2017-Sep-24 at 10:11

I have a ViewPager with two pages namely Popular and All. What I'm trying to achieve is only push items that have popular tag true to Popular whereas push all items to All.

Currently I have a single class which is used in the PagerAdapter and passing in the page type. How do I filter out PublishSubject so that each page only displays necessary items accordingly.

Both my Observer are subscribed to a single PublishSubject, but I want to filter when emitting.

Please comment if the question is unclear. I'll try my best to relay this problem. Also sorry if it has already been answered since I couldn't find anything relevant.

The code I'm using is this based on this architecture in which I have a Firebase data store FirebaseSubscriptionDataStore which provides the PublishSubject. This is later subscribed to by SubscribeToSubscriptionUpdates in SubscriptionListPresenterImpl

Thanks in advance.

ANSWER

Answered 2017-Sep-24 at 10:11

You can basically define two different methods to get Observable (or Flowable) from PublishSubject. First observable will emit all of the items and second one only popular ones:

public class DataStore {

    private PublishSubject<DataItem> dataItemPublishSubject = PublishSubject.create();

    public Flowable<DataItem> getAllObservable() {
        return dataItemPublishSubject.toFlowable(BackpressureStrategy.BUFFER);
    }

    public Flowable<DataItem> getPopularObservable() {
        return dataItemPublishSubject.toFlowable(BackpressureStrategy.BUFFER)
                .filter(new Predicate<DataItem>() {
                    @Override
                    public boolean test(DataItem dataItem) throws Exception {
                        return dataItem.popular;
                    }
                });
    }

    public static class DataItem {
        public final boolean popular;

        public DataItem(boolean popular) {
            this.popular = popular;
        }
    }
}

In case you don't want to two methods, you can move .filter() operator everywhere within you Rx chain and you might end up with something like this:

    dataStore.getAllObservable()
            .doOnNext(new Consumer<DataStore.DataItem>() {
                @Override
                public void accept(DataStore.DataItem dataItem) throws Exception {
                    pagerAdapter.addDataAll(dataItem);      
                }
            })
            .filter(new Predicate<DataStore.DataItem>() {
                @Override
                public boolean test(DataStore.DataItem dataItem) throws Exception {
                    return dataItem.popular;
                }
            })
            .doOnNext(new Consumer<DataStore.DataItem>() {
                @Override
                public void accept(DataStore.DataItem dataItem) throws Exception {
                    pagerAdapter.addDataPopular(dataItem);
                }
            })
            .subscribe();

Source https://stackoverflow.com/questions/46380716

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

No vulnerabilities reported

Install Android-CleanArchitecture

You can download it from GitHub.
You can use Android-CleanArchitecture like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the Android-CleanArchitecture component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .

Support

For any new features, suggestions and bugs create an issue on GitHub. If you have any questions check and ask questions on community page Stack Overflow .