Section 1
Preview this deck
Android Studio
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
7 years ago
Date created
Mar 1, 2020
Cards (62)
Section 1
(50 cards)
Android Studio
customized IDE based on IntelliJ that allows you to build apps IDE = Integrated Development Environment
not finding databinding class in Fragment?
make sure your xml is surrounded with <layout> </layout> and the namespacing are on these layout tags
AVD
Android Virtual Device emulator that pretends to be a device on your computer
View reference
ViewModel does not need View reference in MVVM bc of data binding, but is needed in MVP. Thus MVVM doesn't need all the interfaces that MVP requires
MVVM
more event driven than MVP
Activities and fragments
only contain logic dealing with UI display and capturing user input
ViewModel
store and manage UI related data in a lifecycle conscious way. Allows data to survive device-configuration changes such as keyboard availability and screen rotations
using Dispatchers.Main
means that the coroutines launched in the defined scope will run on the main thread.
how to change the value of a livedata variable
race condition
results when several threads try to access and modify the same data concurrently
what does it mean if LiveData is an observable
an observer is notified when the data held by the LiveData object changes.
avoid excess code with .copy
// Build appointment object. return AppointmentData( result.id ?: 0, status, time, result.location?.name, result.windowStart, result.windowEnd, result.location?.id, result.location?.address?.street, result.location?.address?.city, result.location?.address?.state, result.location?.address?.postalCode, result.location?.lat, result.location?.lon, result.location?.distance, result.job?.type, result.job?.number, result.job?.jobDescription, result.job?.id, result.job?.jobTypeWeight, result.job?.dueBy, result.techs?.map { tech -> tech.id ?: 0L } existing.copy(status = pending.status) Do the bottom instead of the top
things to know MVVM and RxJava observables
1. The view should always know about changes after the ViewModel & everything should go through the ViewModel 2. Emit one stream with states instead of events
How to apply event driven data in MVVM
Use RxJava library Observables
may not be MutableLiveData
when you want to cast it as LiveData to send elsewhere where it wont be changed.
View
actual UI ex. Activity, Fragment, or custom View For Activities and Fragments, we bind and unbind from the event sources onResume() and onPause()
DataModel
exposes data through event streams (RxJava Observables). Gets the data from network, database, or shared preferences, and exposes easily consumable data. Holds all business logic
dependency
when one object depends on the concrete implementation of another object. The Parent instance is dependent on the child. If the Child class itself depends on a class C, which in turn depends on class D, then all that complexity will propagate throughout the code base and hence result in a tight coupling between the components of the application.
using Dispathers.IO
means that the coroutines launched will run on the IO thread since getting stuff from the database is an IO option
Steps to set up a device
settings about phone tap build number item a ton go back go into developer options enable usb debugging
ViewModel
abstracts the View retrieves data from DataModel, applies UI logic, exposes relevant data for the View to consume. Like DataModel, VM exposes data via Observables
POJO
Plain Old Java Object
lambda expression
anonymous function that isn't declared, but is passed immediately as an expression
More MVVM advantages
has separation of concerns like MVP, but also has data binding benefits ALLOWS FAST REACTION TO DESIGN CHANGES
layouts
incredibly flexible and allow you to define how your user interface is presented on the device
Fragments
UI benefit A single activity can contain multiple fragments mainly used for tablet benefits For example, a news application can use one fragment to show a list of articles on the left and another fragment to display an article on the right—both fragments appear in one activity, side by side, and each fragment has its own set of lifecycle callback methods and handle their own user input events. Thus, instead of using one activity to select an article and another activity to read the article, the user can select an article and read it all within the same activity, as illustrated in the tablet layout in figure 1. should be modular and reusable
job
allows you to cancel all coroutines started by this view model when the view model is no longer used and destroyed
Abstraction
Pulling out specific differences to make one solution work for multiple problems. Preserving information that is relevant in a given context, and forgetting information that is irrelevant in that context
Live Data
observable data holder class that is lifecycle-aware. For example, you can wrap a LiveData around the current score in the GuessTheWord app
View Data Binding Example
MutableLiveData
LiveData whose value can be changed. MutableLiveData is a generic class, so you need to specify the type of data that it holds. // The current word val word = MutableLiveData<String>() // The current score val score = MutableLiveData<Int>()
test with Mockito in ViewModel
mock the DataModel and control the returned data for the methods used
View and ViewModel relationship
notifies the ViewModel about different actions, which creates a two-way data binding between the View and ViewModel. One to many relationship. This means View Model may be linked to many Views, but a View is linked to only 1 ViewModel. View has reference to VM, but VM has NO INFORMATION ABOUT THE VIEW. The data consumer knows the producer, but the producer (ViewModel) doesn't know or care about consumer (View)
More on ViewModel
VM EXPOSES STATES FOR THE VIEW, RATHER THAN JUST EVENTS. for example, create a DisplayableUser object that encapsulates name and email states. The stream will emit every time the name or email changes. Thus, our View always displays current state of the User. EVERY USER ACTION GOES THROUGH THE VM AND ANY POSSIBLE LOGIC OF VIEW IS MOVED IN THE VM
LiveData updates
only updates observers that are in an active lifecycle state such as STARTED or RESUMED.
Single Responsibility Principle
Create a DataModel for every feature in the app For example, we have an ArticleDataModel that composes its output from the API service and database layer. This DataModel handles the business logic ensuring that the latest news from the database is retrieved, by applying an age filter.
coroutines
the way to handle long-running tasks elegantly and efficiently. Let you convert callback-based code to sequential code.
Editor
main window where you edit your code
when should you use coroutines
when creating a database operation such as creating or updating a SleepNight
Benefits of MVVM
since the View is just a consumer of the ViewModel, it's easy to just replace different UI elements (with minimal or zero changes in other classes). GREAT FOR WHEN UI REQUIREMENTS CHANGE
coroutine pattern
Launch a coroutine that runs on the main or UI thread, because the result affects the UI. Call a suspend function to do the long-running work, so that you don't block the UI thread while waiting for the result. The long-running work has nothing to do with the UI. Switch to the I/O context, so that the work can run in a thread pool that's optimized and set aside for these kinds of operations. Then call the database function to do the work.
ui scope
determines the thread that the coroutine will run on. scope needs to know about the job
MVVM testability
easy to test unit tests in datamodel test ViewModel with Mockito
Project Navigator
left of editor, shows you everything your project contains
MVVM architecture
View (informs the ViewModel about the user's actions) ViewModel (exposes streams of data relevant to the View) DataModel (abstracts the data source. The ViewModel works with the DataModel to get and save the data)
listener bindings
binding expressions that run when events such as onClick(), onZoomIn(), or onZoomOut() are triggered. Listener bindings are written as lambda expressions.
how to use coroutines
you need a job, dispatcher, and a scope
view model
collects data, adds data to the database, and displays the data
custom android View data binding
binding done in the constructor unbinding happens in onDetachedFromWindow
MVP vs MVVM
similar, but Presenter tells the View directly what to display whereas the ViewModel just exposes streams of events. the View is updated with by binding to these events with data binding.
Section 2
(12 cards)