Nishant Srivastava - The A, B and C of Lifecycle Components

Transcript

1. Nishant Srivastava The A,B and C of Lifecycle Components
2. Nishant Srivastava twitter.com/nisrulz github.com/nisrulz www.nisrulz.com
3. Soundbrenner
4. The Challenge
5. The Challenge Android activity lifecycle..
6. The Challenge Android activity lifecycle
7. The Challenge Android activity lifecycle - Many states
8. The Challenge Android activity lifecycle - Many states - Repeats on configuration changes
9. The Challenge Android activity lifecycle - Many states - Repeats on configuration changes Not to forget...
10. The Challenge ...the Fragment lifecycle.
11. The Challenge ...the Fragment lifecycle.
12. Architecture Components
13. Lifecycle Components
14. Lifecycle Components Series of classes designed to help deal with lifecycles in a more consistent fashion.
15. Lifecycle Components Series of classes designed to help deal with lifecycles in a more consistent fashion. - Lifecycle - LifecycleOwner - LifecycleObserver
16. Lifecycle
17. Lifecycle Series of states an object can be in. For Android: Object that defines Android lifecycle states. i.e. Activity & Fragment
18. Lifecycle
19. Lifecycle dependencies { def lifecycle_version = "1.1.1" // Support library already depends on this (since v26.1.0) // Both AppCompatActivity & Support Fragment implement // LifecycleOwner interface. // Lifecycles only implementation "android.arch.lifecycle:runtime:$lifecycle_version" ... }
20. Lifecycle // Source code public abstract class Lifecycle { // Adds a LifecycleObserver addObserver(@NonNull LifecycleObserver observer) // Removes the given observer from the observers list removeObserver(@NonNull LifecycleObserver observer) // Current state of the Lifecycle getCurrentState() // Compares the lifecycle states isAtLeast(@NonNull State state) ... }
21. Lifecycle // Source code public abstract class Lifecycle { // Adds a LifecycleObserver addObserver(@NonNull LifecycleObserver observer) // Removes the given observer from the observers list removeObserver(@NonNull LifecycleObserver observer) // Current state of the Lifecycle getCurrentState() // Compares the lifecycle states isAtLeast(@NonNull State state) ... }
22. Lifecycle // Source code public abstract class Lifecycle { // Adds a LifecycleObserver addObserver(@NonNull LifecycleObserver observer) // Removes the given observer from the observers list removeObserver(@NonNull LifecycleObserver observer) // Current state of the Lifecycle getCurrentState() // Compares the lifecycle states isAtLeast(@NonNull State state) ... }
23. LifecycleOwner
24. LifecycleOwner Interface that goes through Android Lifecycle.
25. LifecycleOwner Interface that goes through Android Lifecycle. // Source code public interface LifecycleOwner { // Returns the Lifecycle of the provider. @NonNull Lifecycle getLifecycle(); }
26. LifecycleOwner class MainActivity : AppCompatActivity() { // Missing myLifecycleObserver override fun onResume() { // Add lifecycle observer lifecycle.addObserver(myLifecycleObserver) } override fun onStop() { // Remove lifecycle observer lifecycle.removeObserver(myLifecycleObserver) } }
27. LifecycleOwner Fun Fact: Activities & fragments are not the only things with lifecycle by default
28. LifecycleOwner Fun Fact: Activities & fragments are not the only things with lifecycle by default You also have - LifecycleService - ProcessLifecycleOwner
29. LifecycleService
30. LifecycleService A service that is also a LifecycleOwner
31. LifecycleService A service that is also a LifecycleOwner // Source code public class LifecycleService extends Service implements LifecycleOwner { ... }
32. ProcessLifecycleOwner
33. ProcessLifecycleOwner - Class that tracks the lifecycle of
34. ProcessLifecycleOwner - Class that tracks the lifecycle of - whole application process or - all the activities combined
35. ProcessLifecycleOwner - Class that tracks the lifecycle of - whole application process or - all the activities combined - Useful for reacting to app coming to foreground or going to background
36. ProcessLifecycleOwner dependencies { def lifecycle_version = "1.1.1" // For ProcessLifecycleOwner implementation "android.arch.lifecycle:extensions:$lifecycle_version" ... }
37. ProcessLifecycleOwner ON_CREATE ON_START & ON_RESUME ON_PAUSE & ON_STOP ON_DESTROY
38. ProcessLifecycleOwner ON_CREATE (Only 1 time) ON_START & ON_RESUME ON_PAUSE & ON_STOP ON_DESTROY
39. ProcessLifecycleOwner ON_CREATE (Only 1 time) ON_START & ON_RESUME (First Activity pass) ON_PAUSE & ON_STOP ON_DESTROY
40. ProcessLifecycleOwner ON_CREATE (Only 1 time) ON_START & ON_RESUME (First Activity pass) ON_PAUSE & ON_STOP (after 700ms delay) ON_DESTROY
41. ProcessLifecycleOwner ON_CREATE (Only 1 time) ON_START & ON_RESUME (First Activity pass) ON_PAUSE & ON_STOP (after 700ms delay) ON_DESTROY
42. ProcessLifecycleOwner ON_CREATE (Only 1 time) ON_START & ON_RESUME (First Activity pass) ON_PAUSE & ON_STOP (after 700ms delay) ON_DESTROY
43. ProcessLifecycleOwner ON_PAUSE & ON_STOP (after 700ms delay)
44. ProcessLifecycleOwner ON_PAUSE & ON_STOP (after 700ms delay) // Source code public class ProcessLifecycleOwner implements LifecycleOwner { static final long TIMEOUT_MS = 700; //mls ... }
45. ProcessLifecycleOwner Guarantee that ProcessLifecycleOwner won’t send any events if activities are - Destroyed - Recreated due to configuration change
46. ProcessLifecycleOwner Comes with cost:
47. ProcessLifecycleOwner Comes with cost: extension artifact automatically adds <provider> element to your manifest
48. ProcessLifecycleOwner <manifest > <application> ... <provider android:name="android.arch.lifecycle.ProcessLifecycleOwnerInitializer" android:authorities="com.example.app.lifecycle-trojan" android:exported="false" android:multiprocess="true" /> </application> </manifest>
49. ProcessLifecycleOwner // Source code // Internal class to initialize Lifecycles. public class ProcessLifecycleOwnerInitializer extends ContentProvider { @Override public boolean onCreate() { ... ProcessLifecycleOwner.init(getContext()); return true; } ... }
50. ProcessLifecycleOwner Side-effect:
51. ProcessLifecycleOwner Side-effect: Inits ProcessLifecycleOwner even if your app does not use it!
52. ProcessLifecycleOwner Side-effect: Inits ProcessLifecycleOwner even if your app does not use it! Why?
53. ProcessLifecycleOwner Side-effect: Inits ProcessLifecycleOwner even if your app does not use it! Why? So that ProcessLifecycleOwner can be invoked as soon as process starts
54. Application.ActivityLifecycleCallback vs ProcessLifecycleOwner
55. Application.ActivityLifecycleCallback vs or ProcessLifecycleOwner
56. Application.ActivityLifecycleCallback // Source code public interface ActivityLifecycleCallbacks { void onActivityCreated(Activity var1, Bundle var2); ... void onActivitySaveInstanceState(Activity var1, Bundle var2); void onActivityDestroyed(Activity var1); }
57. Application.ActivityLifecycleCallback // Register for the callback application .registerActivityLifecycleCallbacks(object: Application.ActivityLifecycleCallbacks{ override fun onActivityCreated(activity: Activity?, bundle: Bundle?) {} ... })
58. ProcessLifecycleOwner // Source code public class ProcessLifecycleOwner implements LifecycleOwner { ... void attach(Context context) { ... Application app = (Application) context.getApplicationContext(); app.registerActivityLifecycleCallbacks (new EmptyActivityLifecycleCallbacks() { @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { .. } ... }); } }
59. ProcessLifecycleOwner // Source code public class ProcessLifecycleOwner implements LifecycleOwner { ... void attach(Context context) { ... Application app = (Application) context.getApplicationContext(); app.registerActivityLifecycleCallbacks (new EmptyActivityLifecycleCallbacks() { @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { .. } ... }); } }
60. ProcessLifecycleOwner // Source code public class ProcessLifecycleOwner implements LifecycleOwner { ... void attach(Context context) { ... Application app = (Application) context.getApplicationContext(); app.registerActivityLifecycleCallbacks (new EmptyActivityLifecycleCallbacks() { @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { .. } ... }); } }
61. ProcessLifecycleOwner // Source code class EmptyActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks { @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { //Empty method body } ... }
62. ProcessLifecycleOwner // Source code class EmptyActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks { @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { //Empty method body } ... }
63. LifecycleRegistry
64. LifecycleRegistry Implementation of Lifecycle that can handle multiple observers
65. LifecycleRegistry Implementation of Lifecycle that can handle multiple observers // Source code public class LifecycleRegistry extends Lifecycle { ... }
66. LifecycleRegistry Implementation of Lifecycle that can handle multiple observers // Source code public class LifecycleRegistry extends Lifecycle { ... } However, you need to dispatch the events yourself.
67. LifecycleRegistry class MyLifecycleOwner : LifecycleOwner { private var registry: LifecycleRegistry = LifecycleRegistry(this) init { registry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE) } override fun getLifecycle(): Lifecycle = registry fun startListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_START) } fun stopListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_STOP) } }
68. LifecycleRegistry class MyLifecycleOwner : LifecycleOwner { private var registry: LifecycleRegistry = LifecycleRegistry(this) init { registry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE) } override fun getLifecycle(): Lifecycle = registry fun startListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_START) } fun stopListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_STOP) } }
69. LifecycleRegistry class MyLifecycleOwner : LifecycleOwner { private var registry: LifecycleRegistry = LifecycleRegistry(this) init { registry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE) } override fun getLifecycle(): Lifecycle = registry fun startListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_START) } fun stopListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_STOP) } }
70. LifecycleRegistry class MyLifecycleOwner : LifecycleOwner { private var registry: LifecycleRegistry = LifecycleRegistry(this) init { registry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE) } override fun getLifecycle(): Lifecycle = registry fun startListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_START) } fun stopListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_STOP) } }
71. LifecycleRegistry class MyLifecycleOwner : LifecycleOwner { private var registry: LifecycleRegistry = LifecycleRegistry(this) init { registry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE) } override fun getLifecycle(): Lifecycle = registry fun startListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_START) } fun stopListening() { registry.handleLifecycleEvent(Lifecycle.Event.ON_STOP) } }
72. LifecycleRegistry val myLifecycleOwner = MyLifecycleOwner() // Missing myLifecycleObserver // Add lifecycle observer myLifecycleOwner.lifecycle.addObserver(myLifecycleObserver) // Remove lifecycle observer myLifecycleOwner.lifecycle.removeObserver(myLifecycleObserver)
73. LifecycleObserver
74. LifecycleObserver An interface for observing a Lifecycle // Source code public interface LifecycleObserver { // Empty }
75. LifecycleObserver Two ways to implement - Annotation - Callback Interface
76. LifecycleObserver dependencies { def lifecycle_version = "1.1.1" // For Annotation Support annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version" ... }
77. LifecycleObserver class MyLifecycleObserver : LifecycleObserver { @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) fun init() {} @OnLifecycleEvent(Lifecycle.Event.ON_START) fun onStart() {} ... @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) fun cleanup() {} }
78. LifecycleObserver val myLifecycleOwner = MyLifecycleOwner() // Add lifecycle observer myLifecycleOwner.lifecycle.addObserver(myLifecycleObserver) // Remove lifecycle observer myLifecycleOwner.lifecycle.removeObserver(myLifecycleObserver)
79. LifecycleObserver val myLifecycleOwner = MyLifecycleOwner() val myLifecycleObserver = MyLifecycleObserver() // Add lifecycle observer myLifecycleOwner.lifecycle.addObserver(myLifecycleObserver) // Remove lifecycle observer myLifecycleOwner.lifecycle.removeObserver(myLifecycleObserver)
80. LifecycleObserver val myLifecycleOwner = MyLifecycleOwner() val myLifecycleObserver = MyLifecycleObserver() // Add lifecycle observer myLifecycleOwner.lifecycle.addObserver(myLifecycleObserver) // Remove lifecycle observer myLifecycleOwner.lifecycle.removeObserver(myLifecycleObserver)
81. DefaultLifecycleObserver
82. DefaultLifecycleObserver Callback interface for listening to LifecycleOwner state changes.
83. DefaultLifecycleObserver Callback interface for listening to LifecycleOwner state changes. Recommended over annotations if using Java 8 language.
84. DefaultLifecycleObserver android { compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } } dependencies { def lifecycle_version = "1.1.1" // For DefaultLifecycleObserver implementation "android.arch.lifecycle:common-java8:$lifecycle_version" ... }
85. DefaultLifecycleObserver // Source code public interface DefaultLifecycleObserver extends FullLifecycleObserver { @Override default void onCreate(@NonNull LifecycleOwner owner) { ... } ... @Override default void onDestroy(@NonNull LifecycleOwner owner) { ... } }
86. DefaultLifecycleObserver // Source code interface FullLifecycleObserver extends LifecycleObserver { void onCreate(LifecycleOwner owner); void onStart(LifecycleOwner owner); ... void onDestroy(LifecycleOwner owner); }
87. DefaultLifecycleObserver class MyLifecycleObserver : DefaultLifecycleObserver { override fun onCreate(owner: LifecycleOwner) {} ... override fun onDestroy(owner: LifecycleOwner) {} }
88. LiveData
89. LiveData A lifecycle aware base class for encapsulating loading data
90. LiveData A lifecycle aware base class for encapsulating loading data Lightweight implementation of Observer pattern
91. LiveData dependencies { def lifecycle_version = "1.1.1" // For LiveData implementation "android.arch.lifecycle:livedata:$lifecycle_version" ... }
92. LiveData // Source Code public abstract class LiveData<T> { ... protected void postValue(T value) {...} ... @MainThread protected void setValue(T value) {...} ... protected void onActive() {...} protected void onInactive() {...} }
93. LiveData // Source Code public abstract class LiveData<T> { ... protected void postValue(T value) {...} // Sets the value async ... @MainThread protected void setValue(T value) {...} ... protected void onActive() {...} protected void onInactive() {...} }
94. LiveData // Source Code public abstract class LiveData<T> { ... protected void postValue(T value) {...} // Sets the value async ... @MainThread protected void setValue(T value) {...} // Sets the value sync ... protected void onActive() {...} protected void onInactive() {...} }
95. LiveData // Source Code public abstract class LiveData<T> { ... protected void postValue(T value) {...} // Sets the value async ... @MainThread protected void setValue(T value) {...} // Sets the value sync ... protected void onActive() {...} // Has active observers i.e in Start/Resume state protected void onInactive() {...} }
96. LiveData // Source Code public abstract class LiveData<T> { ... protected void postValue(T value) {...} // Sets the value async ... @MainThread protected void setValue(T value) {...} // Sets the value sync ... protected void onActive() {...} // Has active observers i.e in Start/Resume state protected void onInactive() {...} // Has 0 active observers }
97. LiveData class MySensorLiveData(context: Context?) : LiveData<Float>() { val sensorManager: SensorManager? = context? .getSystemService(Service.SENSOR_SERVICE) as SensorManager val sensorListener: SensorEventListener = object : SensorEventListener { override fun onSensorChanged(event: SensorEvent?) { // Set Value setValue(event?.values?.get(0)) } ... } }
98. LiveData class MySensorLiveData(context: Context?) : LiveData<Float>() { val sensorManager: SensorManager? = context? .getSystemService(Service.SENSOR_SERVICE) as SensorManager val sensorListener: SensorEventListener = object : SensorEventListener { override fun onSensorChanged(event: SensorEvent?) { // Set Value setValue(event?.values?.get(0)) } ... } }
99. LiveData class MySensorLiveData(context: Context?) : LiveData<Float>() { ... override fun onActive() { ... sensorManager?.registerListener(sensorListener, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_FASTEST) } override fun onInactive() { ... sensorManager.unregisterListener(sensorListener) } }
100. LiveData class MySensorLiveData(context: Context?) : LiveData<Float>() { ... override fun onActive() { ... sensorManager?.registerListener(sensorListener, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_FASTEST) } override fun onInactive() { ... sensorManager.unregisterListener(sensorListener) } }
101. LiveData val mySensorLiveData = MySensorLiveData(this) // Observe for values mySensorLiveData.observe(this, Observer<Float>{ floatVal -> // Update the UI })
102. ViewModel
103. ViewModel - Hold & manage UI related data in Lifecycle conscious way - Survives configuration changes - Prevents unnecessary reloading of data
104. ViewModel dependencies { def lifecycle_version = "1.1.1" // For ViewModel implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" ... }
105. ViewModel // Source code public abstract class ViewModel { // Called when ViewModel is destroyed protected void onCleared() { } }
106. ViewModel class MyViewModel : ViewModel() { private val username = MutableLiveData<String>() fun initExpensiveOperation() { // expensive operation, e.g. network request username.value = "Nishant" // username.setValue(“Nishant”) } fun getUsername(): LiveData<String> { return username } }
107. ViewModel class MyViewModel : ViewModel() { private val username = MutableLiveData<String>() fun initExpensiveOperation() { // expensive operation, e.g. network request username.value = "Nishant" // username.setValue(“Nishant”) } fun getUsername(): LiveData<String> { return username } }
108. ViewModel class MyViewModel : ViewModel() { private val username = MutableLiveData<String>() fun initExpensiveOperation() { // expensive operation, e.g. network request username.value = "Nishant" // username.setValue(“Nishant”) } fun getUsername(): LiveData<String> { return username } }
109. ViewModel class MyViewModel : ViewModel() { private val username = MutableLiveData<String>() fun initExpensiveOperation() { // expensive operation, e.g. network request username.value = "Nishant" // username.setValue(“Nishant”) } fun getUsername(): LiveData<String> { return username } }
110. ViewModel class MyViewModel : ViewModel() { private val username = MutableLiveData<String>() fun initExpensiveOperation() { // expensive operation, e.g. network request username.value = "Nishant" // username.setValue(“Nishant”) } fun getUsername(): LiveData<String> { return username } }
111. ViewModel class MyViewModel : ViewModel() { private val username = MutableLiveData<String>() fun initExpensiveOperation() { // expensive operation, e.g. network request username.value = "Nishant" // username.setValue(“Nishant”) } fun getUsername(): LiveData<String> { return username } }
112. ViewModel val viewModel = ViewModelProviders .of(this) .get(MyViewModel::class.java) viewModel.getUsername().observe(this, Observer<String> { text -> //Update the UI })
113. ViewModel val viewModel = ViewModelProviders .of(this) .get(MyViewModel::class.java) viewModel.getUsername().observe(this, Observer<String> { text -> //Update the UI })
114. Thank You twitter.com/nisrulz github.com/nisrulz www.nisrulz.com
115. More Info Is your Android Library, Lifecycle-Aware? https://android.jlelse.eu/is-your-android-library-lifecycle-aware-127629d32dcc Official documentation about lifecycle components d.android.com/topic/libraries/architecture/lifecycle Using ProcessLifecycleOwner for libraries example https://github.com/nisrulz/android-examples/tree/develop/UsingProcessLifecycleOwnerForLibs Using Lifecycle Components for libraries example https://github.com/nisrulz/android-examples/tree/develop/LifeCycleCompForLib
116. The A,B and C of Lifecycle Components twitter.com/nisrulz github.com/nisrulz www.nisrulz.com