Package com.intellij.openapi.application

Interface Application

All Superinterfaces:

AreaInstance, ComponentManager, Disposable, UserDataHolder

All Known Subinterfaces:

ApplicationEx

All Known Implementing Classes:

ApplicationImpl, MockApplication, MockApplicationEx

public interface Application
extends ComponentManager

Provides access to core application-wide functionality and methods for working with the IDE's thread model.

The thread model defines three types of locks which provide access the PSI and other IDE data structures:

• Read lock provides read access to the data. Can be obtained from any thread concurrently with other Read locks and Write Intent lock.
• Write Intent lock provides read access to the data and the ability to acquire Write lock. Can be obtained from any thread concurrently with Read locks, but cannot be acquired if another Write Intent lock is held on another thread.
• Write lock provides read and write access to the data. Can only be obtained from under Write Intent lock. Cannot be acquired if a Read lock is held on another thread.

The compatibility matrix for these locks is reflected below.

	R	IW	W
R	+	+	-
IW	+	-	-
W	-	-	-

Obtaining locks manually is not recommended. The recommended way to obtain read and write locks is to run so-called "read actions" and "write actions" via runReadAction(java.lang.Runnable) and runWriteAction(java.lang.Runnable), respectively.

The recommended way to obtain Write Intent lock is to schedule execution on so-called "write thread" (i.e. thread with Write Intent lock) via invokeLaterOnWriteThread(java.lang.Runnable), WriteThread or AppUIExecutor.onWriteThread(com.intellij.openapi.application.ModalityState) asynchronous API.

Multiple read actions can run at the same time without locking each other.

If there are read actions running at this moment runWriteAction is blocked until they are completed.

See also General Threading Rules.

Nested Class Summary

Nested classes/interfaces inherited from interface com.intellij.openapi.Disposable

Disposable.Parent

Method Summary

Modifier and Type	Method and Description
AccessToken	acquireReadActionLock() Deprecated. Use runReadAction(Runnable) instead
AccessToken	acquireWriteActionLock(java.lang.Class<?> marker) Deprecated. use runWriteAction(java.lang.Runnable), WriteAction.run(ThrowableRunnable) or WriteAction.compute(ThrowableComputable) instead
boolean	acquireWriteIntentLockIfNeeded() Private API to use in instrumented code.
void	addApplicationListener(ApplicationListener listener) Deprecated. Use addApplicationListener(ApplicationListener, Disposable) instead Adds an ApplicationListener.
void	addApplicationListener(ApplicationListener listener, Disposable parent) Adds an ApplicationListener.
void	assertIsDispatchThread() Asserts whether the method is being called from the event dispatch thread.
void	assertIsWriteThread() Asserts whether the method is being called from under the Write Intent lock
void	assertReadAccessAllowed() Asserts whether the read access is allowed.
void	assertWriteAccessAllowed() Asserts whether the write access is allowed.
<T> java.util.concurrent.Future<T>	executeOnPooledThread(java.util.concurrent.Callable<T> action) Requests pooled thread to execute the action.
java.util.concurrent.Future<?>	executeOnPooledThread(java.lang.Runnable action) Requests pooled thread to execute the action.
void	exit() Exits the application, showing the exit confirmation prompt if it is enabled.
default void	exit(boolean force, boolean exitConfirmed, boolean restart)
ModalityState	getAnyModalityState() Please use ModalityState.any() instead, and only if you absolutely must, after carefully reading its documentation.
ModalityState	getCurrentModalityState() Please use ModalityState.current() instead.
ModalityState	getDefaultModalityState() Please use ModalityState.defaultModalityState() instead.
long	getIdleTime() Returns the time in milliseconds during which IDE received no input events.
ModalityInvokator	getInvokator()
ModalityState	getModalityStateForComponent(java.awt.Component c) Please use ModalityState.stateForComponent(Component) instead.
ModalityState	getNoneModalityState() Please use ModalityState.NON_MODAL instead.
long	getStartTime() Returns the time of IDE start, in milliseconds since midnight, January 1, 1970 UTC.
boolean	hasWriteAction(java.lang.Class<?> actionClass) Returns true if there is currently executing write action of the specified class.
void	invokeAndWait(java.lang.Runnable runnable) Same as invokeAndWait(Runnable, ModalityState), using ModalityState.defaultModalityState().
void	invokeAndWait(java.lang.Runnable runnable, ModalityState modalityState) Causes runnable.run() to be executed synchronously on the AWT event dispatching thread under Write Intent lock, when the IDE is in the specified modality state (or a state with less modal dialogs open).
void	invokeLater(java.lang.Runnable runnable) Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, with ModalityState.defaultModalityState() modality state.
void	invokeLater(java.lang.Runnable runnable, Condition<?> expired) Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock - unless the expiration condition is fulfilled.
void	invokeLater(java.lang.Runnable runnable, ModalityState state) Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, when IDE is in the specified modality state (or a state with less modal dialogs open).
void	invokeLater(java.lang.Runnable runnable, ModalityState state, Condition<?> expired) Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, when IDE is in the specified modality state(or a state with less modal dialogs open) - unless the expiration condition is fulfilled.
void	invokeLaterOnWriteThread(java.lang.Runnable action) Causes runnable to be executed asynchronously under Write Intent lock on some thread, with ModalityState.defaultModalityState() modality state.
void	invokeLaterOnWriteThread(java.lang.Runnable action, ModalityState modal) Causes runnable to be executed asynchronously under Write Intent lock on some thread, when IDE is in the specified modality state (or a state with less modal dialogs open).
void	invokeLaterOnWriteThread(java.lang.Runnable action, ModalityState modal, Condition<?> expired) Causes runnable to be executed asynchronously under Write Intent lock on some thread, when IDE is in the specified modality state (or a state with less modal dialogs open) - unless the expiration condition is fulfilled.
boolean	isActive() Checks if the application is active.
boolean	isCommandLine() Checks if IDE is running as a command line applet or in unit test mode.
boolean	isDispatchThread() Checks if the current thread is the Swing dispatch thread and has IW lock acquired.
default boolean	isDisposeInProgress() Deprecated. Use ComponentManager.isDisposed().
boolean	isEAP()
boolean	isHeadlessEnvironment() Checks if IDE is running as a command line applet or in unit test mode.
boolean	isInternal() Checks if IDE is running in Internal Mode to enable additional features for plugin development.
boolean	isReadAccessAllowed() Checks if the read access is currently allowed.
boolean	isRestartCapable() Checks if IDE is capable of restarting itself on the current platform and with the current execution mode.
boolean	isUnitTestMode() Checks if IDE is currently running unit tests.
boolean	isWriteAccessAllowed() Checks if the write access is currently allowed.
boolean	isWriteThread() Checks if the current thread has IW lock acquired, which grants read access and the ability to run write actions.
void	releaseWriteIntentLockIfNeeded(boolean needed) Private API to use in instrumented code.
void	removeApplicationListener(ApplicationListener listener) Deprecated. Instead, just call Disposer.dispose(disposable); on disposable you've passed to addApplicationListener(ApplicationListener, Disposable) Removes an ApplicationListener.
void	restart() Exits and restarts IDE.
void	runIntendedWriteActionOnCurrentThread(java.lang.Runnable action) Runs the specified action under Write Intent lock.
<T> T	runReadAction(Computable<T> computation) Runs the specified computation in a read action.
void	runReadAction(java.lang.Runnable action) Runs the specified read action.
<T,E extends java.lang.Throwable> T	runReadAction(ThrowableComputable<T,E> computation) Runs the specified computation in a read action.
<T,E extends java.lang.Throwable> T	runUnlockingIntendedWrite(ThrowableComputable<T,E> action) Runs the specified action, releasing Write Intent lock if it is acquired at the moment of the call.
<T> T	runWriteAction(Computable<T> computation) Runs the specified computation in a write action.
void	runWriteAction(java.lang.Runnable action) Runs the specified write action.
<T,E extends java.lang.Throwable> T	runWriteAction(ThrowableComputable<T,E> computation) Runs the specified computation in a write action.
void	saveAll() Saves all open documents and projects.
void	saveSettings() Saves application settings.

Methods inherited from interface com.intellij.openapi.components.ComponentManager

createError, createError, getComponent, getComponent, getComponent, getComponentInstancesOfType, getComponentInstancesOfType, getComponents, getDisposed, getExtensionArea, getExtensions, getMessageBus, getPicoContainer, getService, getService, getServiceIfCreated, hasComponent, instantiateClass, instantiateClassWithConstructorInjection, instantiateExtensionWithPicoContainerOnlyIfNeeded, isDisposed, isDisposedOrDisposeInProgress, logError

Methods inherited from interface com.intellij.openapi.util.UserDataHolder

getUserData, putUserData

Methods inherited from interface com.intellij.openapi.Disposable

dispose

Method Detail

acquireWriteIntentLockIfNeeded

boolean acquireWriteIntentLockIfNeeded()

Private API to use in instrumented code.

Acquires IW lock if it's not acquired by the current thread.

Returns:

true if IW lock was acquired, or false if it is held by the current thread already.

releaseWriteIntentLockIfNeeded

void releaseWriteIntentLockIfNeeded(boolean needed)

Private API to use in instrumented code.

Releases IW lock if the parameter is true.

Parameters:

needed - whether IW lock should be released or not

invokeLaterOnWriteThread

void invokeLaterOnWriteThread(java.lang.Runnable action)

Causes runnable to be executed asynchronously under Write Intent lock on some thread, with ModalityState.defaultModalityState() modality state.

Parameters:

action - the runnable to execute.

invokeLaterOnWriteThread

void invokeLaterOnWriteThread(java.lang.Runnable action,
                              ModalityState modal)

Causes runnable to be executed asynchronously under Write Intent lock on some thread, when IDE is in the specified modality state (or a state with less modal dialogs open).

Parameters:

action - the runnable to execute.

modal - the state in which action will be executed

invokeLaterOnWriteThread

void invokeLaterOnWriteThread(java.lang.Runnable action,
                              ModalityState modal,
                              Condition<?> expired)

Causes runnable to be executed asynchronously under Write Intent lock on some thread, when IDE is in the specified modality state (or a state with less modal dialogs open) - unless the expiration condition is fulfilled.

Parameters:

action - the runnable to execute.

modal - the state in which action will be executed

expired - condition to check before execution.

runUnlockingIntendedWrite

<T,E extends java.lang.Throwable> T runUnlockingIntendedWrite(ThrowableComputable<T,E> action)
                                                       throws E extends java.lang.Throwable

Runs the specified action, releasing Write Intent lock if it is acquired at the moment of the call.

This method is used to implement higher-level API, please do not use it directly.

Throws:

E extends java.lang.Throwable

runIntendedWriteActionOnCurrentThread

void runIntendedWriteActionOnCurrentThread(java.lang.Runnable action)

Runs the specified action under Write Intent lock. Can be called from any thread. The action is executed immediately if no write intent action is currently running, or blocked until the currently running write intent action completes.

This method is used to implement higher-level API, please do not use it directly. Use invokeLaterOnWriteThread(java.lang.Runnable), WriteThread or AppUIExecutor.onWriteThread() to run code under Write Intent lock asynchronously.

Parameters:

action - the action to run

runReadAction

void runReadAction(java.lang.Runnable action)

Runs the specified read action. Can be called from any thread. The action is executed immediately if no write action is currently running, or blocked until the currently running write action completes.

See also ReadAction.run(com.intellij.openapi.application.Result<T>) for a more lambda-friendly version.

Parameters:

action - the action to run.

runReadAction

<T> T runReadAction(Computable<T> computation)

Runs the specified computation in a read action. Can be called from any thread. The action is executed immediately if no write action is currently running, or blocked until the currently running write action completes.

See also ReadAction.compute(com.intellij.openapi.util.ThrowableComputable<T, E>) for a more lambda-friendly version.

Parameters:

computation - the computation to perform.

Returns:

the result returned by the computation.

runReadAction

<T,E extends java.lang.Throwable> T runReadAction(ThrowableComputable<T,E> computation)
                                           throws E extends java.lang.Throwable

Runs the specified computation in a read action. Can be called from any thread. The action is executed immediately if no write action is currently running, or blocked until the currently running write action completes.

See also ReadAction.compute(com.intellij.openapi.util.ThrowableComputable<T, E>) for a more lambda-friendly version.

Parameters:

computation - the computation to perform.

Returns:

the result returned by the computation.

Throws:

E - re-frown from ThrowableComputable

E extends java.lang.Throwable

runWriteAction

void runWriteAction(java.lang.Runnable action)

Runs the specified write action. Must be called from the Swing dispatch thread. The action is executed immediately if no read actions are currently running, or blocked until all read actions complete.

See also WriteAction.run(com.intellij.util.ThrowableRunnable<E>) for a more lambda-friendly version.

Parameters:

action - the action to run

runWriteAction

<T> T runWriteAction(Computable<T> computation)

Runs the specified computation in a write action. Must be called from the Swing dispatch thread. The action is executed immediately if no read actions or write actions are currently running, or blocked until all read actions and write actions complete.

See also WriteAction.compute(com.intellij.openapi.util.ThrowableComputable<T, E>) for a more lambda-friendly version.

Parameters:

computation - the computation to run

Returns:

the result returned by the computation.

runWriteAction

<T,E extends java.lang.Throwable> T runWriteAction(ThrowableComputable<T,E> computation)
                                            throws E extends java.lang.Throwable

Runs the specified computation in a write action. Must be called from the Swing dispatch thread. The action is executed immediately if no read actions or write actions are currently running, or blocked until all read actions and write actions complete.

See also WriteAction.compute(com.intellij.openapi.util.ThrowableComputable<T, E>) for a more lambda-friendly version.

Parameters:

computation - the computation to run

Returns:

the result returned by the computation.

Throws:

E - re-frown from ThrowableComputable

E extends java.lang.Throwable

hasWriteAction

boolean hasWriteAction(java.lang.Class<?> actionClass)

Returns true if there is currently executing write action of the specified class.

Parameters:

actionClass - the class of the write action to return.

Returns:

true if the action is running, or false if no action of the specified class is currently executing.

assertReadAccessAllowed

void assertReadAccessAllowed()

Asserts whether the read access is allowed.

assertWriteAccessAllowed

void assertWriteAccessAllowed()

Asserts whether the write access is allowed.

assertIsDispatchThread

void assertIsDispatchThread()

Asserts whether the method is being called from the event dispatch thread.

assertIsWriteThread

void assertIsWriteThread()

Asserts whether the method is being called from under the Write Intent lock

addApplicationListener

@Deprecated
void addApplicationListener(ApplicationListener listener)

Deprecated. Use addApplicationListener(ApplicationListener, Disposable) instead Adds an ApplicationListener.

Parameters:

listener - the listener to add

addApplicationListener

void addApplicationListener(ApplicationListener listener,
                            Disposable parent)

Adds an ApplicationListener.

Parameters:

listener - the listener to add

parent - the parent disposable which dispose will trigger this listener removal

removeApplicationListener

@Deprecated
void removeApplicationListener(ApplicationListener listener)

Deprecated. Instead, just call Disposer.dispose(disposable); on disposable you've passed to addApplicationListener(ApplicationListener, Disposable) Removes an ApplicationListener.

Parameters:

listener - the listener to remove

saveAll

void saveAll()

Saves all open documents and projects.

saveSettings

void saveSettings()

Saves application settings.

exit

void exit()

Exits the application, showing the exit confirmation prompt if it is enabled.

exit

default void exit(boolean force,
                  boolean exitConfirmed,
                  boolean restart)

isWriteAccessAllowed

boolean isWriteAccessAllowed()

Checks if the write access is currently allowed.

Returns:

true if the write access is currently allowed, false otherwise.

See Also:

assertWriteAccessAllowed(), runWriteAction(Runnable)

isReadAccessAllowed

boolean isReadAccessAllowed()

Checks if the read access is currently allowed.

Returns:

true if the read access is currently allowed, false otherwise.

See Also:

assertReadAccessAllowed(), runReadAction(Runnable)

isDispatchThread

boolean isDispatchThread()

Checks if the current thread is the Swing dispatch thread and has IW lock acquired.

Returns:

true if the current thread is the Swing dispatch thread with IW lock, false otherwise.

See Also:

isWriteThread()

isWriteThread

boolean isWriteThread()

Checks if the current thread has IW lock acquired, which grants read access and the ability to run write actions.

Returns:

true if the current thread has IW lock acquired, false otherwise.

getInvokator

ModalityInvokator getInvokator()

Returns:

a facade, which lets to call all those invokeLater() with a ActionCallback handle returned.

invokeLater

void invokeLater(java.lang.Runnable runnable)

Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, with ModalityState.defaultModalityState() modality state. This will happen after all pending AWT events have been processed.

Please use this method instead of SwingUtilities.invokeLater(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.

Parameters:

runnable - the runnable to execute.

invokeLater

void invokeLater(java.lang.Runnable runnable,
                 Condition<?> expired)

Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock - unless the expiration condition is fulfilled. This will happen after all pending AWT events have been processed and in ModalityState.defaultModalityState() modality state (or a state with less modal dialogs open).

Please use this method instead of SwingUtilities.invokeLater(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.

Parameters:

runnable - the runnable to execute.

expired - condition to check before execution.

invokeLater

void invokeLater(java.lang.Runnable runnable,
                 ModalityState state)

Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, when IDE is in the specified modality state (or a state with less modal dialogs open).

Please use this method instead of SwingUtilities.invokeLater(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.

Parameters:

runnable - the runnable to execute.

state - the state in which the runnable will be executed.

invokeLater

void invokeLater(java.lang.Runnable runnable,
                 ModalityState state,
                 Condition<?> expired)

Causes runnable.run() to be executed asynchronously on the AWT event dispatching thread under Write Intent lock, when IDE is in the specified modality state(or a state with less modal dialogs open) - unless the expiration condition is fulfilled. This will happen after all pending AWT events have been processed.

Please use this method instead of SwingUtilities.invokeLater(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.

Parameters:

runnable - the runnable to execute.

state - the state in which the runnable will be executed.

expired - condition to check before execution.

invokeAndWait

void invokeAndWait(java.lang.Runnable runnable,
                   ModalityState modalityState)
            throws ProcessCanceledException

Causes runnable.run() to be executed synchronously on the AWT event dispatching thread under Write Intent lock, when the IDE is in the specified modality state (or a state with less modal dialogs open). This call blocks until all pending AWT events have been processed and (then) runnable.run() returns.

If current thread is an event dispatch thread then runnable.run() is executed immediately regardless of the modality state.

Please use this method instead of SwingUtilities.invokeAndWait(Runnable) or UIUtil methods for the reasons described in ModalityState documentation.

Parameters:

runnable - the runnable to execute.

modalityState - the state in which the runnable will be executed.

Throws:

ProcessCanceledException - when the current thread is interrupted

invokeAndWait

void invokeAndWait(java.lang.Runnable runnable)
            throws ProcessCanceledException

Same as invokeAndWait(Runnable, ModalityState), using ModalityState.defaultModalityState().

Throws:

ProcessCanceledException

getCurrentModalityState

ModalityState getCurrentModalityState()

Please use ModalityState.current() instead.

Returns:

the current modality state.

getModalityStateForComponent

ModalityState getModalityStateForComponent(java.awt.Component c)

Please use ModalityState.stateForComponent(Component) instead.

Returns:

the modality state for the dialog to which the specified component belongs.

getDefaultModalityState

ModalityState getDefaultModalityState()

Please use ModalityState.defaultModalityState() instead.

Returns:

the modality state for the current thread.

getNoneModalityState

ModalityState getNoneModalityState()

Please use ModalityState.NON_MODAL instead.

Returns:

the modality state for no modal dialogs.

getAnyModalityState

ModalityState getAnyModalityState()

Please use ModalityState.any() instead, and only if you absolutely must, after carefully reading its documentation.

Returns:

modality state which is always applicable

getStartTime

long getStartTime()

Returns the time of IDE start, in milliseconds since midnight, January 1, 1970 UTC.

Returns:

the IDE's start time.

getIdleTime

long getIdleTime()

Returns the time in milliseconds during which IDE received no input events.

Returns:

the idle time of IDE.

isUnitTestMode

boolean isUnitTestMode()

Checks if IDE is currently running unit tests. No UI should be shown when unit tests are being executed. This method may also be used for additional debug checks or logging in test mode.

Please avoid doing things differently depending on the result of this method, because this leads to testing something synthetic instead of what really happens in production. So you'll be able to catch less of production bugs and might instead lose your time on debugging test-only issues. It's more robust to write a bit more code in tests to accommodate for production behavior than vice versa. For example:

• To wait for an invokeLater in tests, you can call PlatformTestUtil.dispatchAllInvocationEventsInIdeEventQueue()
• To wait for asynchronous non-blocking read operations, you can call NonBlockingReadActionImpl.waitForAsyncTaskCompletion()
• To wait for other asynchronous operations, you can track their Future/Promise/etc callbacks and call PlatformTestUtil.waitFor*
• To emulate user interaction with a simple yes/no dialog, use Messages.setTestDialog(...)
• For other UI interaction, try UiInterceptors

Returns:

true if IDE is running unit tests, false otherwise

isHeadlessEnvironment

boolean isHeadlessEnvironment()

Checks if IDE is running as a command line applet or in unit test mode. No UI should be shown when IDE is running in this mode.

Returns:

true if IDE is running in UI-less mode, false otherwise

isCommandLine

boolean isCommandLine()

Checks if IDE is running as a command line applet or in unit test mode. UI can be shown (e.g. diff frame)

Returns:

true if IDE is running in command line mode, false otherwise

executeOnPooledThread

java.util.concurrent.Future<?> executeOnPooledThread(java.lang.Runnable action)

Requests pooled thread to execute the action.

This pool is an

• Unbounded.
• Application-wide, always active, non-shutdownable singleton.

You can use this pool for long-running and/or IO-bound tasks.

Parameters:

action - to be executed

Returns:

future result

executeOnPooledThread

<T> java.util.concurrent.Future<T> executeOnPooledThread(java.util.concurrent.Callable<T> action)

Requests pooled thread to execute the action.

This pool is an

• Unbounded.
• Application-wide, always active, non-shutdownable singleton.

You can use this pool for long-running and/or IO-bound tasks.

Parameters:

action - to be executed

Returns:

future result

isDisposeInProgress

@Deprecated
default boolean isDisposeInProgress()

Deprecated. Use ComponentManager.isDisposed().

isRestartCapable

boolean isRestartCapable()

Checks if IDE is capable of restarting itself on the current platform and with the current execution mode.

Returns:

true if IDE can restart itself, false otherwise.

restart

void restart()

Exits and restarts IDE. If the current platform is not restart capable, only exits.

isActive

boolean isActive()

Checks if the application is active.

Returns:

true if one of application windows is focused, false otherwise

acquireReadActionLock

@Deprecated
AccessToken acquireReadActionLock()

Deprecated. Use runReadAction(Runnable) instead

acquireWriteActionLock

@Deprecated
AccessToken acquireWriteActionLock(java.lang.Class<?> marker)

Deprecated. use runWriteAction(java.lang.Runnable), WriteAction.run(ThrowableRunnable) or WriteAction.compute(ThrowableComputable) instead

isInternal

boolean isInternal()

Checks if IDE is running in Internal Mode to enable additional features for plugin development.

isEAP

boolean isEAP()