1 /*
2 * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #import <pthread.h>
27 #import <objc/runtime.h>
28 #import <Cocoa/Cocoa.h>
29 #import <Security/AuthSession.h>
30 #import <JavaNativeFoundation/JavaNativeFoundation.h>
31 #import <JavaRuntimeSupport/JavaRuntimeSupport.h>
32
33 #import "NSApplicationAWT.h"
34 #import "PropertiesUtilities.h"
35 #import "ThreadUtilities.h"
36 #import "AWT_debug.h"
37 #import "ApplicationDelegate.h"
38
39 #define DEBUG 0
40
41
42 // The symbol is defined in libosxapp.dylib (ThreadUtilities.m)
43 extern JavaVM *jvm;
44
45 // Indicates if AWT is running embedded (in SWT, FX, elsewhere)
46 static BOOL isEmbedded = NO;
47
48 // Indicates that the app has been started with -XstartOnFirstThread
49 // (directly or via WebStart settings), and AWT should not run its
50 // own event loop in this mode. Even if a loop isn't running yet,
51 // we expect an embedder (e.g. SWT) to start it some time later.
52 static BOOL forceEmbeddedMode = NO;
53
54 static bool ShouldPrintVerboseDebugging() {
55 static int debug = -1;
56 if (debug == -1) {
57 debug = (int)(getenv("JAVA_AWT_VERBOSE") != NULL) || (DEBUG != 0);
58 }
59 return (bool)debug;
60 }
61
62 // This is the data necessary to have JNI_OnLoad wait for AppKit to start.
63 static BOOL sAppKitStarted = NO;
64 static pthread_mutex_t sAppKitStarted_mutex = PTHREAD_MUTEX_INITIALIZER;
65 static pthread_cond_t sAppKitStarted_cv = PTHREAD_COND_INITIALIZER;
66
67 void setBusy(BOOL isBusy);
68 static void BusyObserver(CFRunLoopObserverRef ref, CFRunLoopActivity what, void* arg);
69 static void NotBusyObserver(CFRunLoopObserverRef ref, CFRunLoopActivity what, void* arg);
70 static void AWT_NSUncaughtExceptionHandler(NSException *exception);
71
72 static CFRunLoopObserverRef busyObserver = NULL;
73 static CFRunLoopObserverRef notBusyObserver = NULL;
74
75 static void setUpAWTAppKit()
76 {
77 BOOL verbose = ShouldPrintVerboseDebugging();
78 if (verbose) AWT_DEBUG_LOG(@"setting up busy observers");
79
80 // Add CFRunLoopObservers to call into AWT so that AWT knows that the
81 // AWT thread (which is the AppKit main thread) is alive. This way AWT
82 // will not automatically shutdown.
83 busyObserver = CFRunLoopObserverCreate(
84 NULL, // CFAllocator
85 kCFRunLoopAfterWaiting, // CFOptionFlags
86 true, // repeats
87 NSIntegerMax, // order
88 &BusyObserver, // CFRunLoopObserverCallBack
89 NULL); // CFRunLoopObserverContext
90
91 notBusyObserver = CFRunLoopObserverCreate(
92 NULL, // CFAllocator
93 kCFRunLoopBeforeWaiting, // CFOptionFlags
94 true, // repeats
95 NSIntegerMin, // order
96 &NotBusyObserver, // CFRunLoopObserverCallBack
97 NULL); // CFRunLoopObserverContext
98
99 CFRunLoopRef runLoop = [[NSRunLoop currentRunLoop] getCFRunLoop];
100 CFRunLoopAddObserver(runLoop, busyObserver, kCFRunLoopDefaultMode);
101 CFRunLoopAddObserver(runLoop, notBusyObserver, kCFRunLoopDefaultMode);
102
103 CFRelease(busyObserver);
104 CFRelease(notBusyObserver);
105
106 setBusy(YES);
107 }
108
109 static void setUpAppKitThreadName()
110 {
111 BOOL verbose = ShouldPrintVerboseDebugging();
112 JNIEnv *env = [ThreadUtilities getJNIEnv];
113
114 // Set the java name of the AppKit main thread appropriately.
115 jclass threadClass = NULL;
116 jstring name = NULL;
117 jobject curThread = NULL;
118
119 threadClass = (*env)->FindClass(env, "java/lang/Thread");
120 if (threadClass == NULL || (*env)->ExceptionCheck(env)) goto cleanup;
121 jmethodID currentThreadID = (*env)->GetStaticMethodID(env, threadClass, "currentThread", "()Ljava/lang/Thread;");
122 if (currentThreadID == NULL || (*env)->ExceptionCheck(env)) goto cleanup;
123 jmethodID setName = (*env)->GetMethodID(env, threadClass, "setName", "(Ljava/lang/String;)V");
124 if (setName == NULL || (*env)->ExceptionCheck(env)) goto cleanup;
125
126 curThread = (*env)->CallStaticObjectMethod(env, threadClass, currentThreadID); // AWT_THREADING Safe (known object)
127 if (curThread == NULL || (*env)->ExceptionCheck(env)) goto cleanup;
128 name = (*env)->NewStringUTF(env, "AWT-AppKit");
129 if (name == NULL || (*env)->ExceptionCheck(env)) goto cleanup;
130 (*env)->CallVoidMethod(env, curThread, setName, name); // AWT_THREADING Safe (known object)
131 if ((*env)->ExceptionCheck(env)) goto cleanup;
132
133 cleanup:
134 if (threadClass != NULL) {
135 (*env)->DeleteLocalRef(env, threadClass);
136 }
137 if (name != NULL) {
138 (*env)->DeleteLocalRef(env, name);
139 }
140 if (curThread != NULL) {
141 (*env)->DeleteLocalRef(env, curThread);
142 }
143 if ((*env)->ExceptionCheck(env)) {
144 (*env)->ExceptionDescribe(env);
145 (*env)->ExceptionClear(env);
146 }
147
148 if (verbose) AWT_DEBUG_LOG(@"finished setting thread name");
149 }
150
151
152 // Returns true if java believes it is running headless
153 BOOL isHeadless(JNIEnv *env) {
154 // Just access the property directly, instead of using GraphicsEnvironment.isHeadless.
155 // This is because this may be called while AWT is being loaded, and calling AWT
156 // while it is being loaded will deadlock.
157 static JNF_CLASS_CACHE(jc_Toolkit, "java/awt/GraphicsEnvironment");
158 static JNF_STATIC_MEMBER_CACHE(jm_isHeadless, jc_Toolkit, "isHeadless", "()Z");
159 return JNFCallStaticBooleanMethod(env, jm_isHeadless);
160 }
161
162 BOOL isSWTInWebStart(JNIEnv* env) {
163 NSString *swtWebStart = [PropertiesUtilities javaSystemPropertyForKey:@"com.apple.javaws.usingSWT" withEnv:env];
164 return [@"true" isCaseInsensitiveLike:swtWebStart];
165 }
166
167 void setBusy(BOOL busy) {
168 AWT_ASSERT_APPKIT_THREAD;
169
170 JNIEnv *env = [ThreadUtilities getJNIEnv];
171 static JNF_CLASS_CACHE(jc_AWTAutoShutdown, "sun/awt/AWTAutoShutdown");
172
173 if (busy) {
174 static JNF_STATIC_MEMBER_CACHE(jm_notifyBusyMethod, jc_AWTAutoShutdown, "notifyToolkitThreadBusy", "()V");
175 JNFCallStaticVoidMethod(env, jm_notifyBusyMethod);
176 } else {
177 static JNF_STATIC_MEMBER_CACHE(jm_notifyFreeMethod, jc_AWTAutoShutdown, "notifyToolkitThreadFree", "()V");
178 JNFCallStaticVoidMethod(env, jm_notifyFreeMethod);
179 }
180 }
181
182 static void BusyObserver(CFRunLoopObserverRef ref, CFRunLoopActivity what, void* arg) {
183 AWT_ASSERT_APPKIT_THREAD;
184
185 // This is only called with the selector kCFRunLoopAfterWaiting.
186 #ifndef PRODUCT_BUILD
187 assert(what == kCFRunLoopAfterWaiting);
188 #endif /* PRODUCT_BUILD */
189
190 setBusy(YES);
191 }
192
193 static void NotBusyObserver(CFRunLoopObserverRef ref, CFRunLoopActivity what, void* arg) {
194 AWT_ASSERT_APPKIT_THREAD;
195
196 // This is only called with the selector kCFRunLoopBeforeWaiting.
197 #ifndef PRODUCT_BUILD
198 assert(what == kCFRunLoopBeforeWaiting);
199 #endif /* PRODUCT_BUILD */
200
201 setBusy(NO);
202 }
203
204 static void AWT_NSUncaughtExceptionHandler(NSException *exception) {
205 NSLog(@"Apple AWT Internal Exception: %@", [exception description]);
206 }
207
208 // This is an empty Obj-C object just so that -peformSelectorOnMainThread can be used.
209 @interface AWTStarter : NSObject { }
210 + (void)start:(BOOL)headless;
211 - (void)starter:(NSArray*)args;
212 + (void)appKitIsRunning:(id)arg;
213 @end
214
215 @implementation AWTStarter
216
217 + (BOOL) isConnectedToWindowServer {
218 SecuritySessionId session_id;
219 SessionAttributeBits session_info;
220 OSStatus status = SessionGetInfo(callerSecuritySession, &session_id, &session_info);
221 if (status != noErr) return NO;
222 if (!(session_info & sessionHasGraphicAccess)) return NO;
223 return YES;
224 }
225
226 + (BOOL) markAppAsDaemon {
227 id jrsAppKitAWTClass = objc_getClass("JRSAppKitAWT");
228 SEL markAppSel = @selector(markAppIsDaemon);
229 if (![jrsAppKitAWTClass respondsToSelector:markAppSel]) return NO;
230 return [jrsAppKitAWTClass performSelector:markAppSel] ? YES : NO;
231 }
232
233 + (void)appKitIsRunning:(id)arg {
234 // Headless: NO
235 // Embedded: BOTH
236 // Multiple Calls: NO
237 // Callers: AppKit's NSApplicationDidFinishLaunchingNotification or +[AWTStarter startAWT:]
238 AWT_ASSERT_APPKIT_THREAD;
239
240 BOOL verbose = ShouldPrintVerboseDebugging();
241 if (verbose) AWT_DEBUG_LOG(@"about to message AppKit started");
242
243 // Signal that AppKit has started (or is already running).
244 pthread_mutex_lock(&sAppKitStarted_mutex);
245 sAppKitStarted = YES;
246 pthread_cond_signal(&sAppKitStarted_cv);
247 pthread_mutex_unlock(&sAppKitStarted_mutex);
248
249 if (verbose) AWT_DEBUG_LOG(@"finished messaging AppKit started");
250 }
251
252 + (void)start:(BOOL)headless
253 {
254 BOOL verbose = ShouldPrintVerboseDebugging();
255
256 // Headless: BOTH
257 // Embedded: BOTH
258 // Multiple Calls: NO
259 // Caller: JNI_OnLoad
260
261 // onMainThread is NOT the same at SWT mode!
262 // If the JVM was started on the first thread for SWT, but the SWT loads the AWT on a secondary thread,
263 // onMainThread here will be false but SWT mode will be true. If we are currently on the main thread, we don't
264 // need to throw AWT startup over to another thread.
265 BOOL onMainThread = (pthread_main_np() != 0);
266
267 if (verbose) {
268 NSString *msg = [NSString stringWithFormat:@"+[AWTStarter start headless:%d] { onMainThread:%d }", headless, onMainThread];
269 AWT_DEBUG_LOG(msg);
270 }
271
272 if (!headless)
273 {
274 // Listen for the NSApp to start. This indicates that JNI_OnLoad can proceed.
275 // It must wait because there is a chance that another java thread will grab
276 // the AppKit lock before the +[NSApplication sharedApplication] returns.
277 // See <rdar://problem/3492666> for an example.
278 [[NSNotificationCenter defaultCenter] addObserver:[AWTStarter class]
279 selector:@selector(appKitIsRunning:)
280 name:NSApplicationDidFinishLaunchingNotification
281 object:nil];
282
283 if (verbose) NSLog(@"+[AWTStarter start:::]: registered NSApplicationDidFinishLaunchingNotification");
284 }
285
286 id st = [[AWTStarter alloc] init];
287
288 NSArray * args = [NSArray arrayWithObjects:
289 [NSNumber numberWithBool: onMainThread],
290 [NSNumber numberWithBool: headless],
291 [NSNumber numberWithBool: verbose],
292 nil];
293
294 if (onMainThread) {
295 [st starter:args];
296 } else {
297 [st performSelectorOnMainThread: @selector(starter:) withObject:args waitUntilDone:NO];
298 }
299
300 if (!headless && !onMainThread) {
301 if (verbose) AWT_DEBUG_LOG(@"about to wait on AppKit startup mutex");
302
303 // Wait here for AppKit to have started (or for AWT to have been loaded into
304 // an already running NSApplication).
305 pthread_mutex_lock(&sAppKitStarted_mutex);
306 while (sAppKitStarted == NO) {
307 pthread_cond_wait(&sAppKitStarted_cv, &sAppKitStarted_mutex);
308 }
309 pthread_mutex_unlock(&sAppKitStarted_mutex);
310
311 // AWT gets here AFTER +[AWTStarter appKitIsRunning:] is called.
312 if (verbose) AWT_DEBUG_LOG(@"got out of the AppKit startup mutex");
313 }
314
315 if (!headless) {
316 // Don't set the delegate until the NSApplication has been created and
317 // its finishLaunching has initialized it.
318 // ApplicationDelegate is the support code for com.apple.eawt.
319 [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
320 id<NSApplicationDelegate> delegate = [ApplicationDelegate sharedDelegate];
321 if (delegate != nil) {
322 OSXAPP_SetApplicationDelegate(delegate);
323 }
324 }];
325 }
326 }
327
328 - (void)starter:(NSArray*)args {
329 NSAutoreleasePool *pool = [NSAutoreleasePool new];
330
331 BOOL onMainThread = [[args objectAtIndex:0] boolValue];
332 BOOL headless = [[args objectAtIndex:1] boolValue];
333 BOOL verbose = [[args objectAtIndex:2] boolValue];
334
335 BOOL wasOnMainThread = onMainThread;
336
337 // Add the exception handler of last resort
338 NSSetUncaughtExceptionHandler(AWT_NSUncaughtExceptionHandler);
339
340 // Headless mode trumps either ordinary AWT or SWT-in-AWT mode. Declare us a daemon and return.
341 if (headless) {
342 // Note that we don't install run loop observers in headless mode
343 // because we don't need them (see 7174704)
344 if (!forceEmbeddedMode) {
345 setUpAppKitThreadName();
346 }
347 [AWTStarter markAppAsDaemon];
348 return;
349 }
350
351 if (forceEmbeddedMode) {
352 if (verbose) NSLog(@"in SWT or SWT/WebStart mode");
353
354 // Init a default NSApplication instance instead of the NSApplicationAWT.
355 // Note that [NSApp isRunning] will return YES after that, though
356 // this behavior isn't specified anywhere. We rely on that.
357 NSApplicationLoad();
358 }
359
360 // This will create a NSApplicationAWT for standalone AWT programs, unless there is
361 // already a NSApplication instance. If there is already a NSApplication instance,
362 // and -[NSApplication isRunning] returns YES, AWT is embedded inside another
363 // AppKit Application.
364 NSApplication *app = [NSApplicationAWT sharedApplication];
365 isEmbedded = ![NSApp isKindOfClass:[NSApplicationAWT class]];
366 [ThreadUtilities setAWTEmbedded:isEmbedded];
367
368 if (!isEmbedded) {
369 // Install run loop observers and set the AppKit Java thread name
370 setUpAWTAppKit();
371 setUpAppKitThreadName();
372 }
373
374 // AWT gets to this point BEFORE NSApplicationDidFinishLaunchingNotification is sent.
375 if (![app isRunning]) {
376 if (verbose) AWT_DEBUG_LOG(@"+[AWTStarter startAWT]: ![app isRunning]");
377
378 // This is where the AWT AppKit thread parks itself to process events.
379 [NSApplicationAWT runAWTLoopWithApp: app];
380 } else {
381 // We're either embedded, or showing a splash screen
382 if (isEmbedded) {
383 if (verbose) AWT_DEBUG_LOG(@"running embedded");
384
385 // We don't track if the runloop is busy, so set it free to let AWT finish when it needs
386 setBusy(NO);
387 } else {
388 if (verbose) AWT_DEBUG_LOG(@"running after showing a splash screen");
389 }
390
391 // Signal so that JNI_OnLoad can proceed.
392 if (!wasOnMainThread) [AWTStarter appKitIsRunning:nil];
393
394 // Proceed to exit this call as there is no reason to run the NSApplication event loop.
395 }
396
397 [pool drain];
398 }
399
400 @end
401
402
403 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
404 BOOL verbose = ShouldPrintVerboseDebugging();
405 if (verbose) AWT_DEBUG_LOG(@"entered JNI_OnLoad");
406
407 // Headless: BOTH
408 // Embedded: BOTH
409 // Multiple Calls: NO
410 // Caller: JavaVM classloader
411
412 // Keep a static reference for other archives.
413 OSXAPP_SetJavaVM(vm);
414
415 JNIEnv *env = NULL;
416
417 // Need JNIEnv for JNF_COCOA_ENTER(env); macro below
418 jint status = (*jvm)->GetEnv(jvm, (void **)&env, JNI_VERSION_1_4);
419 if (status != JNI_OK || env == NULL) {
420 AWT_DEBUG_LOG(@"Can't get JNIEnv");
421 return JNI_VERSION_1_4;
422 }
423
424 JNF_COCOA_ENTER(env);
425
426 // Launcher sets this env variable if -XstartOnFirstThread is specified
427 char envVar[80];
428 snprintf(envVar, sizeof(envVar), "JAVA_STARTED_ON_FIRST_THREAD_%d", getpid());
429 if (getenv(envVar) != NULL) {
430 forceEmbeddedMode = YES;
431 unsetenv(envVar);
432 }
433
434 if (isSWTInWebStart(env)) {
435 forceEmbeddedMode = YES;
436 }
437 JNIEnv* env = [ThreadUtilities getJNIEnvUncached];
438 jclass jc_ThreadGroupUtils = (*env)->FindClass(env, "sun/awt/util/ThreadGroupUtils");
439 jmethodID sjm_getRootThreadGroup = (*env)->GetStaticMethodID(env, jc_ThreadGroupUtils, "getRootThreadGroup", "()Ljava/lang/ThreadGroup;");
440 jobject rootThreadGroup = (*env)->CallStaticObjectMethod(env, jc_ThreadGroupUtils, sjm_getRootThreadGroup);
441 [ThreadUtilities setAppkitThreadGroup:(*env)->NewGlobalRef(env, rootThreadGroup)];
442 // The current thread was attached in getJNIEnvUnchached.
443 // Detach it back. It will be reattached later if needed with a proper TG
444 [ThreadUtilities detachCurrentThread];
445
446 BOOL headless = isHeadless(env);
447
448 // We need to let Foundation know that this is a multithreaded application, if it isn't already.
449 if (![NSThread isMultiThreaded]) {
450 [NSThread detachNewThreadSelector:nil toTarget:nil withObject:nil];
451 }
452
453 [AWTStarter start:headless];
454
455 JNF_COCOA_EXIT(env);
456
457 if (verbose) AWT_DEBUG_LOG(@"exiting JNI_OnLoad");
458
459 return JNI_VERSION_1_4;
460 }