< prev index next >

modules/javafx.graphics/src/main/java/com/sun/javafx/application/LauncherImpl.java

Print this page
rev 10897 : 8199357: Remove references to applets and Java Web Start from FX
Reviewed-by:
   1 /*
   2  * Copyright (c) 2010, 2017, 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


  70     public static final String LAUNCH_MODE_JAR = "LM_JAR";
  71 
  72     /**
  73      * When passed as launchMode to launchApplication, tells the method that
  74      * launchName is the name of the JavaFX application class within a module
  75      * to be launched. Either the class name will be provided or the main class
  76      * will be defined in the module's descriptor.
  77      */
  78     public static final String LAUNCH_MODE_MODULE = "LM_MODULE";
  79 
  80     // set to true to debug launch issues from Java launcher
  81     private static final boolean trace = false;
  82 
  83     // set system property javafx.verbose to true to make the launcher noisy
  84     private static final boolean verbose;
  85 
  86     private static final String MF_MAIN_CLASS = "Main-Class";
  87     private static final String MF_JAVAFX_MAIN = "JavaFX-Application-Class";
  88     private static final String MF_JAVAFX_PRELOADER = "JavaFX-Preloader-Class";
  89     private static final String MF_JAVAFX_CLASS_PATH = "JavaFX-Class-Path";
  90     private static final String MF_JAVAFX_FEATURE_PROXY = "JavaFX-Feature-Proxy";
  91     private static final String MF_JAVAFX_ARGUMENT_PREFIX = "JavaFX-Argument-";
  92     private static final String MF_JAVAFX_PARAMETER_NAME_PREFIX = "JavaFX-Parameter-Name-";
  93     private static final String MF_JAVAFX_PARAMETER_VALUE_PREFIX = "JavaFX-Parameter-Value-";
  94 
  95     // Set to true to simulate a slow download progress
  96     private static final boolean simulateSlowProgress = false;
  97 
  98     // Ensure that launchApplication method is only called once
  99     private static AtomicBoolean launchCalled = new AtomicBoolean(false);
 100 
 101     // Flag indicating that the toolkit has been started
 102     private static final AtomicBoolean toolkitStarted = new AtomicBoolean(false);
 103 
 104     // Exception found during launching
 105     private static volatile RuntimeException launchException = null;
 106 
 107     // The current preloader, used for notification in the standalone
 108     // launcher mode
 109     private static Preloader currentPreloader = null;
 110 


 229      * abort with an error.
 230      *
 231      * @param launchName The path to a jar file, the application class name to launch,
 232      * or the module and optional class name to launch
 233      * @param launchMode The method of launching the application, one of LM_JAR,
 234      * LM_CLASS, or LM_MODULE
 235      * @param args Application arguments from the command line
 236      */
 237     public static void launchApplication(final String launchName,
 238             final String launchMode,
 239             final String[] args) {
 240 
 241         if (verbose) {
 242             System.err.println("JavaFX launchApplication method: launchMode="
 243                     + launchMode);
 244         }
 245 
 246         /*
 247          * For now, just open the jar and get JavaFX-Application-Class and
 248          * JavaFX-Preloader and pass them to launchApplication. In the future
 249          * we'll need to load requested jar files and set up the proxy
 250          */
 251         String mainClassName = null;
 252         String preloaderClassName = null;
 253         String[] appArgs = args;
 254         ClassLoader appLoader = null;
 255         ModuleAccess mainModule = null;
 256 
 257         if (launchMode.equals(LAUNCH_MODE_JAR)) {
 258             Attributes jarAttrs = getJarAttributes(launchName);
 259             if (jarAttrs == null) {
 260                 abort(null, "Can't get manifest attributes from jar");
 261             }
 262 
 263             // If we ever need to check JavaFX-Version, do that here...
 264 
 265             // Support JavaFX-Class-Path, but warn that it's deprecated if used
 266             String fxClassPath = jarAttrs.getValue(MF_JAVAFX_CLASS_PATH);
 267             if (fxClassPath != null) {
 268                 if (fxClassPath.trim().length() == 0) {
 269                     fxClassPath = null;
 270                 } else {
 271                     if (verbose) {
 272                         System.err.println("WARNING: Application jar uses deprecated JavaFX-Class-Path attribute."
 273                                +" Please use Class-Path instead.");
 274                     }
 275 
 276                     /*
 277                      * create a new ClassLoader to pull in the requested jar files
 278                      * OK if it returns null, that just means we didn't need to load
 279                      * anything
 280                      */
 281                     appLoader = setupJavaFXClassLoader(new File(launchName), fxClassPath);
 282                 }
 283             }
 284 
 285             // Support JavaFX-Feature-Proxy (only supported setting is 'auto', anything else is ignored)
 286             String proxySetting = jarAttrs.getValue(MF_JAVAFX_FEATURE_PROXY);
 287             if (proxySetting != null && "auto".equals(proxySetting.toLowerCase())) {
 288                 trySetAutoProxy();
 289             }
 290 
 291             // process arguments and parameters if no args have been passed by the launcher
 292             if (args.length == 0) {
 293                 appArgs = getAppArguments(jarAttrs);
 294             }
 295 
 296             // grab JavaFX-Application-Class
 297             mainClassName = jarAttrs.getValue(MF_JAVAFX_MAIN);
 298             if (mainClassName == null) {
 299                 // fall back on Main-Class if no JAC
 300                 mainClassName = jarAttrs.getValue(MF_MAIN_CLASS);
 301                 if (mainClassName == null) {
 302                     // Should not happen as the launcher enforces the presence of Main-Class
 303                     abort(null, "JavaFX jar manifest requires a valid JavaFX-Appliation-Class or Main-Class entry");
 304                 }
 305             }
 306             mainClassName = mainClassName.trim();
 307 
 308             // grab JavaFX-Preloader-Class
 309             preloaderClassName = jarAttrs.getValue(MF_JAVAFX_PRELOADER);
 310             if (preloaderClassName != null) {


 564 
 565                 URL[] urls = (URL[])urlList.toArray(new URL[0]);
 566                 if (verbose) {
 567                     System.err.println("===== URL list");
 568                     for (int i = 0; i < urls.length; i++) {
 569                         System.err.println("" + urls[i]);
 570                     }
 571                     System.err.println("=====");
 572                 }
 573                 return new URLClassLoader(urls, ClassLoader.getPlatformClassLoader());
 574             }
 575         } catch (Exception ex) {
 576             if (trace) {
 577                 System.err.println("Exception creating JavaFX class loader: "+ex);
 578                 ex.printStackTrace();
 579             }
 580         }
 581         return null;
 582     }
 583 
 584     private static void trySetAutoProxy() {
 585         // if explicit proxy settings are proxided we will skip autoproxy
 586         // Note: we only check few most popular settings.
 587         if (System.getProperty("http.proxyHost") != null
 588              || System.getProperty("https.proxyHost") != null
 589              || System.getProperty("ftp.proxyHost") != null
 590              || System.getProperty("socksProxyHost") != null) {
 591            if (verbose) {
 592                System.out.println("Explicit proxy settings detected. Skip autoconfig.");
 593                System.out.println("  http.proxyHost=" + System.getProperty("http.proxyHost"));
 594                System.out.println("  https.proxyHost=" + System.getProperty("https.proxyHost"));
 595                System.out.println("  ftp.proxyHost=" + System.getProperty("ftp.proxyHost"));
 596                System.out.println("  socksProxyHost=" + System.getProperty("socksProxyHost"));
 597            }
 598            return;
 599         }
 600         if (System.getProperty("javafx.autoproxy.disable") != null) {
 601             if (verbose) {
 602                 System.out.println("Disable autoproxy on request.");
 603             }
 604             return;
 605         }
 606 
 607         try {
 608             Class sm = Class.forName("com.sun.deploy.services.ServiceManager");
 609             Class params[] = {Integer.TYPE};
 610             Method setservice = sm.getDeclaredMethod("setService", params);
 611             String osname = System.getProperty("os.name");
 612 
 613             String servicename;
 614             if (osname.startsWith("Win")) {
 615                 servicename = "STANDALONE_TIGER_WIN32";
 616             } else if (osname.contains("Mac")) {
 617                 servicename = "STANDALONE_TIGER_MACOSX";
 618             } else {
 619                 servicename = "STANDALONE_TIGER_UNIX";
 620             }
 621             Object values[] = new Object[1];
 622             Class pt = Class.forName("com.sun.deploy.services.PlatformType");
 623             values[0] = pt.getField(servicename).get(null);
 624             setservice.invoke(null, values);
 625 
 626             Class dps = Class.forName(
 627                     "com.sun.deploy.net.proxy.DeployProxySelector");
 628             Method m = dps.getDeclaredMethod("reset", new Class[0]);
 629             m.invoke(null, new Object[0]);
 630 
 631             if (verbose) {
 632                 System.out.println("Autoconfig of proxy is completed.");
 633             }
 634         } catch (Exception e) {
 635             if (verbose) {
 636                 System.err.println("Failed to autoconfig proxy due to "+e);
 637             }
 638             if (trace) {
 639                 e.printStackTrace();
 640             }
 641         }
 642     }
 643 
 644     private static String decodeBase64(String inp) throws IOException {
 645         return new String(Base64.getDecoder().decode(inp));
 646     }
 647 
 648     private static String[] getAppArguments(Attributes attrs) {
 649         List args = new LinkedList();
 650 
 651         try {
 652             int idx = 1;
 653             String argNamePrefix = MF_JAVAFX_ARGUMENT_PREFIX;
 654             while (attrs.getValue(argNamePrefix + idx) != null) {
 655                 args.add(decodeBase64(attrs.getValue(argNamePrefix + idx)));
 656                 idx++;
 657             }
 658 
 659             String paramNamePrefix = MF_JAVAFX_PARAMETER_NAME_PREFIX;
 660             String paramValuePrefix = MF_JAVAFX_PARAMETER_VALUE_PREFIX;
 661             idx = 1;
 662             while (attrs.getValue(paramNamePrefix + idx) != null) {
 663                 String k = decodeBase64(attrs.getValue(paramNamePrefix + idx));


 958                     }
 959                 } else if (initError != null) {
 960                     String msg = "Exception in Application init method";
 961                     if (!notifyError(msg, initError)) {
 962                         throw new RuntimeException(msg, initError);
 963                     }
 964                 } else if(startError != null) {
 965                     String msg = "Exception in Application start method";
 966                     if (!notifyError(msg, startError)) {
 967                         throw new RuntimeException(msg, startError);
 968                     }
 969                 } else if (stopError != null) {
 970                     String msg = "Exception in Application stop method";
 971                     if (!notifyError(msg, stopError)) {
 972                         throw new RuntimeException(msg, stopError);
 973                     }
 974                 }
 975             }
 976         } finally {
 977             PlatformImpl.removeListener(listener);
 978             // Workaround until RT-13281 is implemented
 979             // Don't call exit if we detect an error in javaws mode
 980 //            PlatformImpl.tkExit();
 981             final boolean isJavaws = System.getSecurityManager() != null;
 982             if (error && isJavaws) {
 983                 System.err.println("Workaround until RT-13281 is implemented: keep toolkit alive");
 984             } else {
 985                 PlatformImpl.tkExit();
 986             }
 987         }
 988     }
 989 
 990     private static void notifyStateChange(final Preloader preloader,
 991             final StateChangeNotification.Type type,
 992             final Application app) {
 993 
 994         PlatformImpl.runAndWait(() -> preloader.handleStateChangeNotification(
 995             new StateChangeNotification(type, app)));
 996     }
 997 
 998     private static void notifyProgress(final Preloader preloader, final double d) {
 999         PlatformImpl.runAndWait(() -> preloader.handleProgressNotification(
1000                 new Preloader.ProgressNotification(d)));
1001     }
1002 
1003     private static boolean notifyError(final String msg, final Throwable constructorError) {
1004         final AtomicBoolean result = new AtomicBoolean(false);
1005         PlatformImpl.runAndWait(() -> {
1006             if (currentPreloader != null) {
1007                 try {
1008                     ErrorNotification evt = new ErrorNotification(null, msg, constructorError);


1015         });
1016 
1017         return result.get();
1018     }
1019 
1020     private static void notifyCurrentPreloader(final PreloaderNotification pe) {
1021         PlatformImpl.runAndWait(() -> {
1022             if (currentPreloader != null) {
1023                 currentPreloader.handleApplicationNotification(pe);
1024             }
1025         });
1026     }
1027 
1028     private static Method notifyMethod = null;
1029 
1030     public static void notifyPreloader(Application app, final PreloaderNotification info) {
1031         if (launchCalled.get()) {
1032             // Standalone launcher mode
1033             notifyCurrentPreloader(info);
1034             return;
1035         }
1036 
1037         synchronized (LauncherImpl.class) {
1038             if (notifyMethod == null) {
1039                 final String fxPreloaderClassName =
1040                         "com.sun.deploy.uitoolkit.impl.fx.FXPreloader";
1041                 try {
1042                     Class fxPreloaderClass = Class.forName(fxPreloaderClassName);
1043                     notifyMethod = fxPreloaderClass.getMethod(
1044                             "notifyCurrentPreloader", PreloaderNotification.class);
1045                 } catch (Exception ex) {
1046                     ex.printStackTrace();
1047                     return;
1048                 }
1049             }
1050         }
1051 
1052         try {
1053             // Call using reflection: FXPreloader.notifyCurrentPreloader(pe)
1054             notifyMethod.invoke(null, info);
1055         } catch (Exception ex) {
1056             ex.printStackTrace();
1057         }
1058     }
1059 
1060     // Not an instantiable class.
1061     private LauncherImpl() {
1062         // Should never get here.
1063         throw new InternalError();
1064     }
1065 
1066 }
   1 /*
   2  * Copyright (c) 2010, 2018, 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


  70     public static final String LAUNCH_MODE_JAR = "LM_JAR";
  71 
  72     /**
  73      * When passed as launchMode to launchApplication, tells the method that
  74      * launchName is the name of the JavaFX application class within a module
  75      * to be launched. Either the class name will be provided or the main class
  76      * will be defined in the module's descriptor.
  77      */
  78     public static final String LAUNCH_MODE_MODULE = "LM_MODULE";
  79 
  80     // set to true to debug launch issues from Java launcher
  81     private static final boolean trace = false;
  82 
  83     // set system property javafx.verbose to true to make the launcher noisy
  84     private static final boolean verbose;
  85 
  86     private static final String MF_MAIN_CLASS = "Main-Class";
  87     private static final String MF_JAVAFX_MAIN = "JavaFX-Application-Class";
  88     private static final String MF_JAVAFX_PRELOADER = "JavaFX-Preloader-Class";
  89     private static final String MF_JAVAFX_CLASS_PATH = "JavaFX-Class-Path";

  90     private static final String MF_JAVAFX_ARGUMENT_PREFIX = "JavaFX-Argument-";
  91     private static final String MF_JAVAFX_PARAMETER_NAME_PREFIX = "JavaFX-Parameter-Name-";
  92     private static final String MF_JAVAFX_PARAMETER_VALUE_PREFIX = "JavaFX-Parameter-Value-";
  93 
  94     // Set to true to simulate a slow download progress
  95     private static final boolean simulateSlowProgress = false;
  96 
  97     // Ensure that launchApplication method is only called once
  98     private static AtomicBoolean launchCalled = new AtomicBoolean(false);
  99 
 100     // Flag indicating that the toolkit has been started
 101     private static final AtomicBoolean toolkitStarted = new AtomicBoolean(false);
 102 
 103     // Exception found during launching
 104     private static volatile RuntimeException launchException = null;
 105 
 106     // The current preloader, used for notification in the standalone
 107     // launcher mode
 108     private static Preloader currentPreloader = null;
 109 


 228      * abort with an error.
 229      *
 230      * @param launchName The path to a jar file, the application class name to launch,
 231      * or the module and optional class name to launch
 232      * @param launchMode The method of launching the application, one of LM_JAR,
 233      * LM_CLASS, or LM_MODULE
 234      * @param args Application arguments from the command line
 235      */
 236     public static void launchApplication(final String launchName,
 237             final String launchMode,
 238             final String[] args) {
 239 
 240         if (verbose) {
 241             System.err.println("JavaFX launchApplication method: launchMode="
 242                     + launchMode);
 243         }
 244 
 245         /*
 246          * For now, just open the jar and get JavaFX-Application-Class and
 247          * JavaFX-Preloader and pass them to launchApplication. In the future
 248          * we'll need to load requested jar files
 249          */
 250         String mainClassName = null;
 251         String preloaderClassName = null;
 252         String[] appArgs = args;
 253         ClassLoader appLoader = null;
 254         ModuleAccess mainModule = null;
 255 
 256         if (launchMode.equals(LAUNCH_MODE_JAR)) {
 257             Attributes jarAttrs = getJarAttributes(launchName);
 258             if (jarAttrs == null) {
 259                 abort(null, "Can't get manifest attributes from jar");
 260             }
 261 
 262             // If we ever need to check JavaFX-Version, do that here...
 263 
 264             // Support JavaFX-Class-Path, but warn that it's deprecated if used
 265             String fxClassPath = jarAttrs.getValue(MF_JAVAFX_CLASS_PATH);
 266             if (fxClassPath != null) {
 267                 if (fxClassPath.trim().length() == 0) {
 268                     fxClassPath = null;
 269                 } else {
 270                     if (verbose) {
 271                         System.err.println("WARNING: Application jar uses deprecated JavaFX-Class-Path attribute."
 272                                +" Please use Class-Path instead.");
 273                     }
 274 
 275                     /*
 276                      * create a new ClassLoader to pull in the requested jar files
 277                      * OK if it returns null, that just means we didn't need to load
 278                      * anything
 279                      */
 280                     appLoader = setupJavaFXClassLoader(new File(launchName), fxClassPath);
 281                 }
 282             }
 283 






 284             // process arguments and parameters if no args have been passed by the launcher
 285             if (args.length == 0) {
 286                 appArgs = getAppArguments(jarAttrs);
 287             }
 288 
 289             // grab JavaFX-Application-Class
 290             mainClassName = jarAttrs.getValue(MF_JAVAFX_MAIN);
 291             if (mainClassName == null) {
 292                 // fall back on Main-Class if no JAC
 293                 mainClassName = jarAttrs.getValue(MF_MAIN_CLASS);
 294                 if (mainClassName == null) {
 295                     // Should not happen as the launcher enforces the presence of Main-Class
 296                     abort(null, "JavaFX jar manifest requires a valid JavaFX-Appliation-Class or Main-Class entry");
 297                 }
 298             }
 299             mainClassName = mainClassName.trim();
 300 
 301             // grab JavaFX-Preloader-Class
 302             preloaderClassName = jarAttrs.getValue(MF_JAVAFX_PRELOADER);
 303             if (preloaderClassName != null) {


 557 
 558                 URL[] urls = (URL[])urlList.toArray(new URL[0]);
 559                 if (verbose) {
 560                     System.err.println("===== URL list");
 561                     for (int i = 0; i < urls.length; i++) {
 562                         System.err.println("" + urls[i]);
 563                     }
 564                     System.err.println("=====");
 565                 }
 566                 return new URLClassLoader(urls, ClassLoader.getPlatformClassLoader());
 567             }
 568         } catch (Exception ex) {
 569             if (trace) {
 570                 System.err.println("Exception creating JavaFX class loader: "+ex);
 571                 ex.printStackTrace();
 572             }
 573         }
 574         return null;
 575     }
 576 




























































 577     private static String decodeBase64(String inp) throws IOException {
 578         return new String(Base64.getDecoder().decode(inp));
 579     }
 580 
 581     private static String[] getAppArguments(Attributes attrs) {
 582         List args = new LinkedList();
 583 
 584         try {
 585             int idx = 1;
 586             String argNamePrefix = MF_JAVAFX_ARGUMENT_PREFIX;
 587             while (attrs.getValue(argNamePrefix + idx) != null) {
 588                 args.add(decodeBase64(attrs.getValue(argNamePrefix + idx)));
 589                 idx++;
 590             }
 591 
 592             String paramNamePrefix = MF_JAVAFX_PARAMETER_NAME_PREFIX;
 593             String paramValuePrefix = MF_JAVAFX_PARAMETER_VALUE_PREFIX;
 594             idx = 1;
 595             while (attrs.getValue(paramNamePrefix + idx) != null) {
 596                 String k = decodeBase64(attrs.getValue(paramNamePrefix + idx));


 891                     }
 892                 } else if (initError != null) {
 893                     String msg = "Exception in Application init method";
 894                     if (!notifyError(msg, initError)) {
 895                         throw new RuntimeException(msg, initError);
 896                     }
 897                 } else if(startError != null) {
 898                     String msg = "Exception in Application start method";
 899                     if (!notifyError(msg, startError)) {
 900                         throw new RuntimeException(msg, startError);
 901                     }
 902                 } else if (stopError != null) {
 903                     String msg = "Exception in Application stop method";
 904                     if (!notifyError(msg, stopError)) {
 905                         throw new RuntimeException(msg, stopError);
 906                     }
 907                 }
 908             }
 909         } finally {
 910             PlatformImpl.removeListener(listener);







 911             PlatformImpl.tkExit();
 912         }
 913     }

 914 
 915     private static void notifyStateChange(final Preloader preloader,
 916             final StateChangeNotification.Type type,
 917             final Application app) {
 918 
 919         PlatformImpl.runAndWait(() -> preloader.handleStateChangeNotification(
 920             new StateChangeNotification(type, app)));
 921     }
 922 
 923     private static void notifyProgress(final Preloader preloader, final double d) {
 924         PlatformImpl.runAndWait(() -> preloader.handleProgressNotification(
 925                 new Preloader.ProgressNotification(d)));
 926     }
 927 
 928     private static boolean notifyError(final String msg, final Throwable constructorError) {
 929         final AtomicBoolean result = new AtomicBoolean(false);
 930         PlatformImpl.runAndWait(() -> {
 931             if (currentPreloader != null) {
 932                 try {
 933                     ErrorNotification evt = new ErrorNotification(null, msg, constructorError);


 940         });
 941 
 942         return result.get();
 943     }
 944 
 945     private static void notifyCurrentPreloader(final PreloaderNotification pe) {
 946         PlatformImpl.runAndWait(() -> {
 947             if (currentPreloader != null) {
 948                 currentPreloader.handleApplicationNotification(pe);
 949             }
 950         });
 951     }
 952 
 953     private static Method notifyMethod = null;
 954 
 955     public static void notifyPreloader(Application app, final PreloaderNotification info) {
 956         if (launchCalled.get()) {
 957             // Standalone launcher mode
 958             notifyCurrentPreloader(info);
 959             return;






















 960         }
 961     }
 962 
 963     // Not an instantiable class.
 964     private LauncherImpl() {
 965         // Should never get here.
 966         throw new InternalError();
 967     }
 968 
 969 }
< prev index next >