Session #6 loaders and adapters

Loaders and Adapters
#6
Android Academy TLV
11/12/2016
Yossi Segev

Yossi Segev
Crave
Android Academy

Jonathan Yarkoni
Android Developer & Advocate
Ironsource
Android Academy Staff
Yonatan Levin
Google Developer Expert &
Android @ Gett
Britt Barak
Android Lead
Figure8
Yossi Segev
Android Developer
Crave

~ 2000 members Largest Android Active Community

What Do We Do?
●Android Fundamentals
●Android UI / UX
●Community Hackathon
●Android Performance
●Mentors Program

Community Mentors
Betzalel Silver

Today’s agenda
● Part 1: Loaders
○ What are they?
○ Why do we need them?
○ How do we use them?
● Part 2: Adapters
○ View recycling
○ ViewHolder
○ ArrayAdapter
○ CursorAdapter

Android Main/UI Thread
1.Code runs on the main thread (UI thread).

1. Code runs on the main thread (UI thread).
2.Statements are executed in sequence.

2. Statements are executed in sequence.
3.Long operation will block the UI thread.

2. Statements are executed in sequence.
3. Long operation will block the UI thread.
4.Perform long operation off the UI thread.

AsyncTask
✓ Performs background operations off the UI thread.

doInBackground()
@Override
protected String doInBackground(String... params) {
// This code is running on a background thread.
if (!TextUtils.isEmpty(params[0])) {
return "Hello AsyncTask " + params[0];
}
return null;
}

AsyncTask
✓ Returns results on the UI thread.

onPostExecute()
@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
// We're back on the UI thread so we can update the UI from here.
if (!TextUtils.isEmpty(result)) {
mTextView.setText(result);
}
}

AsyncTask
✓ Returns results on the UI thread.
✓ Save time.

AsyncTask = Awesome
But there’s a problem…

Experiment
onCreate() execute()
doInBackground()
Count to 3
.
.
.
onPostExecute()
Activity AsyncTask

Experiment - Logger
public class Logger {
public static void logWithThread(String tag, String message) {
Log.d(tag,
"T:"
+ Thread.currentThread().getId()
+ " | "
+ message);
}
}
D/LogTag: T:1 | The log message.

Experiment - AsyncTask
@Override
protected Void doInBackground(Void... params) {
for (int i = 1 ; i < 4 ; i ++) {
Logger.logWithThread(TAG, "doInBackground: " + i);
try {
Thread.sleep(1000); // Simulates long operation
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return null;
}

Experiment - AsyncTask
public SimpleAsyncTask() {
Logger.logWithThread(TAG, "SimpleAsyncTask created.");
}
// ...
@Override
protected void onPostExecute(Void aVoid) {
super.onPostExecute(aVoid);
Logger.logWithThread(TAG, "onPostExecute()");
}

Experiment - Activity
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Logger.logWithThread(TAG, "onCreate()");
setContentView(R.layout.activity_async_task);
// Creating a new AsyncTask
SimpleAsyncTask simpleAsyncTask = new SimpleAsyncTask();
simpleAsyncTask.execute();
}

Experiment - Activity
@Override
protected void onDestroy() {
super.onDestroy();
Logger.logWithThread(TAG, "onDestroy()");
}

Test log #1
D/Activity: T:1 | onCreate()
D/AsyncTask: T:1 | SimpleAsyncTask created.
D/AsyncTask: T:132 | doInBackground: 1
D/AsyncTask: T:1 | onPostExecute()

Test log #1
Activity lifecycle

Test log #1
Activity lifecycle
AsyncTask

Test log #2
D/Activity: T:1 | onDestroy()

Test log #2
Activity lifecycle
AsyncTask

Test log #2
Activity lifecycle
AsyncTask
AsyncTask #2

✘ No coordination with Activity lifecycle.
✘ Multiple AsyncTasks.
✘ onPostExecute() has no effect.
Test #2 results

Loaders
● Loading data asynchronously.
● Coordinating with Activity lifecycle.
● Surviving configuration changes.
● Observing the data source for changes.

Loaders - Where?
Available to every Activity.
First introduced in Android 3.0 (Honeycomb, API 11).
Part of the v4 support library (Compatibility Library).

Loader
Loader
Doing background work
● Loading data asynchronously.
● Can monitor the data source.

LoaderCallbacks
LoaderCallBacks
Notify on Loader events
Events:
● New Loader is needed.
● Data is ready.
● Loader is about to reset.

LoaderManager
● Monitor Activity lifecycle.
● Manage Loaders:
➢ Start / Stop / Reset / Retrain
(Activity lifecycle / direct request)
● Invoke LoaderCallBacks.
LoaderManager
Monitor Activity
Manage Loaders
Notify LoaderCallBacks

How Loaders work
Loader
Doing background work
LoaderCallBacks
LoaderManager
Monitor Activity
Manage Loaders
Notify LoaderCallBacks
Create

Creating a Loader
Loader<D>
The base class of all Loaders.
AsyncTaskLoader<D>
Subclass of Loader<D>, uses AsyncTask to do its
work in the background.
CursorLoader<D>
Subclass of AsyncTaskLoader<Cursor>, built to
query ContentProviders and monitor their data.

Creating a Loader
1. Create class that extends AsyncTaskLoader<String>.
1. Implement loadInBackground().
2. Override deliverResult().
1. Override onStartLoading().

SimpleLoader.java
public class SimpleLoader extends AsyncTaskLoader<String> {
public SimpleLoader(Context context) {
super(context);
}
}

SimpleLoader.java
@Override
public String loadInBackground() {
// Simulate long operation
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// Return data
return "I'm a data string.";
}

SimpleLoader.java
private String mCache;
// ...
@Override
public void deliverResult(String data) {
mCache = data;
super.deliverResult(data);
}

SimpleLoader.java
private String mCache;
// ...
@Override
protected void onStartLoading() {
super.onStartLoading();
if (TextUtils.isEmpty(mCache)) {
forceLoad();
} else {
deliverResult(mCache);
}
}

We have a Loader...
Now preparing our Activity

Preparing our Activity
1. Implement a LoaderCallbacks<String> interface.
2. Create Loader unique ID.
3. Initialize our Loader.

MyActivity.java
public class MyActivity extends Activity implements
LoaderManager.LoaderCallbacks<String> {
@Override
setContentView(R.layout.activity_myactivity);
mTextView = (TextView) findViewById(R.id.text_view);
mProgressBar = (ProgressBar) findViewById(R.id.progress_bar);
showLoadingIndicator();
//todo init loader
}

LoaderCallbacks
LoaderCallBacks
Events:
● New Loader is needed.
● Loader data is ready.
● Loader is about to reset.

LoaderCallbacks<String>
New Loader is needed
onCreateLoader(int id, Bundle args)
Loader unique ID Optional Bundle

MyActivity.java
// ...
@Override
public Loader<String> onCreateLoader(int id, Bundle args) {
return new SimpleLoader(this);
}

Loader data is ready
onLoadFinished(Loader<String> loader, String data)
Finished Loader. Returned data
Check Loader ID:
loader.getId()

MyActivity.java
// ...
@Override
public void onLoadFinished(Loader<String> loader, String data) {
if (!TextUtils.isEmpty(data)) {
showData(data);
}
}

Loader is about to reset
onLoaderReset(Loader<String> loader)
Check Loader ID:
loader.getId()

MyActivity.java
// ...
@Override
public void onLoaderReset(Loader<String> loader) {
// Our chance to clear data, reset UI etc...
}

Create Loader unique ID
Used to identify the Loader by LoaderManager and the Activity.
private static final int SIMPLE_LOADER_ID = 100;

Init Loader
getLoaderManager().initLoader(LOADER_ID, args, LoaderCallbacks);

Init Loader
Getting a reference to the Activity LoaderManager

Init Loader
Instruct LoaderManager to initialize the Loader

Init Loader
Unique Loader ID to init

Init Loader
Optional Bundle
Can be used for Loader creation

Init Loader
Interface to report on Loader state changes

MyActivity.java
public class MyActivity extends Activity implements
LoaderManager.LoaderCallbacks<String> {
private static final int SIMPLE_LOADER_ID = 100;
@Override
setContentView(R.layout.activity_myactivity);
mTextView = (TextView) findViewById(R.id.text_view);
mProgressBar = (ProgressBar) findViewById(R.id.progress_bar);
showLoadingIndicator();
getLoaderManager().initLoader(SIMPLE_LOADER_ID, null, this);
}

initLoader()
LoaderManager
initLoader(LOADER_ID, args, LoaderCallbacks);
No.
onCreateLoader(int id, Bundle
args)
Use the existing Loader
Yes.

Init new Loader
LoaderManager
onCreateLoader(int id, Bundle args)

Init new Loader
LoaderManager
onStartLoading()
loadInBackground()
deliverResult(D data)

Init new Loader
LoaderManager
onLoadFinished(Loader<D> loader, D data)

Use existing Loader
deliverResult(D data)
Loader state ?
onLoadFinished(Loader<D> loader, D data)

Remember
● initLoader() - when ready to receive data.
● Need fresh data? Call restartLoader().

Let’s talk about the CursorLoader

CursorLoader
Subclass of AsyncTaskLoader<Cursor>.
Queries ContentProviders.
Monitor data changes using ContentObserver.
Returns a Cursor.

CursorLoader #1
@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args) {
CursorLoader loader = new CursorLoader(this);
loader.setUri(ContactsContract.Contacts.CONTENT_URI);
return loader;
}

CursorLoader #2
// …
Bundle args = new Bundle();
args.putString(ARGS_SEARCH_QUERY, “Yossi”);
getLoaderManager().initLoader(CONTACTS_LOADER_ID, args, this);

CursorLoader #2
@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args) {
String searchQuery = args.getString(ARGS_SEARCH_QUERY);
String selection = ContactsContract.Contacts.DISPLAY_NAME + " = ?";
String[] selectionArgs = { searchQuery };
return new CursorLoader(
this, // Context
ContactsContract.Contacts.CONTENT_URI, // Table
null, // Projections
selection, // Selection
selectionArgs, // Selection args
null); // Sort order
}

Adapter
A “bridge” between an AdapterView and it’s underlying data.
Has access to the data items.
Building a View for each item.

Adapter
Data set
ListView (AdapterView)
Adapter
Position Position
Data View

Adapter
Adapter interface
BaseAdapter
Base class of common implementation
for an Adapter
ArrayAdapter<T>
Uses array as a data source
CursorAdapter
Uses Cursor as a data source

Sunshine app ArrayAdapter
// The ArrayAdapter will take data from a source and
// use it to populate the ListView it's attached to.
mForecastAdapter =
new ArrayAdapter<String>(
getActivity(), // The current context (this activity)
R.layout.list_item_forecast, // The name of the layout ID.
R.id.list_item_forecast_textview, // The ID of the textview to populate.
new ArrayList<String>());

Building a custom ArrayAdapter

Custom ArrayAdapter
1. Define the data model.
2. Create a custom XML layout.
3. Create UsersAdapter class.
4. Override getView().
5. Tweak for performance

User.java
public class User {
private String mFullName;
private String mPhoneNumber;
public User(String fullName, String phoneNumber) {
mFullName = fullName;
mPhoneNumber = phoneNumber;
}
public String getFullName() { return mFullName; }
public String getPhoneNumber() { return mPhoneNumber; }
}

XML layout
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<TextView
android:id="@+id/users_adapter_row_fullname"
android:layout_height="wrap_content"
android:textSize="20sp"
tools:text="Full Name"/>
<TextView
android:id="@+id/users_adapter_row_phone"
android:layout_height="wrap_content"
android:textSize="16sp"
tools:text="123-4567"/>
</LinearLayout>

UsersAdapter.java
public class UsersAdapter extends ArrayAdapter<User> {
public UsersAdapter(Context context, User[] users) {
// We'll Override getView()
// layout res can be 0.
super(context, 0, users);
}
@Override
public View getView(int position, View convertView, ViewGroup parent)
{
//todo implement this method
}

getView()
Called for every AdapterView position.
getView(int position, View convertView, ViewGroup parent)

getView()
Convert data into a View.

getView()
Reference to current position.

getView()
Reference to current position.
Has access to recycled views.

getView()
@Override
public View getView(int position, View convertView, ViewGroup parent) {
}

getView()
@Override
User user = getItem(position);
}
Get data object by position

getView()
@Override
if (convertView == null) {
convertView = LayoutInflater.from(getContext())
.inflate(R.layout.users_adapter_row, parent, false);
}
}
Inflate XML (only if needed)

View recycling

getView()
@Override
}
TextView fullName = (TextView) convertView.findViewById(R.id.users_adapter_row_fullname);
TextView phoneNumber = (TextView) convertView.findViewById(R.id.users_adapter_row_phone);
}
Reference layout Views

getView()
@Override
}
fullName.setText(user.getFullName());
phoneNumber.setText(user.getPhoneNumber());
}
Bind data to Views

getView()
@Override
}
return convertView;
}
Return View

getView()
@Override
}
return convertView;
}

ViewHolder
Hold references to the Views
Skip findViewById()

ViewHolder
public class UsersAdapter extends ArrayAdapter<User> {
// ...
private static class ViewHolder {
TextView fullName;
TextView phoneNumber;
}
}

ViewHolder
}

ViewHolder
ViewHolder vh;
}

ViewHolder
ViewHolder vh;
vh = new ViewHolder();
vh.fullName = (TextView) convertView.findViewById(R.id.users_adapter_row_fullname);
vh.phoneNumber = (TextView) convertView.findViewById(R.id.users_adapter_row_phone);
}

ViewHolder
ViewHolder vh;
convertView.setTag(vh);
}

ViewHolder
ViewHolder vh;
convertView.setTag(vh);
} else {
vh = (ViewHolder) convertView.getTag();
}

ViewHolder
// ...
vh.fullName.setText(user.getFullName());
vh.phoneNumber.setText(user.getPhoneNumber());

getView() with ViewHolder
@Override
ViewHolder vh;
vh = new ViewHolder(); // Create a new ViewHolder
convertView.setTag(vh); // Store it as a tag
} else {
vh = (ViewHolder) convertView.getTag(); // use the ViewHolder
}
vh.fullName.setText(user.getFullName());
vh.phoneNumber.setText(user.getPhoneNumber());
return convertView;
}

CursorAdapter
1. Subclass of the abstract BaseAdapter class.
2. Using a Cursor as a data source.
3.getView() is mostly implemented.

CursorAdapter source code
if (!mDataValid) {
throw new IllegalStateException("this should only be called when the cursor is valid");
}
if (!mCursor.moveToPosition(position)) {
throw new IllegalStateException("couldn't move cursor to position " + position);
}
View v;
v = newView(mContext, mCursor, parent);
} else {
v = convertView;
}
bindView(v, mContext, mCursor);
return v;
}

CursorAdapter
1.newView():
Used to inflate a new view and return it.
2.bindView():
Get Cursor Extract data Bind data to View.

CursorAdapter
public class ContactCursorAdapter extends CursorAdapter {
public ContactCursorAdapter(Context context, Cursor c,
boolean autoRequery) {
super(context, c, autoRequery);
}
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
// Inflate new view
return LayoutInflater.from(context)
.inflate(R.layout.contacts_adapter_row, parent, false);
}
// ...
}

CursorAdapter
@Override
public void bindView(View view, Context context, Cursor cursor) {
int idx = cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);
TextView displayName =
(TextView) view.findViewById(R.id.contacts_adapter_row_displayName);
// Get cursor + extract data
String name = cursor.getString(idx);
// Bind data to the view
displayName.setText(name);
}

CursorAdapter + ViewHolder
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
// Inflate new view
View view = LayoutInflater.from(context)
.inflate(R.layout.contacts_adapter_row, parent, false);
// Create a new view holder
ViewHolder vh = new ViewHolder();
vh.displayName = (TextView) view.findViewById(R.id.contacts_adapter_row_displayName);
// Save as tag
view.setTag(vh);
return view;
}

CursorAdapter + ViewHolder
@Override
public void bindView(View view, Context context, Cursor cursor) {
int idx = cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);
// Get the view holder from the view tag
ViewHolder vh = (ViewHolder) view.getTag();
// Get cursor + extract data
String name = cursor.getString(idx);
// Bind data to the view
vh.displayName.setText(name);

What we didn’t cover today
Multiple layouts
RecyclerView

Session #6 loaders and adapters

More Related Content

What's hot

Viewers also liked

Similar to Session #6 loaders and adapters

More from Vitali Pekelis

Recently uploaded

Session #6 loaders and adapters