Modern Android Architecture

Modern Android Architecture
Eric Maxwell 
Product Engineer @ Realm 
Android & iOS Developer
Columbus Kotlin User Group Organizer

Architecture
MVC
MVP
MVVM
Uni-Directional
Reactive
Architecture Components

Architecture
I’m untestable
Nobody understands me!
I’m unmaintainable :-(

Architecture
I can be tested
New Developers know exactly
where all my parts are and
how to update me!!
I’m composable!

Architectures
Understand the principles and components
• MVC on Android
• MVP
• MVVM + Data Binding
• Reactive Architecture
• Android Architecture Components
• Lifecycle
• ViewModel
• LiveData
• Room
https://github.com/ericmaxwell2003/android-architecture-samples

MVC on Android
• Model
Data + State + Business logic
• View
User Interface, visual representation of the model
• Controller
Glue to coordinate interactions between the model and the view

MVC - Model
public class Board {
private Cell[][] cells = new Cell[3][3];
private Player winner;
private GameState state;
private Player currentTurn;
private enum GameState { IN_PROGRESS, FINISHED };
public Board() {...}
/**
* Restart or start a new game, will clear the board and win status
*/
public void restart() {...}
/**
* Mark the current row for the player who's current turn it is.
* Will perform no-op if the arguments are out of range or if that position is already played.
* Will also perform a no-op if the game is already over.
*
* @param row 0..2
* @param col 0..2
* @return the player that moved or null if we did not move anything.
*
*/
public Player mark( int row, int col ) {...}
public Player getWinner() {...}
private void clearCells() {...}
private void flipCurrentTurn() {...}
private boolean isValid(int row, int col ) {...}
private boolean isOutOfBounds(int idx){...}
private boolean isCellValueAlreadySet(int row, int col) {...}
private boolean isWinningMoveByPlayer(Player player, int currentRow, int currentCol) {...}
}
public class Cell {
private Player value;
public Player getValue() { return value; }
public void setValue(Player value) { this.value = value; }
}
public enum Player { X , O }

MVC - Controller
public class TicTacToeController extends AppCompatActivity {
private Board model;
private ViewGroup buttonGrid;
private View winnerPlayerViewGroup;
private TextView winnerPlayerLabel;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.tictactoe);
winnerPlayerLabel = (TextView) findViewById(R.id.winnerPlayerLabel);
...
model = new Board();
}
public void onCellClicked(View v) {
Button button = (Button) v;
String tag = button.getTag().toString();
int row = Integer.valueOf(tag.substring(0,1));
int col = Integer.valueOf(tag.substring(1,2));
Player playerThatMoved = model.mark(row, col);
if(playerThatMoved != null) {
button.setText(playerThatMoved.toString());
if (model.getWinner() != null) {
winnerPlayerLabel.setText(playerThatMoved.toString());
winnerPlayerViewGroup.setVisibility(View.VISIBLE);
}
}
}
private void reset() {
winnerPlayerViewGroup.setVisibility(View.GONE);
winnerPlayerLabel.setText("");
model.restart();
for( int i = 0; i < buttonGrid.getChildCount(); i++ ) {
((Button) buttonGrid.getChildAt(i)).setText("");
}
}
}

MVC - Testing Model
public class TicTacToeTests {
private Board board;
@Before
public void setup() {
board = new Board();
}
/**
* This test will simulate and verify x is the winner.
*
* X | X | X
* O | |
* | O |
*/
@Test
public void test3inRowAcrossTopForX() {
board.mark(0,0); // x
assertNull(board.getWinner());
board.mark(1,0); // o
board.mark(2,1); // o
assertEquals(Player.X, board.getWinner());
}
/**
* This test will simulate and verify o is the winner.
*
* O | X | X
* | O |
* | X | O
*/
@Test
public void test3inRowDiagonalFromTopLeftToBottomForO() {...}
}

MVC - Testing Controller
@Override
...
}
}
}
}
model.restart();
}
}
}

MVC - Testing Controller
@Override
...
}
}
}
}
model.restart();
}
}
}
Views, Lifecycle, Interactions  
all need mocked

MVP
• Model
• View
User Interface, visual representation of the model
• Presenter
Glue to coordinate interactions between the model and the view 
Tells the View what to do, not how to do it!

MVP - Model
/**
*/
/**
*
* @param row 0..2
* @param col 0..2
*
*/
}
public class Cell {
}

MVP - Controller
@Override
...
}
}
}
}
model.restart();
}
}
}

MVP - Presenter
public class TicTacToeActivity extends AppCompatActivity implements TicTacToeView {
private static String TAG = TicTacToeActivity.class.getName();
TicTacToePresenter presenter = new TicTacToePresenter(this);
@Override
...
presenter.onCreate();
}
@Override
protected void onPause() {
super.onPause();
presenter.onPause();
}
@Override
protected void onResume() {
super.onResume();
presenter.onResume();
}
@Override
protected void onDestroy() {
super.onDestroy();
presenter.onDestroy();
}
Log.i(TAG, "Click Row: [" + row + "," + col + "]");
presenter.onButtonSelected(row, col);
}
// View Interface Implementation
public void setButtonText(int row, int col, String text) {...}
public void clearButtons() {...}
public void showWinner(String winningPlayerDisplayLabel) {...}
public void clearWinnerDisplay() {...}
}
View
public class TicTacToePresenter extends Presenter {
private TicTacToeView view;
public TicTacToePresenter(TicTacToeView view) {
this.view = view;
this.model = new Board();
}
@Override
public void onCreate() {
}
public void onButtonSelected(int row, int col) {
view.setButtonText(row, col, playerThatMoved.toString());
view.showWinner(playerThatMoved.toString());
}
}
}
public void onResetSelected() {
view.clearWinnerDisplay();
view.clearButtons();
model.restart();
}
}
public abstract class Presenter {
public void onCreate() {}
public void onPause() {}
public void onResume() {}
public void onDestroy() {}
}
Presenter

MVP - Presenter
public class TicTacToeActivity extends AppCompatActivity implements TicTacToeView {
private static String TAG = TicTacToeActivity.class.getName();
TicTacToePresenter presenter = new TicTacToePresenter(this);
@Override
...
presenter.onCreate();
}
@Override
super.onPause();
presenter.onPause();
}
@Override
super.onResume();
presenter.onResume();
}
@Override
super.onDestroy();
presenter.onDestroy();
}
Log.i(TAG, "Click Row: [" + row + "," + col + "]");
}
// View Interface Implementation
public void setButtonText(int row, int col, String text) {...}
public void clearButtons() {...}
public void showWinner(String winningPlayerDisplayLabel) {...}
public void clearWinnerDisplay() {...}
}
View
public class TicTacToePresenter extends Presenter {
public TicTacToePresenter(TicTacToeView view) {
this.view = view;
this.model = new Board();
}
@Override
public void onCreate() {
}
public void onButtonSelected(int row, int col) {
view.setButtonText(row, col, playerThatMoved.toString());
view.showWinner(playerThatMoved.toString());
}
}
}
view.clearWinnerDisplay();
view.clearButtons();
model.restart();
}
}
public interface TicTacToeView {
void showWinner(String winningPlayerDisplayLabel);
void clearWinnerDisplay();
void clearButtons();
void setButtonText(int row, int col, String text);
}
Presenter

MVP - Testing Presenter
@RunWith(MockitoJUnitRunner.class)
public class TicTacToePresenterTests {
private TicTacToePresenter presenter;
@Mock
@Before
public void setup() { presenter = new TicTacToePresenter(view); }
/**
* This test will simulate and verify o is the winner.
*
* X | X | X
* O | |
* | O |
*/
@Test
clickAndAssertValueAt(0,0, "X");
verify(view, never()).showWinner(anyString());
clickAndAssertValueAt(1,0, "O");
verify(view).showWinner("X");
}
private void clickAndAssertValueAt(int row, int col, String expectedValue) {
verify(view).setButtonText(row, col, expectedValue);
}
}

MVVM + Data Binding
• Model
• View
Binds to observable variables and actions exposed by the ViewModel
• ViewModel
Responsible for wrapping the model and preparing observable data needed by the view. It also provides
hooks for the view to pass events to the model

MVVM - Model
/**
*/
/**
*
* @param row 0..2
* @param col 0..2
*
*/
}
public class Cell {
}

MVVM - ViewModel
public class TicTacToeActivity extends AppCompatActivity {
TicTacToeViewModel viewModel = new TicTacToeViewModel();
@Override
TictactoeBinding binding =
DataBindingUtil.setContentView(this, R.layout.tictactoe);
binding.setViewModel(viewModel);
viewModel.onCreate();
}
@Override
super.onPause();
viewModel.onPause();
}
@Override
super.onResume();
viewModel.onResume();
}
@Override
super.onDestroy();
viewModel.onDestroy();
}
}
View
public class TicTacToeViewModel extends ViewModel {
public final ObservableArrayMap<String, String> cells = new ObservableArrayMap<>();
public final ObservableField<String> winner = new ObservableField<>();
public TicTacToeViewModel() {
}
model.restart();
winner.set(null);
cells.clear();
}
public void onClickedCellAt(int row, int col) {
cells.put(…, …);
winner.set(…);
}
}
ViewModel
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<data>
<import type="android.view.View" />
<variable name="viewModel" type="com.acme.tictactoe.viewmodel.TicTacToeViewModel" />
</data>
...
<Button
style="@style/tictactoebutton"
android:onClick="@{() -> viewModel.onClickedCellAt(0,0)}"
android:text='@{viewModel.cells["00"]}' />
...
</layout>
Observing value of cells at key “00”
Invoke onClickedCellAt(0,0) on click

MVVM - Testing ViewModel
public class TicTacToeViewModelTests {
private TicTacToeViewModel viewModel;
@Before
public void setup() {
viewModel = new TicTacToeViewModel();
}
private void clickAndAssertValueAt(int row, int col, String expectedValue) {
viewModel.onClickedCellAt(row, col);
assertEquals(expectedValue, viewModel.cells.get("" + row + col));
}
/**
* This test will simulate and verify x is the winner.
*
* X | X | X
* O | |
* | O |
*/
@Test
assertNull(viewModel.winner.get());
assertEquals("X", viewModel.winner.get());
}
}

Checkpoint
• Understand the principles and components of
• MVC
• MVP
• MVVM
• Reactive / Uni-Directional
• Google Architecture Components

Concerns w/ MV[x]
2 States to maintain
Recreation from Big Nerd Ranch
Android Programming 3rd Edition
Chapter 2 [Android and MVC pg 38],
Controller littered with code to handle this  
(across threads)

Reactive Architecture
https://en.wikipedia.org/wiki/Model-view-controller
Uni Directional
Examples
• Flux/Redux
• Model View Intent
• Realm
• Uni-Directional Framework Post covering first 3 
http://bit.ly/2temW62
Characteristics
• Single State
• Data and interactions flow in 1 direction
• Reactive
• Asynchronous by nature

em@realm.io
https://developer.android.com/topic/libraries/architecture/index.html

Room
ViewModel
Lifecycle
LiveData
em@realm.io
Android Architecture Components
Modern Reactive Architecture

Lifecycle
class MyActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
public void onCreate(...) {
myLocationListener = new
MyLocationListener(this, (Message location) -> {
// update UI
});
}
public void onStart() {
super.onStart();
myLocationListener.start();
}
public void onStop() {
super.onStop();
myLocationListener.stop();
}
}
class MyLocationListener {
public MyLocationListener(
Context context, Callback callback) {
// ...
}
void start() {
// connect to system location service
}
void stop() {
// disconnect from system location service
}
}
Activity managing all the components

Lifecycle
Owner Component
Lifecycle Aware Components

Lifecycle
Owner
Component is aware of owners lifecycle
class CustomResultUserActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
public void onCreate(...) {
myLocationListener = new MyLocationListener(
this, getLifecycle(), location -> {
// update UI
});
Util.checkUserStatus(result -> {
if (result) {
myLocationListener.enable();
}
});
}
}

Lifecycle
Component is aware of owners lifecycle
class MyLocationListener implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_START)
private void start() {
if (enabled) {
// connect
}
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
private void stop() {
/* disconnect if connected */
}
public void enable() {
if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
/* connect if not connected */
}
}
Component

Lifecycle
Lifecycle Aware Components

ViewModel
em@realm.io
Configuration Changes Destroys Activities

ViewModel
em@realm.io
ViewModels
Survive Rotation

ViewModel
em@realm.iohttps://developer.android.com/topic/libraries/architecture/viewmodel.html#the_lifecycle_of_a_viewmodel

ViewModel
em@realm.io
public class MyActivity extends LifecycleActivity {
private MyViewModel mViewModel;
private TextView meTextView;
@Override
setContentView(R.layout.my_activity);
meTextView = (TextView) findViewById(R.id.books_tv);
// Android will instantiate my ViewModel, and the best part is
// the viewModel will survive configurationChanges!
mViewModel = ViewModelProviders.of(this).get(MyViewModel.class);
}
}
https://developer.android.com/topic/libraries/architecture/viewmodel.html#the_lifecycle_of_a_viewmodel

ViewModel
em@realm.io
public class MyActivity extends AppCompatActivity {
private MyViewModel mViewModel;
private TextView meTextView;
@Override
setContentView(R.layout.my_activity);
meTextView = (TextView) findViewById(R.id.books_tv);
// Android will instantiate my ViewModel, and the best part is
// the viewModel will survive configurationChanges!
mViewModel = ViewModelProviders.of(this).get(MyViewModel.class);
}
}
https://developer.android.com/topic/libraries/architecture/viewmodel.html#the_lifecycle_of_a_viewmodel

ViewModel
em@realm.io
public class MyViewModel extends ViewModel {
private Realm mDb;
public MyViewModel() {
// Initialization in construction
}
@Override
protected void onCleared() {
mDb.close();
}
}
public class MyViewModel extends AndroidViewModel {
private Realm mDb;
public MyViewModel(Application application) {
super(application);
}
@Override
protected void onCleared() {
mDb.close();
getApplication();
// Do something with the application
}
}
ViewModel Android ViewModel

LiveData
em@realm.io
• An observable value container
• Lifecycle Aware
• Any data can be represented as LiveData

LiveData
em@realm.io
• LiveData<String>
• LiveData<List<Dog>>
• CustomLiveData<Dog>

LiveData Transformations
em@realm.io
LiveData<List<LoanWithUserAndBook>> loanLiveData = mDb.loanModel().findLoansByNameAfter("Mike", getYesterdayDate());
// Instead of exposing the list of Loans, we can apply a transformation and expose Strings.
LiveData<String> stringLiveData = Transformations.map(loanLiveData, new Function<List<LoanWithUserAndBook>, String>() {
@Override
public String apply(List<LoanWithUserAndBook> loansWithUserAndBook) {
StringBuilder sb = new StringBuilder();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm",
Locale.US);
for (LoanWithUserAndBook loan : loansWithUserAndBook) {
sb.append(String.format("%sn (Returned: %s)n",
loan.bookTitle,
simpleDateFormat.format(loan.endTime)));
}
return sb.toString();
}
});
Map

LiveData
em@realm.io
Subscribing to LiveData
// Here an Activity, Subscribed to LiveData 
public class CustomResultUserActivity extends AppCompatActivity {
private CustomResultViewModel mShowUserViewModel;
private TextView mBooksTextView;
@Override
setContentView(R.layout.db_activity);
mBooksTextView = (TextView) findViewById(R.id.books_tv);
mShowUserViewModel = ViewModelProviders.of(this).get(CustomResultViewModel.class);
mShowUserViewModel.getLoansResult().observe(this, new Observer<String>() {
@Override
public void onChanged(@Nullable final String result) {
mBooksTextView.setText(result);
}
});
}
}

LiveData
em@realm.io
Subscribing to LiveData
// Here an Activity, Subscribed to LiveData 
public class CustomResultUserActivity extends AppCompatActivity {
private CustomResultViewModel mShowUserViewModel;
private TextView mBooksTextView;
@Override
setContentView(R.layout.db_activity);
mBooksTextView = (TextView) findViewById(R.id.books_tv);
mShowUserViewModel = ViewModelProviders.of(this).get(CustomResultViewModel.class);
mShowUserViewModel.getLoansResult().observe(this, new Observer<String>() {
@Override
public void onChanged(@Nullable final String result) {
mBooksTextView.setText(result);
}
});
}
}
LiveData respects
lifecycle of

LiveData
em@realm.io
public class RealmLiveData<T extends RealmModel> extends LiveData<RealmResults<T>> {
private RealmResults<T> mResults;
private RealmChangeListener<RealmResults<T>> listener = new RealmChangeListener<RealmResults<T>>() {
@Override
public void onChange(RealmResults<T> results) {
setValue(results);
}
};
public RealmLiveData(RealmResults<T> mResults) {
this.mResults = mResults;
}
@Override
protected void onActive() {
mResults.addChangeListener(listener);
}
@Override
protected void onInactive() {
mResults.removeChangeListener(listener);
}
}
Extensible - Represent anything as LiveData

LiveData
em@realm.io
public class RealmLiveData<T extends RealmModel> extends LiveData<RealmResults<T>> {
private RealmResults<T> mResults;
private RealmChangeListener<RealmResults<T>> listener = new RealmChangeListener<RealmResults<T>>() {
@Override
public void onChange(RealmResults<T> results) {
setValue(results);
}
};
public RealmLiveData(RealmResults<T> mResults) {
this.mResults = mResults;
}
@Override
protected void onActive() {
mResults.addChangeListener(listener);
}
@Override
protected void onInactive() {
mResults.removeChangeListener(listener);
}
}

LiveData
em@realm.io
// Use Custom LiveData 
public RealmLiveData<Loan> findLoansByNameAfter(final String userName, final Date after) {
return new RealmLiveData<>(mRealm.where(Loan.class)
.like("user.name", userName)
.greaterThan("endTime", after)
.findAllAsync());
}
// Can even transform that live data
RealmLiveData<Loan> loans = findLoansByNameAfter(“Mike”, getYesterdayDate());
LiveData<String> mLoansResult = Transformations.map(loans, new Function<RealmResults<Loan>, String>() {
@Override
public String apply(RealmResults<Loan> loans) {
StringBuilder sb = new StringBuilder();
for (Loan loan : loans) {
sb.append(String.format("%sn (Returned: %s)n",
loan.getBook().getTitle(),
simpleDateFormat.format(loan.getEndTime())));
}
return sb.toString();
}
});

em@realm.io
Room
• ORM for SQLite
• DAOs defined in interface are generated at compile time
• Results are Live(Data)

em@realm.io
Room
public class LoanWithUserAndBook {
public String id;
@ColumnInfo(name="title")
public String bookTitle;
@ColumnInfo(name="name")
public String userName;
@TypeConverters(DateConverter.class)
public Date startTime;
public Date endTime;
}

em@realm.io
Room
@Entity(foreignKeys = {
@ForeignKey(entity = Book.class,
parentColumns = "id",
childColumns = "book_id"),
@ForeignKey(entity = User.class,
parentColumns = "id",
childColumns = "user_id")})
public class Loan {
public @PrimaryKey String id;
public Date startTime;
public Date endTime;
@ColumnInfo(name="book_id")
public String bookId;
@ColumnInfo(name="user_id")
public String userId;
}
Define Entites
@Entity
public class User {
public String name;
public String lastName;
public int age;
}
@Entity
public class Book {
public String title;
}

em@realm.io
Room
@Database(entities = {User.class, Book.class, Loan.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
private static AppDatabase INSTANCE;
public abstract UserDao userModel();
public abstract BookDao bookModel();
public abstract LoanDao loanModel();
public static AppDatabase getInMemoryDatabase(Context context) {
if (INSTANCE == null) {
INSTANCE =
Room.databaseBuilder(context.getApplicationContext(),
AppDatabase.class, "LibraryDb")
.build();
}
return INSTANCE;
}
public static void destroyInstance() {
INSTANCE = null;
}
}
Define Database

em@realm.io
Room
@Dao
public interface LoanDao {
@Query("SELECT * From Loan")
LiveData<List<Loan>> findAll();
@Query("SELECT Loan.id, Book.title, User.name, Loan.startTime, Loan.endTime From Loan " +
"INNER JOIN Book ON Loan.book_id = Book.id " +
"INNER JOIN User ON Loan.user_id = User.id ")
LiveData<List<LoanWithUserAndBook>> findAllWithUserAndBook();
@Query("SELECT Loan.id, Book.title as title, User.name as name, Loan.startTime, Loan.endTime " +
"FROM Book " +
"INNER JOIN Loan ON Loan.book_id = Book.id " +
"INNER JOIN User on User.id = Loan.user_id " +
"WHERE User.name LIKE :userName " +
"AND Loan.endTime > :after "
)
public LiveData<List<LoanWithUserAndBook>> findLoansByNameAfter(String userName, Date after);
@Insert(onConflict = ABORT)
void insertLoan(Loan loan);
@Query("DELETE FROM Loan")
void deleteAll();
}
Define DAO Interface

em@realm.io
Room
public class CustomResultViewModel extends AndroidViewModel {
private AppDatabase mDb;
public CustomResultViewModel(Application application) {
super(application);
mDb = AppDatabase.getDatabase(application);
}
public logMikesLoans() {
LiveData<List<LoanWithUserAndBook>> loans =
mDb.loanModel().findLoansByNameAfter("Mike", getYesterdayDate());
...
}
Using Room DAOs

em@realm.io
Room
@RunWith(AndroidJUnit4.class)
public class SimpleEntityReadWriteTest {
private UserDao mUserDao;
private TestDatabase mDb;
@Before
public void createDb() {
Context context = InstrumentationRegistry.getTargetContext();
mDb = Room.inMemoryDatabaseBuilder(context, TestDatabase.class).build();
mUserDao = mDb.getUserDao();
}
@After
public void closeDb() throws IOException {
mDb.close();
}
@Test
public void writeUserAndReadInList() throws Exception {
User user = TestUtil.createUser(3);
user.setName("george");
mUserDao.insert(user);
List<User> byName = mUserDao.findUsersByName("george");
assertThat(byName.get(0), equalTo(user));
}
}
Room Test Support
https://developer.android.com/topic/libraries/architecture/room.html#testing-android

em@realm.io
Android Architecture Components
In a Nutshell

Architecture
“It is impossible to have one way of writing apps that will be the
best for every scenario.
If you already have a good way of writing Android apps, you don't
need to change.
That being said, this recommended architecture should be a good
starting point for most use cases.”
https://developer.android.com/topic/libraries/architecture/guide.html#recommended_app_architecture

Official Android Architecture Dogma Guidance
For more information see: https://developer.android.com/topic/libraries/architecture/guide.html

General Good Practices
• Avoid storing state or data in Activities, Fragments, Services, Broadcast Receivers
• Keep a strong separation of concerns
• Build your Data, Model, ViewModel, Activity/Fragment, etc. as components with strong inputs / outputs
• Android Architecture Components and libraries. Focus on what makes your app unique
• Build your apps UI/UX to function well when offline
• Use Service Locators or Dependency Injection for dependencies

Additional Materials
• https://developer.android.com/topic/libraries/architecture/index.html
• https://github.com/googlesamples/android-architecture-components
• https://github.com/googlesamples/android-architecture (Architecture Blueprints)
• Other Reactive Uni-Directional Architectures
• Model View Intent - http://hannesdorfmann.com/android/mosby3-mvi-2#model-view-intent-mvi
• FLUX on Android - https://github.com/lgvalle/android-flux-todo-app
• Other Articles I’ve published on these topics
• https://news.realm.io/news/eric-maxwell-mvc-mvp-and-mvvm-on-android/
• https://news.realm.io/news/eric-maxwell-uni-directional-architecture-android-using-realm
• https://news.realm.io/news/android-architecture-components-and-realm/
• Samples
• https://github.com/ericmaxwell2003/android-architecture-samples

Eric Maxwell
em@realm.io
www.realm.io
@emmax
Thank you!

Modern Android Architecture

Recommended

Recommended

More Related Content

What's hot

What's hot (9)

Similar to Modern Android Architecture

Similar to Modern Android Architecture (20)

Recently uploaded

Recently uploaded (20)

Modern Android Architecture