$30 off During Our Annual Pro Sale. View Details »

Android Architecture Components

Android Architecture Components

A collection of libraries that help you design robust, testable, and maintainable apps. Start with classes for managing your UI component lifecycle and handling data persistence.

Burhanuddin Rashid

November 18, 2017
Tweet

More Decks by Burhanuddin Rashid

Other Decks in Technology

Transcript

  1. Android Architecture Components LifeCycle , LiveData , Room and ViewModel

  2. Agenda • What is Architecture ? • Common Problems •

    Why to use Android Architecture Components ? • LifeCycle • ViewModel • LiveData • Room
  3. What is Architecture ? Software application architecture is the process

    of defining a structured solution that meets all of the technical and operational requirements, while optimizing common quality attributes such as performance, security, and manageability. It involves a series of decisions based on a wide range of factors, and each of these decisions can have considerable impact on the quality, performance, maintainability, and overall success of the application
  4. What is Architecture ?

  5. What is Architecture ? Separation of Concerns

  6. Common Developer Problems • Multiple Entry Point • Constantly Switching

    Flow and Tasks • Screen Rotation
  7. Architecture Patterns • MVC (Model-View-Controller) • MVP (Model-View-Presenter) • MVVM

    (Model-View-ViewModel) • VP (View-Presenter)
  8. Our Expectations

  9. Reality

  10. Why Architecture Components ? Persist Data Manage LifeCycle Modular Defense

    Against Common Errors Less Boilerplate
  11. Simple App App UI/UX ROOM Modifies,requests or generates data for

    database Response Back LIVE DATA
  12. Components 4. Room 1. LifeCycle 2. LiveData 3. ViewModel

  13. Dependencies //Room compile 'android.arch.persistence.room:runtime:1.0.0' annotationProcessor 'android.arch.persistence.room:compiler:1.0.0' //LifeCycle and ViewModel compile

    'android.arch.lifecycle:runtime:1.0.0' compile 'android.arch.lifecycle:extensions:1.0.0' annotationProcessor 'android.arch.lifecycle:compiler:1.0.0'
  14. LifeCycle : Problems 2. Untimely UI updates 1. Activity/Fragment LifeCycle

    4. Screen Rotation 3. Broadcast Receivers
  15. LifeCycle LifeCycle Owner : LifeCycle Owner are the objects with

    lifecycle ,like Activities and Fragments LifeCycle Owners: ( Activities/Fragments ) LifeCycle Observer : LifeCycle Observer observe LifeCycleOwners , and are notifies of lifecycle changes LifeCycle Observer (Ex: LiveData)
  16. LifeCycle @Override public void onCreate(...) { myLocationListener = new MyLocationListener(this,

    location -> { // update UI }); } @Override public void onStart() { super.onStart(); myLocationListener.start(); } @Override public void onStop() { super.onStop(); myLocationListener.stop(); }
  17. LifeCycle @Override public void onCreate(...) { myLocationListener = new MyLocationListener(this,

    location -> { // update UI }); } @Override public void onStop() { super.onStop(); myLocationListener.stop(); } @Override public void onStart() { super.onStart(); Util.checkUserStatus(result -> { // what if this callback is invoked AFTER activity is stopped? if (result) { myLocationListener.start(); } }); }
  18. MyLocationListener public class MyLocationListner implements LifecycleObserver { } //Add this

    our MainActivity getLifecycle().addObserver(new MyLocationListner()); @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) public void connectListener() { ... } @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) public void disconnectListener() { ... }
  19. MyLocationListener class MyLocationListener implements LifecycleObserver { } private boolean enabled

    = false; public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) { ... } public void enable() { enabled = true; if (lifecycle.getCurrentState().isAtLeast(STARTED)) { // connect if not connected } } @OnLifecycleEvent(Lifecycle.Event.ON_STOP) void stop() { // disconnect if connected } @OnLifecycleEvent(Lifecycle.Event.ON_START) void start() { if (enabled) { // connect } }
  20. MainActivity class MainActivity extends AppCompatActivity { private MyLocationListener myLocationListener; public

    void onCreate(...) { } } myLocationListener = new MyLocationListener(this,getLifecycle(),location -> { // update UI }); Util.checkUserStatus(result -> { if (result) { myLocationListener.enable(); } });
  21. LifeCycle : Use Cases 2. Stopping and starting video buffering

    1. Location updates 3. Pausing and resuming animatable drawables
  22. ViewModel The ViewModel class is designed store and manage UI-related

    data so that data survives the configuration changes such as screen rotations ViewModel: public class MyViewModel extends ViewModel{ } AndroidViewModel with context: public class MyViewModel extends AndroidViewModel { public MyViewModel(@NonNull Application application) { super(application); } }
  23. ViewModel LifeCycle

  24. Create ViewModel public class MyViewModel extends ViewModel { private int

    mRotationCount; public int getRotationCount() { mRotationCount = mRotationCount + 1; return mRotationCount; } }
  25. Implement ViewModel @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main);

    } //Get view model instance MyViewModel myViewModel = ViewModelProviders.of(this).get(MyViewModel.class); //set the increment value mRotationCountTextView.setText("" + myViewModel.getRotationCount());
  26. Context ViewModel public class MyViewModel extends AndroidViewModel { private NotificationManager

    mNotificationManager; } public MyViewModel(@NonNull Application application) { super(application); mNotificationManager = (NotificationManager) application. getSystemService(Context.NOTIFICATION_SERVICE); }
  27. ViewModel : Use Cases 2. Shared between fragments 1. Retain

    State 3. Replacing loaders
  28. LiveData 1. LiveData is observable data holder. 2. It notifies

    the observers when data changes so that you can update the UI. 3. It is also Life Cycle Aware
  29. LiveData : Pros 1. UI Matches your data state 2.

    No Memory leak 3. No more manual lifecycle handling
  30. Create LiveData Object public class NameViewModel extends ViewModel { //

    Rest of the ViewModel... } // Create a LiveData with a String private MutableLiveData<String> mCurrentName; public MutableLiveData<String> getCurrentName() { if (mCurrentName == null) { mCurrentName = new MutableLiveData<String>(); } return mCurrentName; }
  31. Observe LiveData Objects private NameViewModel mModel; @Override protected void onCreate(Bundle

    savedInstanceState) { super.onCreate(savedInstanceState); } // Get the ViewModel. mModel = ViewModelProviders.of(this).get(NameViewModel.class); // Create the observer which updates the UI. final Observer<String> nameObserver = new Observer<String>() { @Override public void onChanged(@Nullable final String newName) { // Update the UI, in this case, a TextView. mNameTextView.setText(newName); } }; // Observe the LiveData, passing in this activity as the // LifecycleOwner and the observer. mModel.getCurrentName().observe(this, nameObserver);
  32. Update LiveData Objects mButton.setOnClickListener(new OnClickListener() { @Override public void onClick(View

    v) { String anotherName = "John Doe"; mModel.getCurrentName().setValue(anotherName); } });
  33. Database ??

  34. Room Room is a robust SQL Object Mapping Library

  35. Plain Old Java Object (POJO) Old POJO Room POJO public

    class User { private int uid; private String firstName; private String lastName; private int age; private Date dateOfJoining; } public class User { private int uid; private String firstName; private String lastName; private int age; private Date dateOfJoining; } @PrimaryKey(autoGenerate = true) @ColumnInfo(name = "first_name") @Entity @ColumnInfo(name = "last_name")
  36. UserDao.java public interface UserDao { } @Insert void insertAll(List<User> users);

    @Delete void delete(User user); @Update void updateUser(User user); @Query("SELECT * FROM user") List<User> getAll(); @Dao @Query("SELECT * FROM user WHERE uid = :userID") User findUserById(int userID);
  37. UserDao.java public interface UserDao { } @Insert void insertAll(List<User> users);

    @Delete void delete(User user); @Update void updateUser(User user); @Query("SELECT * FROM user") LiveData<List<User>> getAll(); @Dao @Query("SELECT * FROM user WHERE uid = :userID") User findUserById(int userID);
  38. Setup Room Database public abstract class AppDatabase extends RoomDatabase {

    } public abstract UserDao userDao(); @Database(entities = {User.class}, version = 1) @TypeConverters({Converters.class})
  39. Build Room Database public class AppController extends Application { private

    static AppController appController; private AppDatabase appDatabase; @Override public void onCreate() { super.onCreate(); appController = this; } public static AppDatabase getAppDatabase() { return appController.appDatabase; } } //Initialize the room database with database name appDatabase = Room.databaseBuilder(this, AppDatabase.class, "user-database") .fallbackToDestructiveMigration() .build();
  40. Display data public class MainActivity extends AppCompatActivity { @Override protected

    void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); List<User> userList = AppController .getAppDatabase() .userDao() .getAll(); //Update List in adapter } }
  41. UserModel public class UserModel extends ViewModel { private final UserDao

    userDao; public UserModel() { userDao = AppController .getAppDatabase() .userDao(); } public LiveData<List<User>> getAllUser() { return userDao.getAll(); } }
  42. MainActivity public class MainActivity extends AppCompatActivity { private UserModel userModel;

    @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); //Setup your UI } } userModel = ViewModelProviders.of(this).get(UserModel.class); userModel.getAllUser().observe(this, new Observer<List<User>>() { @Override public void onChanged(@Nullable List<User> userList) { // updateUI } });
  43. Thank you burhanrashid52 Burhanuddin Rashid Resources : • Android Architecture

    Components : http://bit.ly/2hGRxoc • Exploring Architecture Components : http://bit.ly/2j1Pvvv Multidots Inc. https://www.multidots.com/