1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package android.app; 18 19import android.content.Loader; 20import android.os.Bundle; 21import android.util.DebugUtils; 22import android.util.Log; 23import android.util.SparseArray; 24 25import java.io.FileDescriptor; 26import java.io.PrintWriter; 27import java.lang.reflect.Modifier; 28 29/** 30 * Interface associated with an {@link Activity} or {@link Fragment} for managing 31 * one or more {@link android.content.Loader} instances associated with it. This 32 * helps an application manage longer-running operations in conjunction with the 33 * Activity or Fragment lifecycle; the most common use of this is with a 34 * {@link android.content.CursorLoader}, however applications are free to write 35 * their own loaders for loading other types of data. 36 * 37 * While the LoaderManager API was introduced in 38 * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, a version of the API 39 * at is also available for use on older platforms through 40 * {@link android.support.v4.app.FragmentActivity}. See the blog post 41 * <a href="http://android-developers.blogspot.com/2011/03/fragments-for-all.html"> 42 * Fragments For All</a> for more details. 43 * 44 * <p>As an example, here is the full implementation of a {@link Fragment} 45 * that displays a {@link android.widget.ListView} containing the results of 46 * a query against the contacts content provider. It uses a 47 * {@link android.content.CursorLoader} to manage the query on the provider. 48 * 49 * {@sample development/samples/ApiDemos/src/com/example/android/apis/app/LoaderCursor.java 50 * fragment_cursor} 51 * 52 * <div class="special reference"> 53 * <h3>Developer Guides</h3> 54 * <p>For more information about using loaders, read the 55 * <a href="{@docRoot}guide/topics/fundamentals/loaders.html">Loaders</a> developer guide.</p> 56 * </div> 57 */ 58public abstract class LoaderManager { 59 /** 60 * Callback interface for a client to interact with the manager. 61 */ 62 public interface LoaderCallbacks<D> { 63 /** 64 * Instantiate and return a new Loader for the given ID. 65 * 66 * @param id The ID whose loader is to be created. 67 * @param args Any arguments supplied by the caller. 68 * @return Return a new Loader instance that is ready to start loading. 69 */ 70 public Loader<D> onCreateLoader(int id, Bundle args); 71 72 /** 73 * Called when a previously created loader has finished its load. Note 74 * that normally an application is <em>not</em> allowed to commit fragment 75 * transactions while in this call, since it can happen after an 76 * activity's state is saved. See {@link FragmentManager#beginTransaction() 77 * FragmentManager.openTransaction()} for further discussion on this. 78 * 79 * <p>This function is guaranteed to be called prior to the release of 80 * the last data that was supplied for this Loader. At this point 81 * you should remove all use of the old data (since it will be released 82 * soon), but should not do your own release of the data since its Loader 83 * owns it and will take care of that. The Loader will take care of 84 * management of its data so you don't have to. In particular: 85 * 86 * <ul> 87 * <li> <p>The Loader will monitor for changes to the data, and report 88 * them to you through new calls here. You should not monitor the 89 * data yourself. For example, if the data is a {@link android.database.Cursor} 90 * and you place it in a {@link android.widget.CursorAdapter}, use 91 * the {@link android.widget.CursorAdapter#CursorAdapter(android.content.Context, 92 * android.database.Cursor, int)} constructor <em>without</em> passing 93 * in either {@link android.widget.CursorAdapter#FLAG_AUTO_REQUERY} 94 * or {@link android.widget.CursorAdapter#FLAG_REGISTER_CONTENT_OBSERVER} 95 * (that is, use 0 for the flags argument). This prevents the CursorAdapter 96 * from doing its own observing of the Cursor, which is not needed since 97 * when a change happens you will get a new Cursor throw another call 98 * here. 99 * <li> The Loader will release the data once it knows the application 100 * is no longer using it. For example, if the data is 101 * a {@link android.database.Cursor} from a {@link android.content.CursorLoader}, 102 * you should not call close() on it yourself. If the Cursor is being placed in a 103 * {@link android.widget.CursorAdapter}, you should use the 104 * {@link android.widget.CursorAdapter#swapCursor(android.database.Cursor)} 105 * method so that the old Cursor is not closed. 106 * </ul> 107 * 108 * @param loader The Loader that has finished. 109 * @param data The data generated by the Loader. 110 */ 111 public void onLoadFinished(Loader<D> loader, D data); 112 113 /** 114 * Called when a previously created loader is being reset, and thus 115 * making its data unavailable. The application should at this point 116 * remove any references it has to the Loader's data. 117 * 118 * @param loader The Loader that is being reset. 119 */ 120 public void onLoaderReset(Loader<D> loader); 121 } 122 123 /** 124 * Ensures a loader is initialized and active. If the loader doesn't 125 * already exist, one is created and (if the activity/fragment is currently 126 * started) starts the loader. Otherwise the last created 127 * loader is re-used. 128 * 129 * <p>In either case, the given callback is associated with the loader, and 130 * will be called as the loader state changes. If at the point of call 131 * the caller is in its started state, and the requested loader 132 * already exists and has generated its data, then 133 * callback {@link LoaderCallbacks#onLoadFinished} will 134 * be called immediately (inside of this function), so you must be prepared 135 * for this to happen. 136 * 137 * @param id A unique identifier for this loader. Can be whatever you want. 138 * Identifiers are scoped to a particular LoaderManager instance. 139 * @param args Optional arguments to supply to the loader at construction. 140 * If a loader already exists (a new one does not need to be created), this 141 * parameter will be ignored and the last arguments continue to be used. 142 * @param callback Interface the LoaderManager will call to report about 143 * changes in the state of the loader. Required. 144 */ 145 public abstract <D> Loader<D> initLoader(int id, Bundle args, 146 LoaderManager.LoaderCallbacks<D> callback); 147 148 /** 149 * Starts a new or restarts an existing {@link android.content.Loader} in 150 * this manager, registers the callbacks to it, 151 * and (if the activity/fragment is currently started) starts loading it. 152 * If a loader with the same id has previously been 153 * started it will automatically be destroyed when the new loader completes 154 * its work. The callback will be delivered before the old loader 155 * is destroyed. 156 * 157 * @param id A unique identifier for this loader. Can be whatever you want. 158 * Identifiers are scoped to a particular LoaderManager instance. 159 * @param args Optional arguments to supply to the loader at construction. 160 * @param callback Interface the LoaderManager will call to report about 161 * changes in the state of the loader. Required. 162 */ 163 public abstract <D> Loader<D> restartLoader(int id, Bundle args, 164 LoaderManager.LoaderCallbacks<D> callback); 165 166 /** 167 * Stops and removes the loader with the given ID. If this loader 168 * had previously reported data to the client through 169 * {@link LoaderCallbacks#onLoadFinished(Loader, Object)}, a call 170 * will be made to {@link LoaderCallbacks#onLoaderReset(Loader)}. 171 */ 172 public abstract void destroyLoader(int id); 173 174 /** 175 * Return the Loader with the given id or null if no matching Loader 176 * is found. 177 */ 178 public abstract <D> Loader<D> getLoader(int id); 179 180 /** 181 * Print the LoaderManager's state into the given stream. 182 * 183 * @param prefix Text to print at the front of each line. 184 * @param fd The raw file descriptor that the dump is being sent to. 185 * @param writer A PrintWriter to which the dump is to be set. 186 * @param args Additional arguments to the dump request. 187 */ 188 public abstract void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args); 189 190 /** 191 * Control whether the framework's internal loader manager debugging 192 * logs are turned on. If enabled, you will see output in logcat as 193 * the framework performs loader operations. 194 */ 195 public static void enableDebugLogging(boolean enabled) { 196 LoaderManagerImpl.DEBUG = enabled; 197 } 198} 199 200class LoaderManagerImpl extends LoaderManager { 201 static final String TAG = "LoaderManager"; 202 static boolean DEBUG = false; 203 204 // These are the currently active loaders. A loader is here 205 // from the time its load is started until it has been explicitly 206 // stopped or restarted by the application. 207 final SparseArray<LoaderInfo> mLoaders = new SparseArray<LoaderInfo>(); 208 209 // These are previously run loaders. This list is maintained internally 210 // to avoid destroying a loader while an application is still using it. 211 // It allows an application to restart a loader, but continue using its 212 // previously run loader until the new loader's data is available. 213 final SparseArray<LoaderInfo> mInactiveLoaders = new SparseArray<LoaderInfo>(); 214 215 Activity mActivity; 216 boolean mStarted; 217 boolean mRetaining; 218 boolean mRetainingStarted; 219 220 boolean mCreatingLoader; 221 222 final class LoaderInfo implements Loader.OnLoadCompleteListener<Object> { 223 final int mId; 224 final Bundle mArgs; 225 LoaderManager.LoaderCallbacks<Object> mCallbacks; 226 Loader<Object> mLoader; 227 boolean mHaveData; 228 boolean mDeliveredData; 229 Object mData; 230 boolean mStarted; 231 boolean mRetaining; 232 boolean mRetainingStarted; 233 boolean mReportNextStart; 234 boolean mDestroyed; 235 boolean mListenerRegistered; 236 237 LoaderInfo mPendingLoader; 238 239 public LoaderInfo(int id, Bundle args, LoaderManager.LoaderCallbacks<Object> callbacks) { 240 mId = id; 241 mArgs = args; 242 mCallbacks = callbacks; 243 } 244 245 void start() { 246 if (mRetaining && mRetainingStarted) { 247 // Our owner is started, but we were being retained from a 248 // previous instance in the started state... so there is really 249 // nothing to do here, since the loaders are still started. 250 mStarted = true; 251 return; 252 } 253 254 if (mStarted) { 255 // If loader already started, don't restart. 256 return; 257 } 258 259 mStarted = true; 260 261 if (DEBUG) Log.v(TAG, " Starting: " + this); 262 if (mLoader == null && mCallbacks != null) { 263 mLoader = mCallbacks.onCreateLoader(mId, mArgs); 264 } 265 if (mLoader != null) { 266 if (mLoader.getClass().isMemberClass() 267 && !Modifier.isStatic(mLoader.getClass().getModifiers())) { 268 throw new IllegalArgumentException( 269 "Object returned from onCreateLoader must not be a non-static inner member class: " 270 + mLoader); 271 } 272 if (!mListenerRegistered) { 273 mLoader.registerListener(mId, this); 274 mListenerRegistered = true; 275 } 276 mLoader.startLoading(); 277 } 278 } 279 280 void retain() { 281 if (DEBUG) Log.v(TAG, " Retaining: " + this); 282 mRetaining = true; 283 mRetainingStarted = mStarted; 284 mStarted = false; 285 mCallbacks = null; 286 } 287 288 void finishRetain() { 289 if (mRetaining) { 290 if (DEBUG) Log.v(TAG, " Finished Retaining: " + this); 291 mRetaining = false; 292 if (mStarted != mRetainingStarted) { 293 if (!mStarted) { 294 // This loader was retained in a started state, but 295 // at the end of retaining everything our owner is 296 // no longer started... so make it stop. 297 stop(); 298 } 299 } 300 } 301 302 if (mStarted && mHaveData && !mReportNextStart) { 303 // This loader has retained its data, either completely across 304 // a configuration change or just whatever the last data set 305 // was after being restarted from a stop, and now at the point of 306 // finishing the retain we find we remain started, have 307 // our data, and the owner has a new callback... so 308 // let's deliver the data now. 309 callOnLoadFinished(mLoader, mData); 310 } 311 } 312 313 void reportStart() { 314 if (mStarted) { 315 if (mReportNextStart) { 316 mReportNextStart = false; 317 if (mHaveData) { 318 callOnLoadFinished(mLoader, mData); 319 } 320 } 321 } 322 } 323 324 void stop() { 325 if (DEBUG) Log.v(TAG, " Stopping: " + this); 326 mStarted = false; 327 if (!mRetaining) { 328 if (mLoader != null && mListenerRegistered) { 329 // Let the loader know we're done with it 330 mListenerRegistered = false; 331 mLoader.unregisterListener(this); 332 mLoader.stopLoading(); 333 } 334 } 335 } 336 337 void destroy() { 338 if (DEBUG) Log.v(TAG, " Destroying: " + this); 339 mDestroyed = true; 340 boolean needReset = mDeliveredData; 341 mDeliveredData = false; 342 if (mCallbacks != null && mLoader != null && mHaveData && needReset) { 343 if (DEBUG) Log.v(TAG, " Reseting: " + this); 344 String lastBecause = null; 345 if (mActivity != null) { 346 lastBecause = mActivity.mFragments.mNoTransactionsBecause; 347 mActivity.mFragments.mNoTransactionsBecause = "onLoaderReset"; 348 } 349 try { 350 mCallbacks.onLoaderReset(mLoader); 351 } finally { 352 if (mActivity != null) { 353 mActivity.mFragments.mNoTransactionsBecause = lastBecause; 354 } 355 } 356 } 357 mCallbacks = null; 358 mData = null; 359 mHaveData = false; 360 if (mLoader != null) { 361 if (mListenerRegistered) { 362 mListenerRegistered = false; 363 mLoader.unregisterListener(this); 364 } 365 mLoader.reset(); 366 } 367 if (mPendingLoader != null) { 368 mPendingLoader.destroy(); 369 } 370 } 371 372 @Override public void onLoadComplete(Loader<Object> loader, Object data) { 373 if (DEBUG) Log.v(TAG, "onLoadComplete: " + this); 374 375 if (mDestroyed) { 376 if (DEBUG) Log.v(TAG, " Ignoring load complete -- destroyed"); 377 return; 378 } 379 380 if (mLoaders.get(mId) != this) { 381 // This data is not coming from the current active loader. 382 // We don't care about it. 383 if (DEBUG) Log.v(TAG, " Ignoring load complete -- not active"); 384 return; 385 } 386 387 LoaderInfo pending = mPendingLoader; 388 if (pending != null) { 389 // There is a new request pending and we were just 390 // waiting for the old one to complete before starting 391 // it. So now it is time, switch over to the new loader. 392 if (DEBUG) Log.v(TAG, " Switching to pending loader: " + pending); 393 mPendingLoader = null; 394 mLoaders.put(mId, null); 395 destroy(); 396 installLoader(pending); 397 return; 398 } 399 400 // Notify of the new data so the app can switch out the old data before 401 // we try to destroy it. 402 if (mData != data || !mHaveData) { 403 mData = data; 404 mHaveData = true; 405 if (mStarted) { 406 callOnLoadFinished(loader, data); 407 } 408 } 409 410 //if (DEBUG) Log.v(TAG, " onLoadFinished returned: " + this); 411 412 // We have now given the application the new loader with its 413 // loaded data, so it should have stopped using the previous 414 // loader. If there is a previous loader on the inactive list, 415 // clean it up. 416 LoaderInfo info = mInactiveLoaders.get(mId); 417 if (info != null && info != this) { 418 info.mDeliveredData = false; 419 info.destroy(); 420 mInactiveLoaders.remove(mId); 421 } 422 423 if (mActivity != null && !hasRunningLoaders()) { 424 mActivity.mFragments.startPendingDeferredFragments(); 425 } 426 } 427 428 void callOnLoadFinished(Loader<Object> loader, Object data) { 429 if (mCallbacks != null) { 430 String lastBecause = null; 431 if (mActivity != null) { 432 lastBecause = mActivity.mFragments.mNoTransactionsBecause; 433 mActivity.mFragments.mNoTransactionsBecause = "onLoadFinished"; 434 } 435 try { 436 if (DEBUG) Log.v(TAG, " onLoadFinished in " + loader + ": " 437 + loader.dataToString(data)); 438 mCallbacks.onLoadFinished(loader, data); 439 } finally { 440 if (mActivity != null) { 441 mActivity.mFragments.mNoTransactionsBecause = lastBecause; 442 } 443 } 444 mDeliveredData = true; 445 } 446 } 447 448 @Override 449 public String toString() { 450 StringBuilder sb = new StringBuilder(64); 451 sb.append("LoaderInfo{"); 452 sb.append(Integer.toHexString(System.identityHashCode(this))); 453 sb.append(" #"); 454 sb.append(mId); 455 sb.append(" : "); 456 DebugUtils.buildShortClassTag(mLoader, sb); 457 sb.append("}}"); 458 return sb.toString(); 459 } 460 461 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) { 462 writer.print(prefix); writer.print("mId="); writer.print(mId); 463 writer.print(" mArgs="); writer.println(mArgs); 464 writer.print(prefix); writer.print("mCallbacks="); writer.println(mCallbacks); 465 writer.print(prefix); writer.print("mLoader="); writer.println(mLoader); 466 if (mLoader != null) { 467 mLoader.dump(prefix + " ", fd, writer, args); 468 } 469 if (mHaveData || mDeliveredData) { 470 writer.print(prefix); writer.print("mHaveData="); writer.print(mHaveData); 471 writer.print(" mDeliveredData="); writer.println(mDeliveredData); 472 writer.print(prefix); writer.print("mData="); writer.println(mData); 473 } 474 writer.print(prefix); writer.print("mStarted="); writer.print(mStarted); 475 writer.print(" mReportNextStart="); writer.print(mReportNextStart); 476 writer.print(" mDestroyed="); writer.println(mDestroyed); 477 writer.print(prefix); writer.print("mRetaining="); writer.print(mRetaining); 478 writer.print(" mRetainingStarted="); writer.print(mRetainingStarted); 479 writer.print(" mListenerRegistered="); writer.println(mListenerRegistered); 480 if (mPendingLoader != null) { 481 writer.print(prefix); writer.println("Pending Loader "); 482 writer.print(mPendingLoader); writer.println(":"); 483 mPendingLoader.dump(prefix + " ", fd, writer, args); 484 } 485 } 486 } 487 488 LoaderManagerImpl(Activity activity, boolean started) { 489 mActivity = activity; 490 mStarted = started; 491 } 492 493 void updateActivity(Activity activity) { 494 mActivity = activity; 495 } 496 497 private LoaderInfo createLoader(int id, Bundle args, 498 LoaderManager.LoaderCallbacks<Object> callback) { 499 LoaderInfo info = new LoaderInfo(id, args, (LoaderManager.LoaderCallbacks<Object>)callback); 500 Loader<Object> loader = callback.onCreateLoader(id, args); 501 info.mLoader = (Loader<Object>)loader; 502 return info; 503 } 504 505 private LoaderInfo createAndInstallLoader(int id, Bundle args, 506 LoaderManager.LoaderCallbacks<Object> callback) { 507 try { 508 mCreatingLoader = true; 509 LoaderInfo info = createLoader(id, args, callback); 510 installLoader(info); 511 return info; 512 } finally { 513 mCreatingLoader = false; 514 } 515 } 516 517 void installLoader(LoaderInfo info) { 518 mLoaders.put(info.mId, info); 519 if (mStarted) { 520 // The activity will start all existing loaders in it's onStart(), 521 // so only start them here if we're past that point of the activitiy's 522 // life cycle 523 info.start(); 524 } 525 } 526 527 /** 528 * Call to initialize a particular ID with a Loader. If this ID already 529 * has a Loader associated with it, it is left unchanged and any previous 530 * callbacks replaced with the newly provided ones. If there is not currently 531 * a Loader for the ID, a new one is created and started. 532 * 533 * <p>This function should generally be used when a component is initializing, 534 * to ensure that a Loader it relies on is created. This allows it to re-use 535 * an existing Loader's data if there already is one, so that for example 536 * when an {@link Activity} is re-created after a configuration change it 537 * does not need to re-create its loaders. 538 * 539 * <p>Note that in the case where an existing Loader is re-used, the 540 * <var>args</var> given here <em>will be ignored</em> because you will 541 * continue using the previous Loader. 542 * 543 * @param id A unique (to this LoaderManager instance) identifier under 544 * which to manage the new Loader. 545 * @param args Optional arguments that will be propagated to 546 * {@link LoaderCallbacks#onCreateLoader(int, Bundle) LoaderCallbacks.onCreateLoader()}. 547 * @param callback Interface implementing management of this Loader. Required. 548 * Its onCreateLoader() method will be called while inside of the function to 549 * instantiate the Loader object. 550 */ 551 @SuppressWarnings("unchecked") 552 public <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) { 553 if (mCreatingLoader) { 554 throw new IllegalStateException("Called while creating a loader"); 555 } 556 557 LoaderInfo info = mLoaders.get(id); 558 559 if (DEBUG) Log.v(TAG, "initLoader in " + this + ": args=" + args); 560 561 if (info == null) { 562 // Loader doesn't already exist; create. 563 info = createAndInstallLoader(id, args, (LoaderManager.LoaderCallbacks<Object>)callback); 564 if (DEBUG) Log.v(TAG, " Created new loader " + info); 565 } else { 566 if (DEBUG) Log.v(TAG, " Re-using existing loader " + info); 567 info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback; 568 } 569 570 if (info.mHaveData && mStarted) { 571 // If the loader has already generated its data, report it now. 572 info.callOnLoadFinished(info.mLoader, info.mData); 573 } 574 575 return (Loader<D>)info.mLoader; 576 } 577 578 /** 579 * Call to re-create the Loader associated with a particular ID. If there 580 * is currently a Loader associated with this ID, it will be 581 * canceled/stopped/destroyed as appropriate. A new Loader with the given 582 * arguments will be created and its data delivered to you once available. 583 * 584 * <p>This function does some throttling of Loaders. If too many Loaders 585 * have been created for the given ID but not yet generated their data, 586 * new calls to this function will create and return a new Loader but not 587 * actually start it until some previous loaders have completed. 588 * 589 * <p>After calling this function, any previous Loaders associated with 590 * this ID will be considered invalid, and you will receive no further 591 * data updates from them. 592 * 593 * @param id A unique (to this LoaderManager instance) identifier under 594 * which to manage the new Loader. 595 * @param args Optional arguments that will be propagated to 596 * {@link LoaderCallbacks#onCreateLoader(int, Bundle) LoaderCallbacks.onCreateLoader()}. 597 * @param callback Interface implementing management of this Loader. Required. 598 * Its onCreateLoader() method will be called while inside of the function to 599 * instantiate the Loader object. 600 */ 601 @SuppressWarnings("unchecked") 602 public <D> Loader<D> restartLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) { 603 if (mCreatingLoader) { 604 throw new IllegalStateException("Called while creating a loader"); 605 } 606 607 LoaderInfo info = mLoaders.get(id); 608 if (DEBUG) Log.v(TAG, "restartLoader in " + this + ": args=" + args); 609 if (info != null) { 610 LoaderInfo inactive = mInactiveLoaders.get(id); 611 if (inactive != null) { 612 if (info.mHaveData) { 613 // This loader now has data... we are probably being 614 // called from within onLoadComplete, where we haven't 615 // yet destroyed the last inactive loader. So just do 616 // that now. 617 if (DEBUG) Log.v(TAG, " Removing last inactive loader: " + info); 618 inactive.mDeliveredData = false; 619 inactive.destroy(); 620 info.mLoader.abandon(); 621 mInactiveLoaders.put(id, info); 622 } else { 623 // We already have an inactive loader for this ID that we are 624 // waiting for! What to do, what to do... 625 if (!info.mStarted) { 626 // The current Loader has not been started... we thus 627 // have no reason to keep it around, so bam, slam, 628 // thank-you-ma'am. 629 if (DEBUG) Log.v(TAG, " Current loader is stopped; replacing"); 630 mLoaders.put(id, null); 631 info.destroy(); 632 } else { 633 // Now we have three active loaders... we'll queue 634 // up this request to be processed once one of the other loaders 635 // finishes. 636 if (info.mPendingLoader != null) { 637 if (DEBUG) Log.v(TAG, " Removing pending loader: " + info.mPendingLoader); 638 info.mPendingLoader.destroy(); 639 info.mPendingLoader = null; 640 } 641 if (DEBUG) Log.v(TAG, " Enqueuing as new pending loader"); 642 info.mPendingLoader = createLoader(id, args, 643 (LoaderManager.LoaderCallbacks<Object>)callback); 644 return (Loader<D>)info.mPendingLoader.mLoader; 645 } 646 } 647 } else { 648 // Keep track of the previous instance of this loader so we can destroy 649 // it when the new one completes. 650 if (DEBUG) Log.v(TAG, " Making last loader inactive: " + info); 651 info.mLoader.abandon(); 652 mInactiveLoaders.put(id, info); 653 } 654 } 655 656 info = createAndInstallLoader(id, args, (LoaderManager.LoaderCallbacks<Object>)callback); 657 return (Loader<D>)info.mLoader; 658 } 659 660 /** 661 * Rip down, tear apart, shred to pieces a current Loader ID. After returning 662 * from this function, any Loader objects associated with this ID are 663 * destroyed. Any data associated with them is destroyed. You better not 664 * be using it when you do this. 665 * @param id Identifier of the Loader to be destroyed. 666 */ 667 public void destroyLoader(int id) { 668 if (mCreatingLoader) { 669 throw new IllegalStateException("Called while creating a loader"); 670 } 671 672 if (DEBUG) Log.v(TAG, "destroyLoader in " + this + " of " + id); 673 int idx = mLoaders.indexOfKey(id); 674 if (idx >= 0) { 675 LoaderInfo info = mLoaders.valueAt(idx); 676 mLoaders.removeAt(idx); 677 info.destroy(); 678 } 679 idx = mInactiveLoaders.indexOfKey(id); 680 if (idx >= 0) { 681 LoaderInfo info = mInactiveLoaders.valueAt(idx); 682 mInactiveLoaders.removeAt(idx); 683 info.destroy(); 684 } 685 if (mActivity != null && !hasRunningLoaders()) { 686 mActivity.mFragments.startPendingDeferredFragments(); 687 } 688 } 689 690 /** 691 * Return the most recent Loader object associated with the 692 * given ID. 693 */ 694 @SuppressWarnings("unchecked") 695 public <D> Loader<D> getLoader(int id) { 696 if (mCreatingLoader) { 697 throw new IllegalStateException("Called while creating a loader"); 698 } 699 700 LoaderInfo loaderInfo = mLoaders.get(id); 701 if (loaderInfo != null) { 702 if (loaderInfo.mPendingLoader != null) { 703 return (Loader<D>)loaderInfo.mPendingLoader.mLoader; 704 } 705 return (Loader<D>)loaderInfo.mLoader; 706 } 707 return null; 708 } 709 710 void doStart() { 711 if (DEBUG) Log.v(TAG, "Starting in " + this); 712 if (mStarted) { 713 RuntimeException e = new RuntimeException("here"); 714 e.fillInStackTrace(); 715 Log.w(TAG, "Called doStart when already started: " + this, e); 716 return; 717 } 718 719 mStarted = true; 720 721 // Call out to sub classes so they can start their loaders 722 // Let the existing loaders know that we want to be notified when a load is complete 723 for (int i = mLoaders.size()-1; i >= 0; i--) { 724 mLoaders.valueAt(i).start(); 725 } 726 } 727 728 void doStop() { 729 if (DEBUG) Log.v(TAG, "Stopping in " + this); 730 if (!mStarted) { 731 RuntimeException e = new RuntimeException("here"); 732 e.fillInStackTrace(); 733 Log.w(TAG, "Called doStop when not started: " + this, e); 734 return; 735 } 736 737 for (int i = mLoaders.size()-1; i >= 0; i--) { 738 mLoaders.valueAt(i).stop(); 739 } 740 mStarted = false; 741 } 742 743 void doRetain() { 744 if (DEBUG) Log.v(TAG, "Retaining in " + this); 745 if (!mStarted) { 746 RuntimeException e = new RuntimeException("here"); 747 e.fillInStackTrace(); 748 Log.w(TAG, "Called doRetain when not started: " + this, e); 749 return; 750 } 751 752 mRetaining = true; 753 mStarted = false; 754 for (int i = mLoaders.size()-1; i >= 0; i--) { 755 mLoaders.valueAt(i).retain(); 756 } 757 } 758 759 void finishRetain() { 760 if (mRetaining) { 761 if (DEBUG) Log.v(TAG, "Finished Retaining in " + this); 762 763 mRetaining = false; 764 for (int i = mLoaders.size()-1; i >= 0; i--) { 765 mLoaders.valueAt(i).finishRetain(); 766 } 767 } 768 } 769 770 void doReportNextStart() { 771 for (int i = mLoaders.size()-1; i >= 0; i--) { 772 mLoaders.valueAt(i).mReportNextStart = true; 773 } 774 } 775 776 void doReportStart() { 777 for (int i = mLoaders.size()-1; i >= 0; i--) { 778 mLoaders.valueAt(i).reportStart(); 779 } 780 } 781 782 void doDestroy() { 783 if (!mRetaining) { 784 if (DEBUG) Log.v(TAG, "Destroying Active in " + this); 785 for (int i = mLoaders.size()-1; i >= 0; i--) { 786 mLoaders.valueAt(i).destroy(); 787 } 788 } 789 790 if (DEBUG) Log.v(TAG, "Destroying Inactive in " + this); 791 for (int i = mInactiveLoaders.size()-1; i >= 0; i--) { 792 mInactiveLoaders.valueAt(i).destroy(); 793 } 794 mInactiveLoaders.clear(); 795 } 796 797 @Override 798 public String toString() { 799 StringBuilder sb = new StringBuilder(128); 800 sb.append("LoaderManager{"); 801 sb.append(Integer.toHexString(System.identityHashCode(this))); 802 sb.append(" in "); 803 DebugUtils.buildShortClassTag(mActivity, sb); 804 sb.append("}}"); 805 return sb.toString(); 806 } 807 808 @Override 809 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) { 810 if (mLoaders.size() > 0) { 811 writer.print(prefix); writer.println("Active Loaders:"); 812 String innerPrefix = prefix + " "; 813 for (int i=0; i < mLoaders.size(); i++) { 814 LoaderInfo li = mLoaders.valueAt(i); 815 writer.print(prefix); writer.print(" #"); writer.print(mLoaders.keyAt(i)); 816 writer.print(": "); writer.println(li.toString()); 817 li.dump(innerPrefix, fd, writer, args); 818 } 819 } 820 if (mInactiveLoaders.size() > 0) { 821 writer.print(prefix); writer.println("Inactive Loaders:"); 822 String innerPrefix = prefix + " "; 823 for (int i=0; i < mInactiveLoaders.size(); i++) { 824 LoaderInfo li = mInactiveLoaders.valueAt(i); 825 writer.print(prefix); writer.print(" #"); writer.print(mInactiveLoaders.keyAt(i)); 826 writer.print(": "); writer.println(li.toString()); 827 li.dump(innerPrefix, fd, writer, args); 828 } 829 } 830 } 831 832 public boolean hasRunningLoaders() { 833 boolean loadersRunning = false; 834 final int count = mLoaders.size(); 835 for (int i = 0; i < count; i++) { 836 final LoaderInfo li = mLoaders.valueAt(i); 837 loadersRunning |= li.mStarted && !li.mDeliveredData; 838 } 839 return loadersRunning; 840 } 841} 842