Architecture Components

Extended
Seoul
Architecture Components
 
alpaca@vcnc.co.kr

Speaker
• (@plazgun)

• Between Android Developer

• Google I/O 2017  
Architecture Components - Introduction 
Architecture Components - Solving the Lifecycle 
Architecture Components - Persistence and Oﬄine

•

• https://developer.android.com/topic/libraries/architecture/
index.html

• Handling Lifecycles

• LiveData

• ViewModel

• Room

build.gradle
• allprojects { 
repositories { 
jcenter() 
maven { url 'https://maven.google.com' } 
} 
}

• compile "android.arch.lifecycle:runtime:1.0.0-alpha3" 
compile "android.arch.lifecycle:extensions:1.0.0-alpha3" 
annotationProcessor "android.arch.lifecycle:compiler:1.0.0-alpha3" 
• compile "android.arch.persistence.room:runtime:1.0.0-alpha3" 
annotationProcessor "android.arch.persistence.room:compiler:1.0.0-alpha3" 
• compile "android.arch.persistence.room:rxjava2:1.0.0-alpha3" 
testCompile "android.arch.persistence.room:testing:1.0.0-alpha3"

public class MyActivity extends AppCompatActivity {
private TestListener testListener;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
testListener = new TestListener();
}
@Override
protected void onStart() {
super.onStart();
testListener.start();
}
@Override
protected void onStop() {
super.onStop();
testListener.stop();
}
}

public class MyActivity extends AppCompatActivity {
@Override
testListener = new TestListener();
}
@Override
super.onStart();
}
@Override
protected void onStop() {
super.onStop();
testListener.stop();
}
}
onStart  
Override .

Handling Lifecycles
• Lifecycle

• LifecycleOwner

• LifecycleObserver

public class MyActivity extends LifecycleActivity {
@Override
setContentView(R.layout.activity_lifecycle);
TestListener testListener = new TestListener( 
getLifecycle(),  
result -> {
// update UI
});
}
}

public class TestListener implements LifecycleObserver {
private Lifecycle lifecycle;
public TestListener(Lifecycle lifecycle, TestCallback callback) {
lifecycle.addObserver(this);
this.lifecycle = lifecycle;
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void start() {
// start Event
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void clean() {
lifecycle.removeObserver(this);
}
}

public class MyActivity extends CustomActivity {
@Override 
protected void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
setContentView(R.layout.activity_main); 
}
}

public class LifecycleActivity extends FragmentActivity  
implements LifecycleRegistryOwner {
private final LifecycleRegistry mRegistry  
= new LifecycleRegistry(this);
@Override
public LifecycleRegistry getLifecycle() {
return mRegistry;
}
}

public class MyActivity extends CustomActivity implements LifecycleRegistryOwner {
private final LifecycleRegistry lifecycleRegistry = new LifecycleRegistry(this);
@Override
return lifecycleRegistry;
}
@Override
setContentView(R.layout.activity_lifecycle);
TestListener testListener = new TestListener(getLifecycle(), state -> {
// update Ui
});
}
}

@Override
super.onStart();
Utils.checkUserStatus(state -> {
if (state.equals("OK")) {
}
});
}

@Override
super.onStart();
// ?
if (state.equals("OK")) {
}
});
}

StartCreate Resume Pause Stop Destroy
testListener.stop
Utils.checkStatus testListener.start

@Override
super.onStart();
if (state.equals("OK") && getLifecycle() 
.getCurrentState() 
.isAtLeast(Lifecycle.State.STARTED)) {
}
});
}

LiveData
• Observable Data Holder

• Lifecycle aware

• Automatic subscription management

LiveData<String> stateData = new MutableLiveData<>();
@Override
stateData.observe((LifecycleOwner) this, ((String) result) -> {
// stateData .
});
}
@Override
super.onStart();
stateData.setValue(“Start");
}

public class StateChangeLiveData extends MutableLiveData<String> {
@Override
protected void onActive() {
super.onActive(); 
// Active Observer  
// Active: Lifecycle.State STARTED RESUMED
}
@Override
protected void onInactive() {
super.onInactive(); 
// Active Observer
}
}

LiveData<User> userData;
@Override
userData = userRepository.fetchData();
userData.observe(this, user -> {
// update UI
});
}
}

Rotated
fetchData
StartCreate Resume
fetchData

ViewModel
The ViewModel class is designed to store
and manage UI-related data so that the
data survives conﬁguration changes such
as screen rotations.
”
“

public class UserViewModel extends ViewModel {
} 
 
public class UserViewModel extends AndroidViewModel { 
// Application ViewModel 
}

ViewModel
•

• ActivityContext

• Resource

@Override
setContentView(R.layout.insert_activity);
 
// ViewModelStore ViewModel .
UserListViewModel viewModel = ViewModelProviders.of(this) 
.get(UserListViewModel.class);

@Override
ViewModelProviders.of(this).get(UserListViewModel.class)
.getData()
.observe(this, user -> {
//update UI
});
public class UserListViewModel extends ViewModel { 
private LiveData<User> userLiveData; 
 
public LiveData<User> getData() { 
if (userLiveData == null) { 
userLiveData = userRepository.fetchData(); 
} 
return userLiveData; 
} 
}

Rotated
StartCreate Resume
ViewModel
fetchData
getData getData

Room
• Sqlite ORM

• Entity

• Dao

• Database

id name create_time
@Entity
public class User {
@PrimaryKey(autoGenerate = true)
private Long id;
String name;
@ColumnInfo(name = "created_time")
private long createdTime;
@Ignore
Bitmap profile;
}
Entity

DAO
@Dao
public interface UserDao {
@Query("SELECT * FROM user")
List<User> getAll();
@Query("SELECT * FROM user WHERE id IN (:userIds)")
List<User> loadAllByIds(int[] userIds);
@Query("SELECT * FROM user WHERE name LIKE :first LIMIT 1")
User findByName(String first);
@Insert(onConflict = OnConflictStrategy.REPLACE)
void insertAll(User... users);
@Delete
void delete(User user);
@Update
void updateUser(User user);

DAO (Rx, LiveData)
@Query("SELECT * FROM user")
LiveData<List<User>> getAllSync();
@Query("SELECT * FROM user WHERE id = :userId")
LiveData<User> fetchUser(String userId);
@Query("SELECT * from user where id = :id LIMIT 1")
Flowable<User> loadUserByIdRx(int id);
@Query("SELECT * FROM user WHERE age > :minAge LIMIT 5")
Cursor loadRawUsersOlderThan(int minAge);

Database
@Database(entities = {User.class, Book.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
 
public abstract UserDao userDao();
public abstract BookDao bookDao();
}

Entity - Embedded
id name created_time image_id image_width image_height
public class Image {
String id;
Integer width;
Integer height;
}
@Entity
public class User { 
private Long id;
String name;
 
@Embedded(prefix = "image_")
private Image image;
@ColumnInfo(name = "created_time")
private long createdTime;

Entity - TypeConverter
public class User {
@PrimaryKey
private Long id;
@TypeConverters(Converters.class)
private Date date;
public class Converters {
@TypeConverter
public static Date toDate(Long timestamp) {
return timestamp == null ? null :  
new Date(timestamp);
}
@TypeConverter
public static Long toTimestamp(Date date) {
return date == null ? null : date.getTime();
}
}

Entity - Relation
@Entity(indices = {@Index(value = "id", unique = true)},  
foreignKeys = {
@ForeignKey(entity = Book.class,  
parentColumns = "id",  
childColumns = "bookId",  
onDelete = ForeignKey.CASCADE)
})
public class User {
private Long id;
public Long bookId; 
}

public class UserDao_Impl implements UserDao {
private final RoomDatabase __db;
private final EntityInsertionAdapter __insertionAdapterOfUser;
private final EntityDeletionOrUpdateAdapter __deletionAdapterOfUser;
private final EntityDeletionOrUpdateAdapter __updateAdapterOfUser;
public UserDao_Impl(RoomDatabase __db) {
this.__db = __db;
this.__insertionAdapterOfUser = new EntityInsertionAdapter<User>(__db) {
@Override
public String createQuery() {
return "INSERT OR REPLACE INTO
Ùser`(ìd`,`name`,`created_time`,ùpdated_time`,àge`,`bookId`,ìmage_id`,ìmage_width`,ìmage_height`) VALUES
(?,?,?,?,?,?,?,?,?)";
}
@Override
public void bind(SupportSQLiteStatement stmt, User value) {
if (value.getId() == null) {
stmt.bindNull(1);
} else {
stmt.bindLong(1, value.getId());
}
if (value.getName() == null) {
stmt.bindNull(2);
} else {
stmt.bindString(2, value.getName());
}
stmt.bindLong(3, value.getCreatedTime());
if (value.getUpdatedTime() == null) {
stmt.bindNull(4);
} else {
stmt.bindLong(4, value.getUpdatedTime());
}

Error
@Query("SELECT * FROM users”) 
List<User> getAll();

• RxJava

• greenDAO ( Realm)

• MVP

• Firebase, Retroﬁt, Dagger, ButterKnife, Fresco, Glide, Mockito …

Android Lifecycle Components  
vs  
ReactiveX

public class TestActivity extends RxFragmentActivity {
@Override
protected void onCreate(@Nullable Bundle b) {
lifecycle()
.filter(e -> e == ActivityEvent.START)
.subscribe(e -> {
// on start
});
}
}
public class TestActivity extends LifecycleActivity
implements LifecycleObserver {
@Override
getLifecycle().addObserver(this);
}
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void start() {
// on start
}
}
LifecycleOwner RxLifecycle

public abstract class RxFragmentActivity
extends FragmentActivity
implements LifecycleProvider<ActivityEvent> {
private final BehaviorSubject<ActivityEvent> lifecycleSubject
= BehaviorSubject.create();
@Override
@NonNull
@CheckResult
public final Observable<ActivityEvent> lifecycle() {
return lifecycleSubject.asObservable();
}
@Override
@CallSuper
lifecycleSubject.onNext(ActivityEvent.CREATE);
}
@Override
@CallSuper
super.onStart();
lifecycleSubject.onNext(ActivityEvent.START);
}
}
public class LifecycleActivity extends FragmentActivity
implements LifecycleRegistryOwner {
private final LifecycleRegistry mRegistry
= new LifecycleRegistry(this);
@Override
return mRegistry;
}
}
LifecycleActivity RxFragmentActivity

public class TestActivity extends RxFragmentActivity {
@Override
Flowable<Long> data = getData();
data.compose(RxLifecycle.bindUntilEvent(
lifecycle(), ActivityEvent.DESTROY))
.subscribe(d -> {
// update ui
});
}
}
public class TestActivity extends LifecycleActivity {
@Override
LiveData<Long> data = getData();
data.observe(this, result -> {
// update ui
});
}
}
LiveData RxFlowable

Don’t migrate from RxJava
But be sure that you correctly handle lifecycle. 
”
“

@Entity
public class RoomUser {
@PrimaryKey
private long id;
// getter & setter
}
Room
greenDAO
Realm
@Entity
public class GreenUser {
@Id
private long id;
// getter & setter
}
public class RealmUser extends RealmObject {
@PrimaryKey
private long id;
// getter & setter
}

@Entity(tableName = "user")
@ColumnInfo(name = “first_name")
private String firstName;
}
@Entity(nameInDb = "user")
@Property(nameInDb = “first_name")
private String firstName;
}
Room
greenDAO
Realm

@Entity(indices = @Index(“address"))
private String address;
@Ignore
private String sessionId;
}
@Entity(indexes = @Index("address DESC"))
@Transient
}
@Index
@Ignore
}
Room
greenDAO
Realm

@Dao
public interface RoomUserDao {
@Query("SELECT * FROM RoomUser WHERE id > 10 ORDER BY id DESC”)
List<RoomUser> getUsers();
}
public class GreenUseCase {
public List<GreenUser> getUsers() {
// get DaoSession
return new daoSession.getGreenUserDao().queryBuilder()
.where(GreenUserDao.Properties.Id.gt(10))
.orderDesc(GreenUserDao.Properties.Id)
.list();
}
}
public class RealmUseCase {
public RealmResults<RealmUser> getUsers() {
// get realm instance
return realm.where(RealmUser.class)
.greaterThan("id", 10)
.findAllSorted("id", Sort.DESCENDING);
}
}
Room
greenDAO
Realm

public class AndroidUser { 
private String userId; 
 
private String groupID; 
}
public class AndroidGroup { 
 
private String groupId; 
 
private String groupName; 
 
private List<AndroidUser> roomUser; 
}
Relation

@Entity
public class RoomGroup {
@PrimaryKey
private long id;
}
@Entity(foreignKeys = @ForeignKey(
entity = RoomGroup.class,
parentColumns = "id",
childColumns = "groupId"))
@PrimaryKey
private long id;
private long groupId;
}
https://developer.android.com/topic/libraries/architecture/room.html#no-object-references
Relation - Room
@Dao
public interface RoomGroupDao {
void insertGroup(RoomGroup group);
@Query("SELECT * FROM RoomGroup WHERE id = :id")
LiveData<RoomGroup> getGroup(long id);
}
@Dao
public interface RoomUserDao {
void insertUsers(List<RoomUser> users);
@Query("SELECT * FROM RoomUser WHERE groupId = :groupId")
LiveData<List<RoomUser>> getUsers(long groupId);
}

@Entity
public class GreenGroup {
@Id
private long id;
@ToMany(referencedJoinProperty
= "groupId")
private List<GreenUser> users;
}
@Entity
@Id
private long id;
private long groupId;
}
Relation - greenDAO
public class GreenUseCase {
public void insertGroup(GreenGroup group) {
daoSession.getGreenGroupDao()
.insertOrReplace(group);
daoSession.getGreenUserDao()
.insertOrReplaceInTx(group.getUsers());
}
public GreenGroup getGroup(long groupId) {
return daoSession.getGreenGroupDao()
.queryBuilder()
.where(GreenGroupDao.Properties.Id.eq(groupId))
.build()
.unique();
}
}

public class RealmGroup extends RealmObject {
@PrimaryKey
private long id;
RealmList<RealmUser> users;
}
@PrimaryKey
private long id;
}
Relation - Realm
public class RealmUseCase {
public void insertGroup(RealmGroup group) {
realm.insertOrUpdate(group);
}
public RealmGroup getGroup(long groupId) {
return realm.where(RealmGroup.class)
.equalTo("id", groupId)
.findFirst();
}
}

Realm GreenDao Room
Core Native Library SQLite SQLite
Performance Realm Realm
Relation
 
.
QueryBuilder X
DeepInsert X X
LazyLoading X
Integration Rx Rx, LiveData, Cursor

https://youtu.be/FrteWKKVyzI
https://youtu.be/bEKNi1JOrNs
https://youtu.be/MfHsPGQ6bgE
https://developer.android.com/topic/libraries/architecture/index.html
alpaca@vcnc.co.kr

• http://engineering.vcnc.co.kr/jobs/

Architecture Components

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Architecture Components

Ähnlich wie Architecture Components (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Architecture Components