/** * Copyright (C) 2007 Aelitis, All Rights Reserved. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * AELITIS, SAS au capital de 63.529,40 euros * 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France. * */ package com.aelitis.azureus.launcher; import java.lang.reflect.Method; import java.net.URL; import com.aelitis.azureus.launcher.classloading.*; /** * This will (hopefully) become a unified launching pathway covering everything * from the bare core over UIs to Launchable Plugins in the future * * @author Aaron Grunthal * @create 28.12.2007 */ public class Launcher { private final static boolean LOADER_ENABLED = false; /** * Bootstraps a new {@link PrimaryClassloader} from the system class loader, * creates a new thread, instantiates MainClass and invokes its main method * with the provided arguments. * * * @param MainClass * class implementing the main() method which will be invoked * @param args * arguments to the main method */ public static void launch(Class MainClass,String[] args) { ClassLoader primaryloader = PrimaryClassloader.getBootstrappedLoader(); try { Method mainWrapper = primaryloader.loadClass(MainExecutor.class.getName()).getDeclaredMethod("load", new Class[] {ClassLoader.class,String.class,String[].class}); mainWrapper.setAccessible(true); mainWrapper.invoke(null, new Object[] {primaryloader,MainClass.getName(),args}); } catch (Exception e) { System.err.println("Bootstrapping failed"); e.printStackTrace(); System.exit(1); } } /** * Checks if the current classloader is not part of the {@link PeeringClassloader} hierarchy and performs {@link #launch(Class, String[])} if so<br> * <br> * * This example shows how to implement a main class that ensures that it is * called through the primary class loader: <code><pre> * MyClass { * public static void main(String[] args) { * if(Launcher.checkAndLaunch(MyClass.class,args)) * return; * ... // normal main code * } * } * </pre></code> * * * @param MainClass * @param args * @return true if bootstrapping was necessary and the main method was * called through a new classloader, false otherwise */ public static boolean checkAndLaunch(Class MainClass,String[] args) { if(isBootStrapped()) return false; launch(MainClass, args); return true; } /** * * @return true if the current classloader is part of the {@link PeeringClassloader} hierarchy */ public static boolean isBootStrapped() { if(!LOADER_ENABLED || ClassLoaderWitness.class.getClassLoader() instanceof PeeringClassloader) return true; return false; } public static SecondaryClassLoader getComponentLoader(URL[] urls) { if(!isBootStrapped()) throw new IllegalStateException("Current Classloader is not part of the peering hierarchy!"); ClassLoader primary = ClassLoaderWitness.class.getClassLoader(); while(!(primary instanceof PrimaryClassloader)) primary = primary.getParent(); return new SecondaryClassLoader(urls,(PrimaryClassloader)primary); } public static void main(String[] args) { // TODO unify commandline processing and GUI selection code here } }