Application (libGDX Core 1.9.13 API)

```
public interface Application
```
An Application is the main entry point of your project. It sets up a window and rendering surface and manages the different aspects of your application, namely Graphics, Audio, Input and Files. Think of an Application being equivalent to Swing's JFrame or Android's Activity.

An application can be an instance of any of the following:
- a desktop application (see JglfwApplication found in gdx-backends-jglfw.jar)
- an Android application (see AndroidApplication found in gdx-backends-android.jar)
- a HTML5 application (see GwtApplication found in gdx-backends-gwt.jar)
- an iOS application (see IOSApplication found in gdx-backends-robovm.jar)
Each application class has it's own startup and initialization methods. Please refer to their documentation for more information.

While game programmers are used to having a main loop, libgdx employs a different concept to accommodate the event based nature of Android applications a little more. You application logic must be implemented in a ApplicationListener which has methods that get called by the Application when the application is created, resumed, paused, disposed or rendered. As a developer you will simply implement the ApplicationListener interface and fill in the functionality accordingly. The ApplicationListener is provided to a concrete Application instance as a parameter to the constructor or another initialization method. Please refer to the documentation of the Application implementations for more information. Note that the ApplicationListener can be provided to any Application implementation. This means that you only need to write your program logic once and have it run on different platforms by passing it to a concrete Application implementation.

The Application interface provides you with a set of modules for graphics, audio, input and file i/o.

Graphics offers you various methods to output visuals to the screen. This is achieved via OpenGL ES 2.0 or 3.0 depending on what's available an the platform. On the desktop the features of OpenGL ES 2.0 and 3.0 are emulated via desktop OpenGL. On Android the functionality of the Java OpenGL ES bindings is used.

Audio offers you various methods to output and record sound and music. This is achieved via the Java Sound API on the desktop. On Android the Android media framework is used.

Input offers you various methods to poll user input from the keyboard, touch screen, mouse and accelerometer. Additionally you can implement an InputProcessor and use it with Input.setInputProcessor(InputProcessor) to receive input events.

Files offers you various methods to access internal and external files. An internal file is a file that is stored near your application. On Android internal files are equivalent to assets. On the desktop the classpath is first scanned for the specified file. If that fails then the root directory of your application is used for a look up. External files are resources you create in your application and write to an external storage. On Android external files reside on the SD-card, on the desktop external files are written to a users home directory. If you know what you are doing you can also specify absolute file names. Absolute filenames are not portable, so take great care when using this feature.

Net offers you various methods to perform network operations, such as performing HTTP requests, or creating server and client sockets for more elaborate network programming.

The Application also has a set of methods that you can use to query specific information such as the operating system the application is currently running on and so forth. This allows you to have operating system dependent code paths. It is however not recommended to use this facilities.

The Application also has a simple logging method which will print to standard out on the desktop and to logcat on Android.
Author:

mzechner

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Application.ApplicationType
Enumeration of possible Application types

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Application.ApplicationType` Enumeration of possible `Application` types

Field Summary

Fields
Modifier and Type Field and Description

static int LOG_DEBUG

static int LOG_ERROR

static int LOG_INFO

static int LOG_NONE

Fields
Modifier and Type	Field and Description
`static int`	`LOG_DEBUG`
`static int`	`LOG_ERROR`
`static int`	`LOG_INFO`
`static int`	`LOG_NONE`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`addLifecycleListener(LifecycleListener listener)` Adds a new `LifecycleListener` to the application.
`void`	`debug(String tag, String message)` Logs a debug message to the console or logcat
`void`	`debug(String tag, String message, Throwable exception)` Logs a debug message to the console or logcat
`void`	`error(String tag, String message)` Logs an error message to the console or logcat
`void`	`error(String tag, String message, Throwable exception)` Logs an error message to the console or logcat
`void`	`exit()` Schedule an exit from the application.
`ApplicationListener`	`getApplicationListener()`
`ApplicationLogger`	`getApplicationLogger()`
`Audio`	`getAudio()`
`Clipboard`	`getClipboard()`
`Files`	`getFiles()`
`Graphics`	`getGraphics()`
`Input`	`getInput()`
`long`	`getJavaHeap()`
`int`	`getLogLevel()` Gets the log level.
`long`	`getNativeHeap()`
`Net`	`getNet()`
`Preferences`	`getPreferences(String name)` Returns the `Preferences` instance of this Application.
`Application.ApplicationType`	`getType()`
`int`	`getVersion()`
`void`	`log(String tag, String message)` Logs a message to the console or logcat
`void`	`log(String tag, String message, Throwable exception)` Logs a message to the console or logcat
`void`	`postRunnable(Runnable runnable)` Posts a `Runnable` on the main loop thread.
`void`	`removeLifecycleListener(LifecycleListener listener)` Removes the `LifecycleListener`.
`void`	`setApplicationLogger(ApplicationLogger applicationLogger)` Sets the current Application logger.
`void`	`setLogLevel(int logLevel)` Sets the log level.

- Field Detail
  - LOG_NONE
```
static final int LOG_NONE
```
    See Also:
    
    Constant Field Values
  - LOG_DEBUG
```
static final int LOG_DEBUG
```
    See Also:
    
    Constant Field Values
  - LOG_INFO
```
static final int LOG_INFO
```
    See Also:
    
    Constant Field Values
  - LOG_ERROR
```
static final int LOG_ERROR
```
    See Also:
    
    Constant Field Values
- Method Detail
  - getApplicationListener
```
ApplicationListener getApplicationListener()
```
    Returns:
    
    the ApplicationListener instance
  - getGraphics
```
Graphics getGraphics()
```
    Returns:
    
    the Graphics instance
  - getAudio
```
Audio getAudio()
```
    Returns:
    
    the Audio instance
  - getInput
```
Input getInput()
```
    Returns:
    
    the Input instance
  - getFiles
```
Files getFiles()
```
    Returns:
    
    the Files instance
  - getNet
```
Net getNet()
```
    Returns:
    
    the Net instance
  - log
```
void log(String tag,
         String message)
```
    Logs a message to the console or logcat
  - log
```
void log(String tag,
         String message,
         Throwable exception)
```
    Logs a message to the console or logcat
  - error
```
void error(String tag,
           String message)
```
    Logs an error message to the console or logcat
  - error
```
void error(String tag,
           String message,
           Throwable exception)
```
    Logs an error message to the console or logcat
  - debug
```
void debug(String tag,
           String message)
```
    Logs a debug message to the console or logcat
  - debug
```
void debug(String tag,
           String message,
           Throwable exception)
```
    Logs a debug message to the console or logcat
  - setLogLevel
```
void setLogLevel(int logLevel)
```
    Sets the log level. LOG_NONE will mute all log output. LOG_ERROR will only let error messages through. LOG_INFO will let all non-debug messages through, and LOG_DEBUG will let all messages through.
    
    Parameters:
    
    logLevel - LOG_NONE, LOG_ERROR, LOG_INFO, LOG_DEBUG.
  - getLogLevel
```
int getLogLevel()
```
    Gets the log level.
  - setApplicationLogger
```
void setApplicationLogger(ApplicationLogger applicationLogger)
```
    Sets the current Application logger. Calls to log(String, String) are delegated to this ApplicationLogger
  - getApplicationLogger
```
ApplicationLogger getApplicationLogger()
```
    Returns:
    
    the current ApplicationLogger
  - getType
```
Application.ApplicationType getType()
```
    Returns:
    
    what Application.ApplicationType this application has, e.g. Android or Desktop
  - getVersion
```
int getVersion()
```
    Returns:
    
    the Android API level on Android, the major OS version on iOS (5, 6, 7, ..), or 0 on the desktop.
  - getJavaHeap
```
long getJavaHeap()
```
    Returns:
    
    the Java heap memory use in bytes
  - getNativeHeap
```
long getNativeHeap()
```
    Returns:
    
    the Native heap memory use in bytes
  - getPreferences
```
Preferences getPreferences(String name)
```
    Returns the Preferences instance of this Application. It can be used to store application settings across runs.
    
    Parameters:
    
    name - the name of the preferences, must be useable as a file name.
    
    Returns:
    
    the preferences.
  - getClipboard
```
Clipboard getClipboard()
```
  - postRunnable
```
void postRunnable(Runnable runnable)
```
    Posts a Runnable on the main loop thread. In a multi-window application, the Gdx.graphics and Gdx.input values may be unpredictable at the time the Runnable is executed. If graphics or input are needed, they can be copied to a variable to be used in the Runnable. For example:
    final Graphics graphics = Gdx.graphics;
    Parameters: runnable - the runnable.
  exit void exit() Schedule an exit from the application. On android, this will cause a call to pause() and dispose() some time in the future, it will not immediately finish your application. On iOS this should be avoided in production as it breaks Apples guidelines addLifecycleListener void addLifecycleListener(LifecycleListener listener) Adds a new LifecycleListener to the application. This can be used by extensions to hook into the lifecycle more easily. The ApplicationListener methods are sufficient for application level development. Parameters: listener - removeLifecycleListener void removeLifecycleListener(LifecycleListener listener) Removes the LifecycleListener. Parameters: listener -

Interface Application

Nested Class Summary

Field Summary

Method Summary

Field Detail

LOG_NONE

LOG_DEBUG

LOG_INFO

LOG_ERROR

Method Detail

getApplicationListener

getGraphics

getAudio

getInput

getFiles

getNet

log

log

error

error

debug

debug

setLogLevel

getLogLevel

setApplicationLogger

getApplicationLogger

getType

getVersion

getJavaHeap

getNativeHeap

getPreferences

getClipboard

postRunnable

exit

addLifecycleListener

removeLifecycleListener