Android之Loader理解

001

/**

002

* Demonstration of the use of a CursorLoader to load and display contacts

003

* data in a fragment.

004

*/

005

public

class

LoaderCursor 

extends

Activity {

006

007

@Override

008

protected

void

onCreate(Bundle savedInstanceState) {

009

super

.onCreate(savedInstanceState);

010

011

FragmentManager fm = getFragmentManager();

012

013

// Create the list fragment and add it as our sole content.

014

if

(fm.findFragmentById(android.R.id.content) == 

null

) {

015

CursorLoaderListFragment list = 

new

CursorLoaderListFragment();

016

fm.beginTransaction().add(android.R.id.content, list).commit();

017

}

018

}

019

020

021

public

static

class

CursorLoaderListFragment 

extends

ListFragment

022

implements

LoaderManager.LoaderCallbacks<Cursor> {

023

024

// This is the Adapter being used to display the list's data.

025

SimpleCursorAdapter mAdapter;

026

027

// If non-null, this is the current filter the user has provided.

028

String mCurFilter;

029

030

@Override

public

void

onActivity
4000
Created(Bundle savedInstanceState) {

031

032

mAdapter = 

new

SimpleCursorAdapter(getActivity(),

033

android.R.layout.simple_list_item_2, 

null

,

034

new

String[] { Contacts.DISPLAY_NAME, Contacts.CONTACT_STATUS },

035

new

int

[] { android.R.id.text1, android.R.id.text2 }, 

0

);

036

setListAdapter(mAdapter);

037

038

getLoaderManager().initLoader(

0

, 

null

, 

this

);

039

}

040

041

042

@Override

public

void

onListItemClick(ListView l, View v, 

int

position, 

long

id)
{

043

// Insert desired behavior here.

044

Log.i(

"FragmentComplexList"

, 

"Item clicked: "

+ id);

045

}

046

047

// These are the Contacts rows that we will retrieve.

048

static

final

String[] CONTACTS_SUMMARY_PROJECTION = 

new

String[] {

049

Contacts._ID,

050

Contacts.DISPLAY_NAME,

051

Contacts.CONTACT_STATUS,

052

Contacts.CONTACT_PRESENCE,

053

Contacts.PHOTO_ID,

054

Contacts.LOOKUP_KEY,

055

};

056

057

public

Loader<Cursor> onCreateLoader(

int

id, Bundle args) {

058

// This is called when a new Loader needs to be created.  This

059

// sample only has one Loader, so we don't care about the ID.

060

// First, pick the base URI to use depending on whether we are

061

// currently filtering.

062

Uri baseUri;

063

if

(mCurFilter != 

null

) {

064

baseUri = Uri.withAppendedPath(Contacts.CONTENT_FILTER_URI,

065

Uri.encode(mCurFilter));

066

} 

else

{

067

baseUri = Contacts.CONTENT_URI;

068

}

069

070

// Now create and return a CursorLoader that will take care of

071

// creating a Cursor for the data being displayed.

072

String select = 

"(("

+ Contacts.DISPLAY_NAME + 

" NOTNULL) AND ("

073

+ Contacts.HAS_PHONE_NUMBER + 

"=1) AND ("

074

+ Contacts.DISPLAY_NAME + 

" != '' ))"

;

075

return

new

CursorLoader(getActivity(), baseUri,

076

CONTACTS_SUMMARY_PROJECTION, select, 

null

,

077

Contacts.DISPLAY_NAME + 

" COLLATE LOCALIZED ASC"

);

078

}

079

080

public

void

onLoadFinished(Loader<Cursor> loader, Cursor data) {

081

// Swap the new cursor in.  (The framework will take care of closing the

082

// old cursor once we return.)

083

mAdapter.swapCursor(data);

084

085

// The list should now be shown.

086

if

(isResumed()) {

087

setListShown(

true

);

088

} 

else

{

089

setListShownNoAnimation(

true

);

090

}

091

}

092

093

public

void

onLoaderReset(Loader<Cursor> loader) {

094

// This is called when the last Cursor provided to onLoadFinished()

095

// above is about to be closed.  We need to make sure we are no

096

// longer using it.

097

mAdapter.swapCursor(

null

);

098

}

099

}

100

101

}

01

public

<D> Loader<D> initLoader(

int

id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {

02

if

(mCreatingLoader) {

03

throw

new

IllegalStateException(

"Called while creating a loader"

);

04

}

05

06

LoaderInfo info = mLoaders.get(id);

07

08

if

(info == 

null

) {

09

// Loader doesn't already exist; create.

10

info = createAndInstallLoader(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);

11

if

(DEBUG) Log.v(TAG, 

"  Created new loader "

+ info);

12

} 

else

{

13

if

(DEBUG) Log.v(TAG, 

"  Re-using existing loader "

+ info);

14

info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback;

15

}

16

17

if

(info.mHaveData && mStarted) {

18

// If the loader has already generated its data, report it now.

19

info.callOnLoadFinished(info.mLoader, info.mData);

20

}

21

22

return

(Loader<D>)info.mLoader;

23

}

01

private

LoaderInfo createAndInstallLoader(

int

id, Bundle args,

02

LoaderManager.LoaderCallbacks<Object> callback) {

03

try

{

04

mCreatingLoader = 

true

;

05

LoaderInfo info = createLoader(id, args, callback);

06

installLoader(info);

07

return

info;

08

} 

finally

{

09

mCreatingLoader = 

false

;

10

}

11

}

12

13

private

LoaderInfo createLoader(

int

id, Bundle args,

14

LoaderManager.LoaderCallbacks<Object> callback) {

15

LoaderInfo info = 

new

LoaderInfo(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);

16

Loader<Object> loader = callback.onCreateLoader(id, args);

17

info.mLoader = (Loader<Object>)loader;

18

return

info;

19

}

20

21

void

installLoader(LoaderInfo info) {

22

mLoaders.put(info.mId, info);

23

if

(mStarted) {

24

// The activity will start all existing loaders in it's onStart(),

25

// so only start them here if we're past that point of the activitiy's

26

// life cycle

27

info.start();

28

}

29

}

01

void

start() {

02

if

(mLoader != 

null

) {

03

04

if

(!mListenerRegistered) {

05

mLoader.registerListener(mId, 

this

);

06

mListenerRegistered = 

true

;

07

}

08

mLoader.startLoading();

09

}

10

}

01

Loader：

02

public

final

void

startLoading() {

03

mStarted = 

true

;

04

mReset = 

false

;

05

mAbandoned = 

false

;

06

onStartLoading();

07

}

08

09

CursorLoader:

10

protected

void

onStartLoading() {

11

if

(mCursor != 

null

) {

12

deliverResult(mCursor);

13

}

14

if

(takeContentChanged() || mCursor == 

null

) {

15

forceLoad();

16

}

17

}

18

19

AsynTaskLoader:

20

protected

void

onForceLoad() {

21

super

.onForceLoad();

22

cancelLoad();

23

mTask = 

new

LoadTask();

24

if

(DEBUG) Slog.v(TAG, 

"Preparing load: mTask="

+ mTask);

25

executePendingTask();

26

}

01

AsyncTaskLoader:

02

final

class

LoadTask 

extends

AsyncTask<Void, Void, D> 

implements

Runnable
{

03

private

final

CountDownLatch mDone = 

new

CountDownLatch(

1

);

04

05

// Set to true to indicate that the task has been posted to a handler for

06

// execution at a later time.  Used to throttle updates.

07

boolean

waiting;

08

09

/* Runs on a worker thread */

10

@Override

11

protected D doInBackground(Void... params) {

12

if (DEBUG) Slog.v(TAG, this + " >>> doInBackground");

13

try {

14

D data = AsyncTaskLoader.this.onLoadInBackground();

15

return data;

16

} catch (OperationCanceledException ex) {

17

}

18

}

19

20

/* Runs on the UI thread */

21

@Override

22

protected

void

onPostExecute(D data) {

23

if

(DEBUG) Slog.v(TAG, 

this

+ 

" onPostExecute"

);

24

try

{

25

AsyncTaskLoader.

this

.dispatchOnLoadComplete(

this

, data);

26

} 

finally

{

27

mDone.countDown();

28

}

29

}

30

}

31

32

AsyncTaskLoader：   

33

protected

D onLoadInBackground() {

34

return

loadInBackground();

35

}  

36

37

CursorLoader:

38

public

Cursor loadInBackground() {

39

try

{

40

Cursor cursor = getContext().getContentResolver().query(mUri, mProjection, mSelection,

41

mSelectionArgs, mSortOrder, mCancellationSignal);

42

if

(cursor != 

null

) {

43

// Ensure the cursor window is filled

44

cursor.getCount();

45

registerContentObserver(cursor, mObserver);

46

}

47

return

cursor;

48

} 

finally

{

49

synchronized

(

this

) {

50

mCancellationSignal = 

null

;

51

}

52

53

}

01

public

void

onChange(

boolean

selfChange) {

02

onContentChanged();

03

}

04

05

public

void

onContentChanged() {

06

if

(mStarted) {

07

forceLoad();    

//这里重新发送请求.

08

} 

else

{

09

// This loader has been stopped, so we don't want to load

10

// new data right now...  but keep track of it changing to

11

// refresh later if we start again.

12

mContentChanged = 

true

;

13

}

14

}

01

Activity:

02

protected

void

onStart() {

03

if

(DEBUG_LIFECYCLE) Slog.v(TAG, 

"onStart "

+ 

this

);

04

mCalled = 

true

;

05

06

if

(!mLoadersStarted) {

07

mLoadersStarted = 

true

;

08

if

(mLoaderManager != 

null

) {

09

mLoaderManager.doStart();

10

} 

else

if

(!mCheckedForLoaderManager) {

11

mLoaderManager = getLoaderManager(

null

, mLoadersStarted, 

false

);

12

}

13

mCheckedForLoaderManager = 

true

;

14

}

15

16

getApplication().dispatchActivityStarted(

this

);

17

}

18

19

LoaderManagerImp：

20

void

doStart() {

21

if

(DEBUG) Log.v(TAG, 

"Starting in "

+ 

this

);

22

if

(mStarted) {

23

RuntimeException e = 

new

RuntimeException(

"here"

);

24

e.fillInStackTrace();

25

Log.w(TAG, 

"Called doStart when already started: "

+ 

this

, e);

26

return

;

27

}

28

29

mStarted = 

true

;

30

31

// Call out to sub classes so they can start their loaders

32

// Let the existing loaders know that we want to be notified when a load is complete

33

for

(

int

i = mLoaders.size()-

1

; i >= 

0

;
i--) {

34

mLoaders.valueAt(i).start();

35

}

36

}