/**@class android.app.FragmentController
@extends java.lang.Object

 Provides integration points with a {@link android.app.FragmentManager} for a fragment host.
 <p>
 It is the responsibility of the host to take care of the Fragment's lifecycle.
 The methods provided by {@link android.app.FragmentController} are for that purpose.

 @deprecated Use the <a href="{@docRoot}tools/extras/support-library.html">Support Library</a>
      {@link android.support.v4.app.FragmentController}
*/
var FragmentController = {

/**Returns a {@link android.app.FragmentController}.
*/
createController : function(  ) {},

/**Returns a {@link android.app.FragmentManager} for this controller.
*/
getFragmentManager : function(  ) {},

/**Returns a {@link android.app.LoaderManager}.
*/
getLoaderManager : function(  ) {},

/**Returns a fragment with the given identifier.
*/
findFragmentByWho : function(  ) {},

/**Attaches the host to the FragmentManager for this controller. The host must be
 attached before the FragmentManager can be used to manage Fragments.
*/
attachHost : function(  ) {},

/**Instantiates a Fragment's view.
@param {Object {View}} parent The parent that the created view will be placed
 in; <em>note that this may be null</em>.
@param {String} name Tag name to be inflated.
@param {Object {Context}} context The context the view is being created in.
@param {Object {AttributeSet}} attrs Inflation attributes as specified in XML file.
@return {Object {android.view.View}} view the newly created view
*/
onCreateView : function(  ) {},

/**Marks the fragment state as unsaved. This allows for "state loss" detection.
*/
noteStateNotSaved : function(  ) {},

/**Saves the state for all Fragments.
*/
saveAllState : function(  ) {},

/**Restores the saved state for all Fragments. The given Fragment list are Fragment
 instances retained across configuration changes.
@see #retainNonConfig()
@deprecated use {@link #restoreAllState(Parcelable, FragmentManagerNonConfig)}
*/
restoreAllState : function(  ) {},

/**Restores the saved state for all Fragments. The given FragmentManagerNonConfig are Fragment
 instances retained across configuration changes, including nested fragments
@see #retainNestedNonConfig()
*/
restoreAllState : function(  ) {},

/**Returns a list of Fragments that have opted to retain their instance across
 configuration changes.
@deprecated use {@link #retainNestedNonConfig()} to also track retained
             nested child fragments
*/
retainNonConfig : function(  ) {},

/**Returns a nested tree of Fragments that have opted to retain their instance across
 configuration changes.
*/
retainNestedNonConfig : function(  ) {},

/**Moves all Fragments managed by the controller's FragmentManager
 into the create state.
 <p>Call when Fragments should be created.
@see Fragment#onCreate(Bundle)
*/
dispatchCreate : function(  ) {},

/**Moves all Fragments managed by the controller's FragmentManager
 into the activity created state.
 <p>Call when Fragments should be informed their host has been created.
@see Fragment#onActivityCreated(Bundle)
*/
dispatchActivityCreated : function(  ) {},

/**Moves all Fragments managed by the controller's FragmentManager
 into the start state.
 <p>Call when Fragments should be started.
@see Fragment#onStart()
*/
dispatchStart : function(  ) {},

/**Moves all Fragments managed by the controller's FragmentManager
 into the resume state.
 <p>Call when Fragments should be resumed.
@see Fragment#onResume()
*/
dispatchResume : function(  ) {},

/**Moves all Fragments managed by the controller's FragmentManager
 into the pause state.
 <p>Call when Fragments should be paused.
@see Fragment#onPause()
*/
dispatchPause : function(  ) {},

/**Moves all Fragments managed by the controller's FragmentManager
 into the stop state.
 <p>Call when Fragments should be stopped.
@see Fragment#onStop()
*/
dispatchStop : function(  ) {},

/**Moves all Fragments managed by the controller's FragmentManager
 into the destroy view state.
 <p>Call when the Fragment's views should be destroyed.
@see Fragment#onDestroyView()
*/
dispatchDestroyView : function(  ) {},

/**Moves all Fragments managed by the controller's FragmentManager
 into the destroy state.
 <p>Call when Fragments should be destroyed.
@see Fragment#onDestroy()
*/
dispatchDestroy : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager know the multi-window mode of
 the activity changed.
 <p>Call when the multi-window mode of the activity changed.
@see Fragment#onMultiWindowModeChanged
@deprecated use {@link #dispatchMultiWindowModeChanged(boolean, Configuration)}
*/
dispatchMultiWindowModeChanged : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager know the multi-window mode of
 the activity changed.
 <p>Call when the multi-window mode of the activity changed.
@see Fragment#onMultiWindowModeChanged
*/
dispatchMultiWindowModeChanged : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager know the picture-in-picture
 mode of the activity changed.
 <p>Call when the picture-in-picture mode of the activity changed.
@see Fragment#onPictureInPictureModeChanged
@deprecated use {@link #dispatchPictureInPictureModeChanged(boolean, Configuration)}
*/
dispatchPictureInPictureModeChanged : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager know the picture-in-picture
 mode of the activity changed.
 <p>Call when the picture-in-picture mode of the activity changed.
@see Fragment#onPictureInPictureModeChanged
*/
dispatchPictureInPictureModeChanged : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager
 know a configuration change occurred.
 <p>Call when there is a configuration change.
@see Fragment#onConfigurationChanged(Configuration)
*/
dispatchConfigurationChanged : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager
 know the device is in a low memory condition.
 <p>Call when the device is low on memory and Fragment's should trim
 their memory usage.
@see Fragment#onLowMemory()
*/
dispatchLowMemory : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager
 know they should trim their memory usage.
 <p>Call when the Fragment can release allocated memory [such as if
 the Fragment is in the background].
@see Fragment#onTrimMemory(int)
*/
dispatchTrimMemory : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager
 know they should create an options menu.
 <p>Call when the Fragment should create an options menu.
@return {Boolean} {@code true} if the options menu contains items to display
@see Fragment#onCreateOptionsMenu(Menu, MenuInflater)
*/
dispatchCreateOptionsMenu : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager
 know they should prepare their options menu for display.
 <p>Call immediately before displaying the Fragment's options menu.
@return {Boolean} {@code true} if the options menu contains items to display
@see Fragment#onPrepareOptionsMenu(Menu)
*/
dispatchPrepareOptionsMenu : function(  ) {},

/**Sends an option item selection event to the Fragments managed by the
 controller's FragmentManager. Once the event has been consumed,
 no additional handling will be performed.
 <p>Call immediately after an options menu item has been selected
@return {Boolean} {@code true} if the options menu selection event was consumed
@see Fragment#onOptionsItemSelected(MenuItem)
*/
dispatchOptionsItemSelected : function(  ) {},

/**Sends a context item selection event to the Fragments managed by the
 controller's FragmentManager. Once the event has been consumed,
 no additional handling will be performed.
 <p>Call immediately after an options menu item has been selected
@return {Boolean} {@code true} if the context menu selection event was consumed
@see Fragment#onContextItemSelected(MenuItem)
*/
dispatchContextItemSelected : function(  ) {},

/**Lets all Fragments managed by the controller's FragmentManager
 know their options menu has closed.
 <p>Call immediately after closing the Fragment's options menu.
@see Fragment#onOptionsMenuClosed(Menu)
*/
dispatchOptionsMenuClosed : function(  ) {},

/**Execute any pending actions for the Fragments managed by the
 controller's FragmentManager.
 <p>Call when queued actions can be performed [eg when the
 Fragment moves into a start or resume state].
@return {Boolean} {@code true} if queued actions were performed
*/
execPendingActions : function(  ) {},

/**Starts the loaders.
*/
doLoaderStart : function(  ) {},

/**Stops the loaders, optionally retaining their state. This is useful for keeping the
 loader state across configuration changes.
@param {Boolean} retain When {@code true}, the loaders aren't stopped, but, their instances
 are retained in a started state
*/
doLoaderStop : function(  ) {},

/**Destroys the loaders and, if their state is not being retained, removes them.
*/
doLoaderDestroy : function(  ) {},

/**Lets the loaders know the host is ready to receive notifications.
*/
reportLoaderStart : function(  ) {},

/**Returns a list of LoaderManagers that have opted to retain their instance across
 configuration changes.
*/
retainLoaderNonConfig : function(  ) {},

/**Restores the saved state for all LoaderManagers. The given LoaderManager list are
 LoaderManager instances retained across configuration changes.
@see #retainLoaderNonConfig()
*/
restoreLoaderNonConfig : function(  ) {},

/**Dumps the current state of the loaders.
*/
dumpLoaders : function(  ) {},


};