Don't Make Android Bad... Again

Don’t Make Android Bad… Again

Pedro Vicente
Mobile Software Craftsman
Apps since ~2009
Self-organising company
…
Most beautiful person…ever
HIRING

2008
2008
Android
Android is
launched
September 2008!
Android Market
Goes live October
2008

AsyncTask ruled the (app) world!
• Callback hell
• Memory leaks
• Spaghetti code

https://thinkmobiles.com/blog/mvp-vs-mvvm-android-patterns/
Every app from 2008 to…

From: https://labs.ribot.co.uk/android-application-architecture-8b6e34acda65
Way to much
responsibilities:
1.Call the API and / or
cache
2. Handle success or
error (of both)
3.Transform the data
returned from the API
4.What happens if the
device rotates?
5. How to test all this?
6. And another N
number of issues..

Way to much
responsibilities:
cache
error (of both)
4.What happens if the
device rotates?
6. And another N
number of issues..
still

Way to much
responsibilities:
cache
error (of both)

Way to much
responsibilities:
cache
error (of both)
How to get bald 101
Actually…Actually…

Way to much
responsibilities:
cache
error (of both)
How to get bald 101

public class MyTodoActivity extends Activity {
...
public void onClickItem(String itemId){
new FetchTaskList().execute(itemId);
}
private class FetchItemDetail extends AsyncTask<String, Void, String> {
@Override
protected void onPreExecute() {
showLoading();
}
@Override
protected String doInBackground(String... params) {
if(cacheProvider.contains(params[0]){
return cacheProvider.get(params[0]);
}
Result result = apiProvider.getItemDetail(params[0])
if(result != null ... && result.success){
cacheProvider.set(params[0], result);
}else{
Log.e(LOG_TAG, "Houston we have a problem..");
}
return result;
}
@Override
protected void onPostExecute(String result) {
if(results != null){
showResults(transformResults(result));
}else{
showResultsError();
}
}
}
}

https://plus.google.com/+DianneHackborn/posts/FXCCYxepsDU

Architecture?
We have Activities,
AsyncTasks and
Services… what else do
we need?

V P M
user events updates model
updates view state change event

public class TasksFragment extends Fragment implements TasksContract.View {
private TasksContract.Presenter mPresenter;
private TasksAdapter mListAdapter;
private View mNoTasksView;
private ImageView mNoTaskIcon;
private TextView mNoTaskMainView;
private TextView mNoTaskAddView;
private LinearLayout mTasksView;
private TextView mFilteringLabelView;
...
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mListAdapter = new TasksAdapter(new ArrayList<Task>(0), mItemListener);
}
@Override
public void onResume() {
super.onResume();
mPresenter.start();
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View root = inflater.inflate(R.layout.tasks_frag, container, false);
// Set up tasks view
ListView listView = (ListView) root.findViewById(R.id.tasks_list);
listView.setAdapter(mListAdapter);
mFilteringLabelView = (TextView) root.findViewById(R.id.filteringLabel);
mTasksView = (LinearLayout) root.findViewById(R.id.tasksLL);
// Set up no tasks view
mNoTasksView = root.findViewById(R.id.noTasks);
mNoTaskIcon = (ImageView) root.findViewById(R.id.noTasksIcon);
mNoTaskMainView = (TextView) root.findViewById(R.id.noTasksMain);
mNoTaskAddView = (TextView) root.findViewById(R.id.noTasksAdd);
mNoTaskAddView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
showAddTask();
}
});
...
setHasOptionsMenu(true);
return root;
}
...
public class TasksPresenter implements TasksContract.Presenter {
private final TasksRepository mTasksRepository;
private final TasksContract.View mTasksView;
private TasksFilterType mCurrentFiltering = TasksFilterType.ALL_TASKS;
private boolean mFirstLoad = true;
public TasksPresenter(@NonNull TasksRepository tasksRepository,
@NonNull TasksContract.View tasksView) {
mTasksRepository = checkNotNull(tasksRepository, "tasksRepository cannot be null");
mTasksView = checkNotNull(tasksView, "tasksView cannot be null!");
mTasksView.setPresenter(this);
}
@Override
public void start() {
loadTasks(false);
}
@Override
public void result(int requestCode, int resultCode) {
// If a task was successfully added, show snackbar
if (AddEditTaskActivity.REQUEST_ADD_TASK == requestCode
&& Activity.RESULT_OK == resultCode) {
mTasksView.showSuccessfullySavedMessage();
}
}
@Override
public void loadTasks(boolean forceUpdate) {
// Simplification for sample: a network reload will be forced on first load.
loadTasks(forceUpdate || mFirstLoad, true);
mFirstLoad = false;
}
private void loadTasks(boolean forceUpdate, final boolean showLoadingUI) {
if (showLoadingUI) {
mTasksView.setLoadingIndicator(true);
}
if (forceUpdate) {
mTasksRepository.refreshTasks();
}
mTasksRepository.getTasks(new TasksDataSource.LoadTasksCallback() {
@Override
public void onTasksLoaded(List<Task> tasks) {
List<Task> tasksToShow = new ArrayList<Task>()
// We filter the tasks based on the requestType
for (Task task : tasks) {
switch (mCurrentFiltering) {
case ALL_TASKS:
tasksToShow.add(task);
break;
case ACTIVE_TASKS:
public class TasksRepository implements TasksDataSource {
private static TasksRepository INSTANCE = null;
private final TasksDataSource mTasksRemoteDataSource;
private final TasksDataSource mTasksLocalDataSource;
/**
* This variable has package local visibility so it can be accessed from tests.
*/
Map<String, Task> mCachedTasks;
/**
* Returns the single instance of this class, creating it if necessary.
*
* @param tasksRemoteDataSource the backend data source
* @param tasksLocalDataSource the device storage data source
* @return the {@link TasksRepository} instance
*/
public static TasksRepository getInstance(TasksDataSource tasksRemoteDataSource,
TasksDataSource tasksLocalDataSource) {
if (INSTANCE == null) {
INSTANCE = new TasksRepository(tasksRemoteDataSource, tasksLocalDataSource);
}
return INSTANCE;
}
/**
* Gets tasks from cache, local data source (SQLite) or remote data source, whichever is
* available first.
*/
@Override
public void getTasks(@NonNull final LoadTasksCallback callback) {
checkNotNull(callback);
// Respond immediately with cache if available and not dirty
if (mCachedTasks != null && !mCacheIsDirty) {
callback.onTasksLoaded(new ArrayList<>(mCachedTasks.values()));
return;
}
if (mCacheIsDirty) {
// If the cache is dirty we need to fetch new data from the network.
getTasksFromRemoteDataSource(callback);
} else {
// Query the local storage if available. If not, query the network.
mTasksLocalDataSource.getTasks(new LoadTasksCallback() {
@Override
refreshCache(tasks);
}
@Override
public void onDataNotAvailable() {
}

public class TasksFragment extends Fragment implements TasksContract.View {
private TasksContract.Presenter mPresenter;
private TasksAdapter mListAdapter;
private View mNoTasksView;
private ImageView mNoTaskIcon;
private TextView mNoTaskMainView;
private TextView mNoTaskAddView;
private LinearLayout mTasksView;
private TextView mFilteringLabelView;
...
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mListAdapter = new TasksAdapter(new ArrayList<Task>(0), mItemListener);
}
@Override
public void onResume() {
super.onResume();
mPresenter.start();
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View root = inflater.inflate(R.layout.tasks_frag, container, false);
// Set up tasks view
ListView listView = (ListView) root.findViewById(R.id.tasks_list);
listView.setAdapter(mListAdapter);
mFilteringLabelView = (TextView) root.findViewById(R.id.filteringLabel);
mTasksView = (LinearLayout) root.findViewById(R.id.tasksLL);
// Set up no tasks view
mNoTasksView = root.findViewById(R.id.noTasks);
mNoTaskIcon = (ImageView) root.findViewById(R.id.noTasksIcon);
mNoTaskMainView = (TextView) root.findViewById(R.id.noTasksMain);
mNoTaskAddView = (TextView) root.findViewById(R.id.noTasksAdd);
mNoTaskAddView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
showAddTask();
}
});
...
setHasOptionsMenu(true);
return root;
}
...
public class TasksPresenter implements TasksContract.Presenter {
private final TasksRepository mTasksRepository;
private final TasksContract.View mTasksView;
private TasksFilterType mCurrentFiltering = TasksFilterType.ALL_TASKS;
private boolean mFirstLoad = true;
public TasksPresenter(@NonNull TasksRepository tasksRepository, @NonNull TasksContract
mTasksRepository = checkNotNull(tasksRepository, "tasksRepository cannot be null");
mTasksView = checkNotNull(tasksView, "tasksView cannot be null!");
mTasksView.setPresenter(this);
}
@Override
public void start() {
loadTasks(false);
}
@Override
public void result(int requestCode, int resultCode) {
// If a task was successfully added, show snackbar
if (AddEditTaskActivity.REQUEST_ADD_TASK == requestCode && Activity.RESULT_OK == re
mTasksView.showSuccessfullySavedMessage();
}
}
@Override
public void loadTasks(boolean forceUpdate) {
// Simplification for sample: a network reload will be forced on first load.
loadTasks(forceUpdate || mFirstLoad, true);
mFirstLoad = false;
}
private void loadTasks(boolean forceUpdate, final boolean showLoadingUI) {
if (showLoadingUI) {
mTasksView.setLoadingIndicator(true);
}
if (forceUpdate) {
mTasksRepository.refreshTasks();
}
// The network request might be handled in a different thread so make sure Espresso know
// that the app is busy until the response is handled.
EspressoIdlingResource.increment(); // App is busy until further notice
mTasksRepository.getTasks(new TasksDataSource.LoadTasksCallback() {
@Override
List<Task> tasksToShow = new ArrayList<Task>()
// We filter the tasks based on the requestType
for (Task task : tasks) {
switch (mCurrentFiltering) {
case ALL_TASKS:
tasksToShow.add(task);
break;
public class TasksRepository implements TasksDataSource {
private static TasksRepository INSTANCE = null;
private final TasksDataSource mTasksRemoteDataSource;
private final TasksDataSource mTasksLocalDataSource;
/**
* This variable has package local visibility so it can be accessed from tests.
*/
Map<String, Task> mCachedTasks;
/**
* Returns the single instance of this class, creating it if necessary.
*
* @param tasksRemoteDataSource the backend data source
* @param tasksLocalDataSource the device storage data source
* @return the {@link TasksRepository} instance
*/
public static TasksRepository getInstance(TasksDataSource tasksRemoteDataSource,
TasksDataSource tasksLocalDataSource) {
if (INSTANCE == null) {
INSTANCE = new TasksRepository(tasksRemoteDataSource, tasksLocalDataSource);
}
return INSTANCE;
}
/**
* Gets tasks from cache, local data source (SQLite) or remote data source, whichever is
* available first.
*/
@Override
public void getTasks(@NonNull final LoadTasksCallback callback) {
checkNotNull(callback);
// Respond immediately with cache if available and not dirty
if (mCachedTasks != null && !mCacheIsDirty) {
return;
}
if (mCacheIsDirty) {
// If the cache is dirty we need to fetch new data from the network.
} else {
// Query the local storage if available. If not, query the network.
mTasksLocalDataSource.getTasks(new LoadTasksCallback() {
@Override
refreshCache(tasks);
}
@Override
public void onDataNotAvailable() {
}

Consists of Model, View, and Presenter layers;
View delegates user input to Presenter;
All layers should have a 1 to 1 relation;
View and Model aren’t tightly coupled (separation of concerns);
Easy unit testing (interface for Presenter layer is easily mocked);
MVP

Done!
Any questions?
made with keynote by andrew haskin

There are still dev pains to be addressed.

1:1 dependency
Lifecycle?
State on rotation?
State on rotation?
Testability?

1:1 dependency
Lifecycle?
State on rotation?
Testability?

1:1 dependency
Lifecycle?
Do we want to?
State on rotation?
Testability?

class MainPresenter(private val view: MainView) {
fun getWeather() {
view.changeText("Sunny weather in Porto!”")
}
interface MainView {
fun changeText(textValue: String)
}
}
class MainActivity : AppCompatActivity(), MainPresenter.MainView {
private val presenter = MainPresenter(this)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
presenter.getWeather()
}
override fun changeText(textValue: String) {
weatherTextView.text = textValue
}
}
class MainViewModel {
val weatherTextValue = “Sunny weather in Porto!”
}
class MainActivity : AppCompatActivity() {
val viewModel = MainViewModel()
weatherTextView.text = viewModel. weatherTextValue
}
}

1:N
Yes you’re right, this does not solve them all

Some assumptions…
It’s 2018.
You don’t live under a rock
You use (at least some of):

2008
2008
Android
Android is
launched
September 2008!
Android Market
Goes live October
2008
2018

Behavior
Download Manager
Media & Playback
Permissions
Notiﬁcations
Sharing
Slices

Foundation
AppCompat
Android KTX
Multidex
Test

UI
Animation & Transisiton 
Auto, TV & Wear
Emoji
Fragment
Layout
Palette

ArchitectureData Binding
Lifecycles
LiveData
Navigation
Paging
Room
ViewModel
WorkManager

Behavior
Architecture
UI
Foundation

Behavior
Architecture
UI
Foundation
Data Binding
Lifecycles
LiveData
Navigation
Paging
Room
ViewModel
WorkManager

@Inject lateinit var viewModelFactory: MainViewModelFactory
Dependencies.inject(this)
class MainViewModel(private val service: WeatherService)
: ViewModel() {
val weatherTextValue = MutableLiveData<String>()
val inProgress = MutableLiveData<Boolean>()
private var disposable: Disposable? = null
fun onRefreshWeatherClicked() {
inProgress.value = true
disposable = service.requestWeather()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(this::onWeatherResponse)
}
override fun onCleared() {
disposable?.dispose()
}
private fun onWeatherResponse(response: String) {
inProgress.value = false
weatherTextValue.value = response
}
}
val viewModel = viewModel.apply {
weatherTextValue.observe(this@MainActivity,
Observer { helloTextView.text = it })
inProgress.observe(this@MainActivity,
Observer { it?.let { progressBar.visibility =
if(it){ View.VISIBLE} else{ View.GONE} } })
}
button.setOnClickListener {
viewModel.onRefreshWeatherClicked() }
}
private val viewModel : MainViewModel by lazy{
ViewModelProviders.of(this, viewModelFactory)
.get(MainViewModel::class.java)
}

: ViewModel() {
}
}
}
}
Progress is
changed
}
}
}
User clicks
button

: ViewModel() {
}
}
}
}
}
}
}
That changes the
progress Since it’s
LiveData it’s
“pushed” to the
View

: ViewModel() {
}
}
}
}
}
}
}
The view is
updated
The request
ﬁnishes, updates
the progress and
text, LiveData
pushes it

: ViewModel() {
}
}
}
}
}
}
}

: ViewModel() {
}
}
}
}
}
}
}
Also with this
magic the
ViewModel
persists on
rotation
No need for
lifecycle, just
implement this
method and 💥

: ViewModel() {
}
}
}
}
val binding = MainActivityBinding
.inﬂate(LayoutInﬂater.from(this)
binding.setLifecycleOwner(this)
setContentView(binding.root)
binding.button.clicks()
.subscribe { viewModel.onRefreshWeatherClicked() }
}
}

<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto" >
<data>
<import type="android.view.View" />
<variable name="viewModel" type="my.package.viewmodel.MainViewModel" />
</data>
<android.support.v7.widget.CardView
android:layout_width="match_parent"
android:layout_height="wrap_content">
<android.support.constraint.ConstraintLayout
android:layout_height="wrap_content">
<ProgressBar
android:id="@+id/progress_bar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:indeterminate="true"
app:layout_constraintTop_toTopOf="parent"
android:text=“@{viewModel.inProgress ? View.VISIBLE : View.GONE}” />
<TextView
android:id=“@+id/weather_text_view”
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
app:layout_constraintTop_toBottomOf="@+id/progress_bar"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toLeftOf="@+id/button"
android:text=“@{viewModel.weatherTextValue}”/>
<Button
android:id="@+id/button"
android:layout_width="100dp"
android:layout_height=“wrap_content"
android:layout_gravity="center_horizontal"
app:layout_constraintTop_toBottomOf="@+id/progress_bar"
app:layout_constraintLeft_toRightOf="@+id/weather_text_view"
app:layout_constraintRight_toRightOf="parent"
android:text="Click me" />
</android.support.constraint.ConstraintLayout>
</android.support.v7.widget.CardView>
</layout>
}
}

With this you
easily get a lot of
magic UI!

: ViewModel() {
}
}
}
}
What if I don’t
have network and
want to wait for it
to update screen?
Because..
!
}
}

}
}
val constraints: Constraints = Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED)
.build()
val work: OneTimeWorkRequest = OneTimeWorkRequest
.Builder(PortugalChampionWorker::class.java)
.setConstraints(constraints).build()
WorkManager.getInstance().enqueue(work)
workId = work.id
WorkManager.getInstance().getStatusById(workId)
.observe(this, Observer { status ->
if (status?.state?.isFinished == true) {
val myResult = status.outputData.getString(KEY_RESULT,
myDefaultValue)
textValue.value = myResult
}
})
}
//Want to cancel when exiting screen?
workId?.let{
WorkManager.getInstance().cancelWorkById(it)
}
}
}
class PortugalChampionWorker : Worker() {
override fun doWork(): Result {
//No need for querying.. the result is clear.. success!
return Result.SUCCESS
}
}
Magic!
class MainViewModel(private val service: FootballService) : ViewModel() {
val textValue = MutableLiveData<String>()
val inProgress = MutableLiveData<Int>()
val workId : UUID? = null
fun onButtonClicked() {
inProgress.value = View.VISIBLE

val constraints: Constraints = Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED)
.build()
val work: OneTimeWorkRequest = OneTimeWorkRequest
.Builder(PortugalChampionWorker::class.java)
.setConstraints(constraints).build()
WorkManager.getInstance().enqueue(work)
workId = work.id
WorkManager.getInstance().getStatusById(workId)
.observe(this, Observer { status ->
if (status != null && status.state.isFinished) {
val myResult = status.outputData.getString(KEY_RESULT,
myDefaultValue)
textValue.value = myResult
}
})
}
//Want to cancel when exiting screen?
workId?.let{
WorkManager.getInstance().cancelWorkById(it)
}
}
}
class PortugalChampionWorker : Worker() {
override fun doWork(): Result {
//No need for querying.. the result is clear.. success!
return Result.SUCCESS
}
}
}
}
Hum… must ﬁnish?
You are kind of
bullshitting here,
aren’t you Pedro?
class MainViewModel(private val service: FootballService) : ViewModel() {
val textValue = MutableLiveData<String>()
val inProgress = MutableLiveData<Int>()
val workId : UUID? = null
fun onButtonClicked() {
inProgress.value = View.VISIBLE
But I forgive you!

Any questions?

Join us at 
Android Portugal Slack
http://bit.ly/AndroidPortugal

made with keynote
Thanks to
Andrew Haskin
Carlos Mota & Renato Almeida
Kamil Seweryninspiring article
review and opinions
base slides

Don't Make Android Bad... Again

Don't Make Android Bad... Again

More Related Content

What's hot

Similar to Don't Make Android Bad... Again

Recently uploaded

Don't Make Android Bad... Again