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/misc/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 }