ComponentCallbacks2

public interface ComponentCallbacks2
implements ComponentCallbacks

Known Indirect Subclasses AbstractInputMethodService, AccessibilityService, AccountAuthenticatorActivity, ActionBarActivity, Activity, ActivityGroup, AliasActivity, AppCompatActivity, Application, BaseLeanbackPreferenceFragment, BrandedFragment, BrowseFragment, CallScreeningService, and 70 others. AbstractInputMethodService AbstractInputMethodService provides a abstract base class for input methods.  AccessibilityService Accessibility services are intended to assist users with disabilities in using Android devices and apps.  AccountAuthenticatorActivity Base class for implementing an Activity that is used to help implement an AbstractAccountAuthenticator.  ActionBarActivity This class is deprecated. Use AppCompatActivity instead.   Activity An activity is a single, focused thing that the user can do.  ActivityGroup This class was deprecated in API level 13. Use the new Fragment and FragmentManager APIs instead; these are also available on older platforms through the Android compatibility package.   AliasActivity Stub activity that launches another activity (and then finishes itself) based on information in its component's manifest meta-data.  AppCompatActivity Base class for activities that use the support library action bar features.  Application Base class for maintaining global application state.  BaseLeanbackPreferenceFragment This fragment provides a preference fragment with leanback-style behavior, suitable for embedding into broader UI elements.  BrandedFragment Fragment class for managing search and branding using a view that implements TitleViewAdapter.Provider.  BrowseFragment A fragment for creating Leanback browse screens.  CallScreeningService This service can be implemented by the default dialer (see getDefaultDialerPackage()) to allow or disallow incoming calls before they are shown to a user.  CameraPrewarmService Extend this class to implement a camera prewarm service.  CarrierMessagingService A service that receives calls from the system when new SMS and MMS are sent or received.  CarrierService A service that exposes carrier-specific functionality to the system.  ChooserTargetService A service that receives calls from the system when the user is asked to choose a target for an intent explicitly by another app.  ConditionProviderService A service that provides conditions about boolean state.  ConnectionService An abstract service that should be implemented by any apps which can make phone calls (VoIP or otherwise) and want those calls to be integrated into the built-in phone app.  ContentProvider Content providers are one of the primary building blocks of Android applications, providing content to applications.  CustomTabsService Abstract service class for implementing Custom Tabs related functionality.  DetailsFragment A fragment for creating Leanback details screens.  DialogFragment A fragment that displays a dialog window, floating on top of its activity's window.  DocumentsProvider Base class for a document provider.  DreamService Extend this class to implement a custom dream (available to the user as a "Daydream").  EditTextPreferenceDialogFragment   ErrorFragment A fragment for displaying an error indication.  ExpandableListActivity An activity that displays an expandable list of items by binding to a data source implementing the ExpandableListAdapter, and exposes event handlers when the user selects an item.  FileProvider FileProvider is a special subclass of ContentProvider that facilitates secure sharing of files associated with an app by creating a content:// Uri for a file instead of a file:/// Uri.  Fragment A Fragment is a piece of an application's user interface or behavior that can be placed in an Activity.  FragmentActivity Base class for activities that want to use the support-based Fragment and Loader APIs.  GuidedStepFragment A GuidedStepFragment is used to guide the user through a decision or series of decisions.  HeadersFragment An internal fragment containing a list of row headers.  HostApduService HostApduService is a convenience Service class that can be extended to emulate an NFC card inside an Android service component.  HostNfcFService HostNfcFService is a convenience Service class that can be extended to emulate an NFC-F card inside an Android service component.  InCallService This service is implemented by any app that wishes to provide the user-interface for managing phone calls.  InputMethodService InputMethodService provides a standard implementation of an InputMethod, which final implementations can derive from and customize.  IntentService IntentService is a base class for Services that handle asynchronous requests (expressed as Intents) on demand.  JobService Entry point for the callback from the JobScheduler.  LauncherActivity Displays a list of all activities which can be performed for a given intent.  LeanbackListPreferenceDialogFragment   LeanbackPreferenceDialogFragment   LeanbackPreferenceFragment This fragment provides a fully decorated leanback-style preference fragment, including a list background and header.  LeanbackSettingsFragment   ListActivity An activity that displays a list of items by binding to a data source such as an array or Cursor, and exposes event handlers when the user selects an item.  ListFragment A fragment that displays a list of items by binding to a data source such as an array or Cursor, and exposes event handlers when the user selects an item.  ListPreferenceDialogFragment   MediaBrowserService Base class for media browse services.  MediaBrowserServiceCompat Base class for media browse services.  MediaRouteProviderService Base class for media route provider services.  MidiDeviceService A service that implements a virtual MIDI device.  MockApplication This class was deprecated in API level 24. Use a mocking framework like Mockito. New tests should be written using the Android Testing Support Library.   MockContentProvider Mock implementation of ContentProvider.  MultiDexApplication Minimal MultiDex capable application.  MultiSelectListPreferenceDialogFragment   NativeActivity Convenience for implementing an activity that will be implemented purely in native code.  NotificationCompatSideChannelService Abstract service to receive side channel notifications sent from NotificationManagerCompat.  NotificationListenerService A service that receives calls from the system when new notifications are posted or removed, or their ranking changed.  OffHostApduService OffHostApduService is a convenience Service class that can be extended to describe one or more NFC applications that are residing off-host, for example on an embedded secure element or a UICC.  OnboardingFragment An OnboardingFragment provides a common and simple way to build onboarding screen for applications.  PlaybackOverlayFragment A fragment for displaying playback controls and related content.  PreferenceActivity This is the base class for an activity to show a hierarchy of preferences to the user.  PreferenceDialogFragment Abstract base class which presents a dialog associated with a DialogPreference.  PreferenceFragment Shows a hierarchy of Preference objects as lists.  PrintService This is the base class for implementing print services.  RecognitionService This class provides a base class for recognition service implementations.  RemoteViewsService The service to be connected to for a remote adapter to request RemoteViews.  RowsFragment An ordered set of rows of leanback widgets.  SearchFragment A fragment to handle searches.  SearchRecentSuggestionsProvider This superclass can be used to create a simple search suggestions provider for your application.  Service A Service is an application component representing either an application's desire to perform a longer-running operation while not interacting with the user or to supply functionality for other applications to use.  SettingInjectorService Dynamically specifies the enabled status of a preference injected into the list of app settings displayed by the system settings app For use only by apps that are included in the system image, for preferences that affect multiple apps.  SpellCheckerService SpellCheckerService provides an abstract base class for a spell checker.  TabActivity This class was deprecated in API level 13. New applications should use Fragments instead of this class; to continue to run on older devices, you can use the v4 support library which provides a version of the Fragment API that is compatible down to DONUT.   TextToSpeechService Abstract base class for TTS engine implementations.  TileService A TileService provides the user a tile that can be added to Quick Settings.  TvInputService The TvInputService class represents a TV input or source such as HDMI or built-in tuner which provides pass-through video or broadcast TV programs.  VerticalGridFragment A fragment for creating leanback vertical grids.  VoiceInteractionService Top-level service of the current global voice interactor, which is providing support for hotwording, the back-end of a VoiceInteractor, etc.  VoiceInteractionSession An active voice interaction session, providing a facility for the implementation to interact with the user in the voice interaction layer.  VoiceInteractionSessionService An active voice interaction session, initiated by a VoiceInteractionService.  VpnService VpnService is a base class for applications to extend and build their own VPN solutions.  VrListenerService A service that is bound from the system while running in virtual reality (VR) mode.  WallpaperService A wallpaper service is responsible for showing a live wallpaper behind applications that would like to sit on top of it.  WebViewFragment A fragment that displays a WebView.

Extended ComponentCallbacks interface with a new callback for finer-grained memory management. This interface is available in all application components (Activity, Service, ContentProvider, and Application).

You should implement onTrimMemory(int) to incrementally release memory based on current system constraints. Using this callback to release your resources helps provide a more responsive system overall, but also directly benefits the user experience for your app by allowing the system to keep your process alive longer. That is, if you don't trim your resources based on memory levels defined by this callback, the system is more likely to kill your process while it is cached in the least-recently used (LRU) list, thus requiring your app to restart and restore all state when the user returns to it.

The values provided by onTrimMemory(int) do not represent a single linear progression of memory limits, but provide you different types of clues about memory availability:

• When your app is running:
  1. TRIM_MEMORY_RUNNING_MODERATE
     The device is beginning to run low on memory. Your app is running and not killable.
  2. TRIM_MEMORY_RUNNING_LOW
     The device is running much lower on memory. Your app is running and not killable, but please release unused resources to improve system performance (which directly impacts your app's performance).
  3. TRIM_MEMORY_RUNNING_CRITICAL
     The device is running extremely low on memory. Your app is not yet considered a killable process, but the system will begin killing background processes if apps do not release resources, so you should release non-critical resources now to prevent performance degradation.
• When your app's visibility changes:
  1. TRIM_MEMORY_UI_HIDDEN
     Your app's UI is no longer visible, so this is a good time to release large resources that are used only by your UI.
• When your app's process resides in the background LRU list:
  1. TRIM_MEMORY_BACKGROUND
     The system is running low on memory and your process is near the beginning of the LRU list. Although your app process is not at a high risk of being killed, the system may already be killing processes in the LRU list, so you should release resources that are easy to recover so your process will remain in the list and resume quickly when the user returns to your app.
  2. TRIM_MEMORY_MODERATE
     The system is running low on memory and your process is near the middle of the LRU list. If the system becomes further constrained for memory, there's a chance your process will be killed.
  3. TRIM_MEMORY_COMPLETE
     The system is running low on memory and your process is one of the first to be killed if the system does not recover memory now. You should release absolutely everything that's not critical to resuming your app state.

     To support API levels lower than 14, you can use the onLowMemory() method as a fallback that's roughly equivalent to the TRIM_MEMORY_COMPLETE level.

  Note: When the system begins killing processes in the LRU list, although it primarily works bottom-up, it does give some consideration to which processes are consuming more memory and will thus provide more gains in memory if killed. So the less memory you consume while in the LRU list overall, the better your chances are to remain in the list and be able to quickly resume.

More information about the different stages of a process lifecycle (such as what it means to be placed in the background LRU list) is provided in the Processes and Threads document.

Summary

Inherited methods
From interface android.content.ComponentCallbacks abstract void onConfigurationChanged(Configuration newConfig) Called by the system when the device configuration changes while your component is running. abstract void onLowMemory() This is called when the overall system is running low on memory, and actively running processes should trim their memory usage.

Constants

int TRIM_MEMORY_BACKGROUND

int TRIM_MEMORY_COMPLETE

int TRIM_MEMORY_MODERATE

int TRIM_MEMORY_RUNNING_CRITICAL

int TRIM_MEMORY_RUNNING_LOW

int TRIM_MEMORY_RUNNING_MODERATE

int TRIM_MEMORY_UI_HIDDEN

Public methods

void onTrimMemory (int level)