AbstractLifecycleHandler.java
01 /*
02  * SPDX-License-Identifier: Apache-2.0
03  *
04  * Copyright 2008-2017 the original author or authors.
05  *
06  * Licensed under the Apache License, Version 2.0 (the "License");
07  * you may not use this file except in compliance with the License.
08  * You may obtain a copy of the License at
09  *
10  *     http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 package org.codehaus.griffon.runtime.core;
19 
20 import griffon.core.GriffonApplication;
21 import griffon.core.LifecycleHandler;
22 
23 import javax.annotation.Nonnull;
24 import javax.annotation.Nullable;
25 import javax.inject.Inject;
26 import java.util.concurrent.Callable;
27 import java.util.concurrent.ExecutorService;
28 import java.util.concurrent.Future;
29 
30 import static java.util.Objects.requireNonNull;
31 
32 /**
33  * Base implementation of the {@code LifecycleHandler} interface.
34  *
35  @author Andres Almiray
36  @since 2.0.0
37  */
38 public abstract class AbstractLifecycleHandler implements LifecycleHandler {
39     private final GriffonApplication application;
40 
41     @Inject
42     public AbstractLifecycleHandler(@Nonnull GriffonApplication application) {
43         this.application = requireNonNull(application, "Argument 'application' must not be null");
44     }
45 
46     @Nonnull
47     protected GriffonApplication getApplication() {
48         return application;
49     }
50 
51     @Override
52     public boolean isUIThread() {
53         return application.getUIThreadManager().isUIThread();
54     }
55 
56     @Override
57     @Nonnull
58     public <R> Future<R> runFuture(@Nonnull Callable<R> callable) {
59         return application.getUIThreadManager().runFuture(callable);
60     }
61 
62     @Override
63     @Nonnull
64     public <R> Future<R> runFuture(@Nonnull ExecutorService executorService, @Nonnull Callable<R> callable) {
65         return application.getUIThreadManager().runFuture(executorService, callable);
66     }
67 
68     @Override
69     public void runInsideUIAsync(@Nonnull Runnable runnable) {
70         application.getUIThreadManager().runInsideUIAsync(runnable);
71     }
72 
73     @Override
74     public void runInsideUISync(@Nonnull Runnable runnable) {
75         application.getUIThreadManager().runInsideUISync(runnable);
76     }
77 
78     @Override
79     public void runOutsideUI(@Nonnull Runnable runnable) {
80         application.getUIThreadManager().runOutsideUI(runnable);
81     }
82 
83     @Override
84     public void runOutsideUIAsync(@Nonnull Runnable runnable) {
85         application.getUIThreadManager().runOutsideUIAsync(runnable);
86     }
87 
88     @Nullable
89     @Override
90     public <R> R runInsideUISync(@Nonnull Callable<R> callable) {
91         return application.getUIThreadManager().runInsideUISync(callable);
92     }
93 }