Java 类android.support.v4.app.LoaderManager.LoaderCallbacks 实例源码

public <D> Loader<D> initLoader(int id, Bundle args, LoaderCallbacks<D> callback) {
    if (this.mCreatingLoader) {
        throw new IllegalStateException("Called while creating a loader");
    }
    LoaderInfo info = (LoaderInfo) this.mLoaders.get(id);
    if (DEBUG) {
        Log.v(TAG, "initLoader in " + this + ": args=" + args);
    }
    if (info == null) {
        info = createAndInstallLoader(id, args, callback);
        if (DEBUG) {
            Log.v(TAG, "  Created new loader " + info);
        }
    } else {
        if (DEBUG) {
            Log.v(TAG, "  Re-using existing loader " + info);
        }
        info.mCallbacks = callback;
    }
    if (info.mHaveData && this.mStarted) {
        info.callOnLoadFinished(info.mLoader, info.mData);
    }
    return info.mLoader;
}

public <D> Loader<D> initLoader(int id, Bundle args, LoaderCallbacks<D> callback) {
    if (this.mCreatingLoader) {
        throw new IllegalStateException("Called while creating a loader");
    }
    LoaderInfo info = (LoaderInfo) this.mLoaders.get(id);
    if (DEBUG) {
        Log.v(TAG, "initLoader in " + this + ": args=" + args);
    }
    if (info == null) {
        info = createAndInstallLoader(id, args, callback);
        if (DEBUG) {
            Log.v(TAG, "  Created new loader " + info);
        }
    } else {
        if (DEBUG) {
            Log.v(TAG, "  Re-using existing loader " + info);
        }
        info.mCallbacks = callback;
    }
    if (info.mHaveData && this.mStarted) {
        info.callOnLoadFinished(info.mLoader, info.mData);
    }
    return info.mLoader;
}

private final void startDownload() {
    final Bundle bundle = new Bundle();

    // 認証情報をキャッシュしていないか、確認する.
    final Uri uri = Uri.parse(mAddress);
    final HttpClientLoaderCallbacks.AuthData authData = BasicAuthManager.getInstance().getAuthData(uri.getHost());
    HttpClientLoaderCallbacks.setAuthDataToBundle(bundle, authData);

    // アドレスを設定しておく.
    bundle.putString(ImageFileDownloadLoaderCallbacks.KEY_ADDRESS, mAddress);

    // ファイルをダウンロードする.
    final LoaderCallbacks<ImageFileBase> loaderCallbacks = new ImageFileDownloadLoaderCallbacks(ImagePageFragment.this) {
        @Override
        protected void onAuthorizationRequired(String message) {
            final DialogFragment dialog = BasicAuthorizeDialogFragment.newInstance(message);
            dialog.show(getChildFragmentManager(), TAG_AUTHORIZE);
        }
    };
    getLoaderManager().initLoader(R.id.cached_image_loader, bundle, loaderCallbacks);
}

private LoaderInfo createAndInstallLoader(int id, Bundle args, LoaderCallbacks<Object> callback) {
    try {
        this.mCreatingLoader = true;
        LoaderInfo info = createLoader(id, args, callback);
        installLoader(info);
        return info;
    } finally {
        this.mCreatingLoader = false;
    }
}

private LoaderInfo createAndInstallLoader(int id, Bundle args, LoaderCallbacks<Object> callback) {
    try {
        this.mCreatingLoader = true;
        LoaderInfo info = createLoader(id, args, callback);
        installLoader(info);
        return info;
    } finally {
        this.mCreatingLoader = false;
    }
}

@Override
public void onLoaderReset(Loader<Cursor> loader) {
    LoaderManager.LoaderCallbacks<Cursor> parent = getSearchResultFragmentLoaderCallbacks();
    if (parent != null) parent.onLoaderReset(loader);

    //((CursorAdapter) getListAdapter()).swapCursor(null);
    ((CursorAdapter) getListAdapter()).changeCursor(null);
}

@Override
    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
        LoaderManager.LoaderCallbacks<Cursor> parent = getSearchResultFragmentLoaderCallbacks();
        if (parent != null) parent.onLoadFinished(loader, data);

        switch (loader.getId()) {
            case ID_LOADER_ALL_DATA_DETAIL:
                // Transactions list loaded.
                AllDataAdapter adapter = (AllDataAdapter) getListAdapter();
//                adapter.swapCursor(data);
                adapter.changeCursor(data);
                if (isResumed()) {
                    setListShown(true);
                    if (data != null && data.getCount() <= 0 && getFloatingActionButton() != null)
                        getFloatingActionButton().show(true);
                } else {
                    setListShownNoAnimation(true);
                }

                // reset the transaction groups (account name collection)
                adapter.resetAccountHeaderIndexes();

                // Show totals
                if (this.mShowFooter) {
                    try {
                        this.updateFooter(data);
                    } catch (Exception e) {
                        Timber.e(e, "displaying footer");
                    }
                }
        }
    }

/**
 * ダウンロードを開始する.
 * 
 * @param downloader ダウンローダ.
 */
private void startDownload(final DownloaderBase downloader) {
    final String address = downloader.getAddress(0);
    final Bundle bundle = new Bundle();

    // 認証情報をキャッシュしていないか、確認する.
    final Uri uri = Uri.parse(address);
    final HttpClientLoaderCallbacks.AuthData authData = BasicAuthManager.getInstance().getAuthData(uri.getHost());
    HttpClientLoaderCallbacks.setAuthDataToBundle(bundle, authData);

    // アドレスを設定しておく.
    bundle.putString(ImageFileDownloadLoaderCallbacks.KEY_ADDRESS, address);

    // ファイルをダウンロードする.
    final LoaderCallbacks<ImageFileBase> loaderCallbacks = new ImageFileDownloadLoaderCallbacks(ImageViewerFragment.this) {
        @Override
        protected void onAuthorizationRequired(String message) {
            final DialogFragment dialog = BasicAuthorizeDialogFragment.newInstance(message);
            dialog.show(getChildFragmentManager(), TAG_AUTHORIZE);
        }

        @Override
        protected void onHttpClientLoadFinished(HttpClientLoader<ImageFileBase> loader, ImageFileBase imageFile) {
            super.onHttpClientLoadFinished(loader, imageFile);

            if (imageFile != null) {
                // ViewPagerにページをセットする.
                mViewPager.setAdapter(new AlbumPagerAdapter(getActivity(), downloader));
            }
        }

    };

    getLoaderManager().initLoader(R.id.cached_image_loader, bundle, loaderCallbacks);
}

RepositoriesLoadable(LoaderManager loaderManager, int loaderId,
        LoaderCallbacks<Result<Repositories>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}

TweetsLoadable(LoaderManager loaderManager, int loaderId,
        LoaderCallbacks<Result<Timeline>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}

PhotosLoadable(LoaderManager loaderManager, int loaderId,
        LoaderCallbacks<Result<ContactsPhotos>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}

public LoadableDecorator(LoaderCallbacks<Result<T>> callbacks, int loaderId,
        ListFragment listFragment) {
    super();
    this.mCallbacks = Preconditions.checkNotNull(callbacks);
    this.mLoaderId = loaderId;
    this.mListFragment = Preconditions.checkNotNull(listFragment);
    this.mAdapterView = Preconditions.checkNotNull(listFragment.getListView());

    mListFragment.setListShown(false);
}

PlurksLoadable(LoaderManager loaderManager, int loaderId,
        LoaderCallbacks<Result<Timeline>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}

public LiveFragment() {
    if (HotFix.PREVENT_VERIFY) {
        System.out.println(VerifyLoad.class);
    }
    this.SCROLL_LEFT = 1;
    this.SCROLL_RIGTH = -1;
    this.mLiveList = new ArrayList();
    this.mGotoChildPageIndex = -1;
    this.mRefreshData = new RefreshData(this) {
        final /* synthetic */ LiveFragment this$0;

        {
            if (HotFix.PREVENT_VERIFY) {
                System.out.println(VerifyLoad.class);
            }
            this.this$0 = this$0;
        }

        public void refreshData() {
            this.this$0.mRootView.loading(false);
            this.this$0.getData();
        }
    };
    this.mBookLoaderCallback = new LoaderCallbacks<Cursor>(this) {
        final /* synthetic */ LiveFragment this$0;

        {
            if (HotFix.PREVENT_VERIFY) {
                System.out.println(VerifyLoad.class);
            }
            this.this$0 = this$0;
        }

        public Loader<Cursor> onCreateLoader(int id, Bundle args) {
            return new CursorLoader(this.this$0.getContext(), LetvContentProvider.URI_LIVEBOOKTRACE, null, null, null, null);
        }

        public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
            if (cursor != null) {
                Set<String> mBookedPrograms = new HashSet();
                while (cursor.moveToNext()) {
                    try {
                        int idx = cursor.getColumnIndexOrThrow(Field.MD5_ID);
                        if (idx != -1) {
                            mBookedPrograms.add(cursor.getString(idx));
                        }
                    } catch (SQLiteException e) {
                        e.printStackTrace();
                        return;
                    }
                }
                if (this.this$0.mLiveAdapter != null) {
                    this.this$0.mLiveAdapter.setBookedPrograms(mBookedPrograms);
                }
            }
        }

        public void onLoaderReset(Loader<Cursor> loader) {
        }
    };
}

public LiveSubTypeActivity() {
    if (HotFix.PREVENT_VERIFY) {
        System.out.println(VerifyLoad.class);
    }
    this.mData = new ArrayList();
    this.mLunboData = new ArrayList();
    this.mPrograms = new HashMap();
    this.mCurrentActionType = 1;
    this.mBookLoaderCallback = new LoaderCallbacks<Cursor>(this) {
        final /* synthetic */ LiveSubTypeActivity this$0;

        {
            if (HotFix.PREVENT_VERIFY) {
                System.out.println(VerifyLoad.class);
            }
            this.this$0 = this$0;
        }

        public Loader<Cursor> onCreateLoader(int id, Bundle args) {
            return new CursorLoader(this.this$0, LetvContentProvider.URI_LIVEBOOKTRACE, null, null, null, null);
        }

        public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
            if (cursor != null) {
                Set<String> mBookedPrograms = new HashSet();
                while (cursor.moveToNext()) {
                    try {
                        int idx = cursor.getColumnIndexOrThrow(Field.MD5_ID);
                        if (idx != -1) {
                            mBookedPrograms.add(cursor.getString(idx));
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        return;
                    }
                }
                if (this.this$0.mRoomAdapter != null) {
                    this.this$0.mRoomAdapter.setBookedPrograms(mBookedPrograms);
                }
            }
        }

        public void onLoaderReset(Loader<Cursor> loader) {
        }
    };
    this.mRefreshData = new RefreshData(this) {
        final /* synthetic */ LiveSubTypeActivity this$0;

        {
            if (HotFix.PREVENT_VERIFY) {
                System.out.println(VerifyLoad.class);
            }
            this.this$0 = this$0;
        }

        public void refreshData() {
            this.this$0.mRootView.loading(false);
            this.this$0.getData();
        }
    };
}

public LoaderInfo(int id, Bundle args, LoaderCallbacks<Object> callbacks) {
    this.mId = id;
    this.mArgs = args;
    this.mCallbacks = callbacks;
}

private LoaderInfo createLoader(int id, Bundle args, LoaderCallbacks<Object> callback) {
    LoaderInfo info = new LoaderInfo(id, args, callback);
    info.mLoader = callback.onCreateLoader(id, args);
    return info;
}

public <D> Loader<D> restartLoader(int id, Bundle args, LoaderCallbacks<D> callback) {
    if (this.mCreatingLoader) {
        throw new IllegalStateException("Called while creating a loader");
    }
    LoaderInfo info = (LoaderInfo) this.mLoaders.get(id);
    if (DEBUG) {
        Log.v(TAG, "restartLoader in " + this + ": args=" + args);
    }
    if (info != null) {
        LoaderInfo inactive = (LoaderInfo) this.mInactiveLoaders.get(id);
        if (inactive == null) {
            if (DEBUG) {
                Log.v(TAG, "  Making last loader inactive: " + info);
            }
            info.mLoader.abandon();
            this.mInactiveLoaders.put(id, info);
        } else if (info.mHaveData) {
            if (DEBUG) {
                Log.v(TAG, "  Removing last inactive loader: " + info);
            }
            inactive.mDeliveredData = false;
            inactive.destroy();
            info.mLoader.abandon();
            this.mInactiveLoaders.put(id, info);
        } else if (info.mStarted) {
            if (DEBUG) {
                Log.v(TAG, "  Current loader is running; attempting to cancel");
            }
            info.cancel();
            if (info.mPendingLoader != null) {
                if (DEBUG) {
                    Log.v(TAG, "  Removing pending loader: " + info.mPendingLoader);
                }
                info.mPendingLoader.destroy();
                info.mPendingLoader = null;
            }
            if (DEBUG) {
                Log.v(TAG, "  Enqueuing as new pending loader");
            }
            info.mPendingLoader = createLoader(id, args, callback);
            return info.mPendingLoader.mLoader;
        } else {
            if (DEBUG) {
                Log.v(TAG, "  Current loader is stopped; replacing");
            }
            this.mLoaders.put(id, null);
            info.destroy();
        }
    }
    return createAndInstallLoader(id, args, callback).mLoader;
}

public LoaderInfo(int id, Bundle args, LoaderCallbacks<Object> callbacks) {
    this.mId = id;
    this.mArgs = args;
    this.mCallbacks = callbacks;
}

private LoaderInfo createLoader(int id, Bundle args, LoaderCallbacks<Object> callback) {
    LoaderInfo info = new LoaderInfo(id, args, callback);
    info.mLoader = callback.onCreateLoader(id, args);
    return info;
}

public <D> Loader<D> restartLoader(int id, Bundle args, LoaderCallbacks<D> callback) {
    if (this.mCreatingLoader) {
        throw new IllegalStateException("Called while creating a loader");
    }
    LoaderInfo info = (LoaderInfo) this.mLoaders.get(id);
    if (DEBUG) {
        Log.v(TAG, "restartLoader in " + this + ": args=" + args);
    }
    if (info != null) {
        LoaderInfo inactive = (LoaderInfo) this.mInactiveLoaders.get(id);
        if (inactive == null) {
            if (DEBUG) {
                Log.v(TAG, "  Making last loader inactive: " + info);
            }
            info.mLoader.abandon();
            this.mInactiveLoaders.put(id, info);
        } else if (info.mHaveData) {
            if (DEBUG) {
                Log.v(TAG, "  Removing last inactive loader: " + info);
            }
            inactive.mDeliveredData = false;
            inactive.destroy();
            info.mLoader.abandon();
            this.mInactiveLoaders.put(id, info);
        } else if (info.mStarted) {
            if (DEBUG) {
                Log.v(TAG, "  Current loader is running; attempting to cancel");
            }
            info.cancel();
            if (info.mPendingLoader != null) {
                if (DEBUG) {
                    Log.v(TAG, "  Removing pending loader: " + info.mPendingLoader);
                }
                info.mPendingLoader.destroy();
                info.mPendingLoader = null;
            }
            if (DEBUG) {
                Log.v(TAG, "  Enqueuing as new pending loader");
            }
            info.mPendingLoader = createLoader(id, args, callback);
            return info.mPendingLoader.mLoader;
        } else {
            if (DEBUG) {
                Log.v(TAG, "  Current loader is stopped; replacing");
            }
            this.mLoaders.put(id, null);
            info.destroy();
        }
    }
    return createAndInstallLoader(id, args, callback).mLoader;
}

protected LoaderCallbacks<List<Song>> getLoaderCallbacks() {
    return mLoaderCallbacks;
}

private LoaderCallbacks<List<Song>> getLoaderCallbacks() {
    return mLoaderCallbacks;
}

public static void init(LoaderManager manager, int loaderId,
                        LoaderCallbacks<Cursor> callbacks, String searchTerm) {
    init(manager, loaderId, callbacks, searchTerm, EnumSet.noneOf(FilterFlags.class));
}

public static void init(LoaderManager manager, int loaderId,
                        LoaderCallbacks<Cursor> callbacks, String searchTerm,
                        EnumSet<FilterFlags> flags) {
    final Bundle args = createArgs(searchTerm, flags);
    manager.initLoader(loaderId, args, callbacks);
}

public static void restart(LoaderManager manager, int loaderId,
                           LoaderCallbacks<Cursor> callbacks, String searchTerm) {
    restart(manager, loaderId, callbacks, searchTerm, EnumSet.noneOf(FilterFlags.class));
}

public static void restart(LoaderManager manager, int loaderId,
                           LoaderCallbacks<Cursor> callbacks, String searchTerm,
                           EnumSet<FilterFlags> flags) {
    final Bundle args = createArgs(searchTerm, flags);
    manager.restartLoader(loaderId, args, callbacks);
}

@Override
public void execute(final Query request, final QueryListener listener) {
    final LoaderCallbacks<?> callbacks = new QueryLoaderCallbacks(listener);
    execute(request, callbacks);
}

@Override
public void execute(final Update request, final UpdateListener listener) {
    final LoaderCallbacks<?> callbacks = new UpdateLoaderCallbacks(listener);
    execute(request, callbacks);
}

@Override
public void execute(final Insert request, final InsertListener listener) {
    final LoaderCallbacks<?> callbacks = new InsertLoaderCallbacks(listener);
    execute(request, callbacks);
}

@Override
public void execute(final Delete request, final DeleteListener listener) {
    final LoaderCallbacks<?> callbacks = new DeleteLoaderCallbacks(listener);
    execute(request, callbacks);
   }

@Override
public void execute(final Batch request, final BatchListener listener) {
    final LoaderCallbacks<?> callbacks = new BatchLoaderCallbacks(listener);
    execute(request, callbacks);
}

private void execute(final Request<?> request, final LoaderCallbacks<?> callbacks) {
    final int identifier = request.getIdentifier();
    final Bundle bundle = createRequestBundle(request);
    mLoaderManager.restartLoader(identifier, bundle, callbacks);
}

/**
 * @return the mSearResultFragmentLoaderCallbacks
 */
public LoaderManager.LoaderCallbacks<Cursor> getSearchResultFragmentLoaderCallbacks() {
    return mSearResultFragmentLoaderCallbacks;
}

/**
 * @param searResultFragmentLoaderCallbacks the searResultFragmentLoaderCallbacks to set
 */
public void setSearResultFragmentLoaderCallbacks(LoaderManager.LoaderCallbacks<Cursor> searResultFragmentLoaderCallbacks) {
    this.mSearResultFragmentLoaderCallbacks = searResultFragmentLoaderCallbacks;
}

FeedLoadable(LoaderManager loaderManager, int loaderId, LoaderCallbacks<Result<Feed>> callbacks) {
    super();
    this.mLoaderManager = Preconditions.checkNotNull(loaderManager);
    this.mLoaderId = loaderId;
    this.mCallbacks = callbacks;
}