diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/java/jogamp/android/launcher/ActivityLauncher.java | 231 | ||||
| -rw-r--r-- | src/java/jogamp/android/launcher/ClassLoaderUtil.java | 193 | ||||
| -rw-r--r-- | src/java/jogamp/android/launcher/LauncherMain.java | 63 | ||||
| -rw-r--r-- | src/java/jogamp/android/launcher/LauncherTempFileCache.java | 477 | ||||
| -rw-r--r-- | src/java/jogamp/android/launcher/LauncherUtil.java | 320 |
5 files changed, 1284 insertions, 0 deletions
diff --git a/src/java/jogamp/android/launcher/ActivityLauncher.java b/src/java/jogamp/android/launcher/ActivityLauncher.java new file mode 100644 index 0000000..04c898e --- /dev/null +++ b/src/java/jogamp/android/launcher/ActivityLauncher.java @@ -0,0 +1,231 @@ +/** + * Copyright 2011 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ +package jogamp.android.launcher; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import android.app.Activity; +import android.content.Context; +import android.net.Uri; +import android.os.Bundle; +import android.widget.TextView; +import android.util.Log; + +public class ActivityLauncher extends Activity { + static final String TAG = "NEWTLauncherActivity"; + TextView tv = null; + Method mOnCreate, mOnDestroy, mOnPause, mOnRestart, mOnResume, + mOnStart, mOnStop, mSetIsInvokedByExternalActivity; + Class<?> activityClazz = null; + Object activityObject = null; + + @Override + public void onCreate(Bundle savedInstanceState) { + Log.d(TAG, "onCreate - S"); + super.onCreate(savedInstanceState); + + final Uri uri = getIntent().getData(); + final LauncherUtil.DataSet data = LauncherUtil.DataSet.create(uri); + data.setSystemProperties(); + + ClassLoader cl = ClassLoaderUtil.createJogampClassLoaderSingleton(this, data.getPackages()); + if(null != cl) { + try { + activityClazz = Class.forName(data.getActivityName(), true, cl); + Log.d(TAG, "Activity Clazz "+activityClazz); + activityObject = createInstance(activityClazz, null); + Log.d(TAG, "Activity Object "+activityObject); + mOnCreate = activityClazz.getMethod("onCreate", Bundle.class); + mOnDestroy = activityClazz.getMethod("onDestroy"); + mOnPause = activityClazz.getMethod("onPause"); + mOnRestart = activityClazz.getMethod("onRestart"); + mOnResume = activityClazz.getMethod("onResume"); + mOnStart = activityClazz.getMethod("onStart"); + mOnStop = activityClazz.getMethod("onStop"); + mSetIsInvokedByExternalActivity = activityClazz.getMethod("setIsInvokedByExternalActivity", Activity.class); + } catch (Exception e) { + Log.d(TAG, "error: "+e, e); + throw new RuntimeException(e); + } + } + + if( null == mOnCreate || null == mOnDestroy || null == mOnPause || + null == mOnRestart || null == mOnResume || + null == mSetIsInvokedByExternalActivity ) { + RuntimeException e = new RuntimeException("XXX - incomplete method set"); + Log.d(TAG, "error: "+e, e); + throw e; + } + + callMethod(activityObject, mSetIsInvokedByExternalActivity, this); + + callMethod(activityObject, mOnCreate, savedInstanceState); + Log.d(TAG, "onCreate - X"); + } + + @Override + public void onStart() { + Log.d(TAG, "onStart - S"); + callMethod(activityObject, mOnStart); + super.onStart(); + Log.d(TAG, "onStart - X"); + } + + @Override + public void onRestart() { + Log.d(TAG, "onRestart - S"); + callMethod(activityObject, mOnRestart); + super.onRestart(); + Log.d(TAG, "onRestart - X"); + } + + @Override + public void onResume() { + Log.d(TAG, "onResume - S"); + callMethod(activityObject, mOnResume); + super.onResume(); + Log.d(TAG, "onResume - X"); + } + + @Override + public void onPause() { + Log.d(TAG, "onPause - S"); + callMethod(activityObject, mOnPause); + super.onPause(); + Log.d(TAG, "onPause - X"); + } + + @Override + public void onStop() { + Log.d(TAG, "onStop - S"); + callMethod(activityObject, mOnStop); + super.onStop(); + Log.d(TAG, "onStop - X"); + } + + @Override + public void onDestroy() { + Log.d(TAG, "onDestroy - S"); + callMethod(activityObject, mOnDestroy); + super.onDestroy(); + finish(); + Log.d(TAG, "onDestroy - X"); + } + + @Override + public void finish() { + Log.d(TAG, "finish - S"); + super.finish(); + Log.d(TAG, "finish - X"); + } + + /** + * @throws JogampRuntimeException if the instance can not be created. + */ + public static final Object createInstance(Class<?> clazz, Class<?>[] cstrArgTypes, Object ... cstrArgs) + throws RuntimeException + { + return createInstance(getConstructor(clazz, cstrArgTypes), cstrArgs); + } + + public static final Object createInstance(Constructor<?> cstr, Object ... cstrArgs) + throws RuntimeException + { + try { + return cstr.newInstance(cstrArgs); + } catch (Exception e) { + Throwable t = e; + if (t instanceof InvocationTargetException) { + t = ((InvocationTargetException) t).getTargetException(); + } + if (t instanceof Error) { + throw (Error) t; + } + if (t instanceof RuntimeException) { + throw (RuntimeException) t; + } + throw new RuntimeException("can not create instance of "+cstr.getName(), t); + } + } + + /** + * @throws JogampRuntimeException if the constructor can not be delivered. + */ + protected static final Constructor<?> getConstructor(Class<?> clazz, Class<?> ... cstrArgTypes) + throws RuntimeException { + try { + if(null == cstrArgTypes) { + cstrArgTypes = zeroTypes; + } + return clazz.getDeclaredConstructor(cstrArgTypes); + } catch (NoSuchMethodException ex) { + throw new RuntimeException("Constructor: '" + clazz + "(" + asString(cstrArgTypes) + ")' not found", ex); + } + } + + protected static final Class<?>[] zeroTypes = new Class[0]; + + protected static final String asString(Class<?>[] argTypes) { + StringBuffer args = new StringBuffer(); + boolean coma = false; + if(null != argTypes) { + for (int i = 0; i < argTypes.length; i++) { + if(coma) { + args.append(", "); + } + args.append(argTypes[i].getName()); + coma = true; + } + } + return args.toString(); + } + + protected static final Object callMethod(Object instance, Method method, Object ... args) + throws RuntimeException + { + try { + return method.invoke(instance, args); + } catch (Exception e) { + Throwable t = e; + if (t instanceof InvocationTargetException) { + t = ((InvocationTargetException) t).getTargetException(); + } + if (t instanceof Error) { + throw (Error) t; + } + if (t instanceof RuntimeException) { + throw (RuntimeException) t; + } + throw new RuntimeException("calling "+method+" failed", t); + } + } + + +} diff --git a/src/java/jogamp/android/launcher/ClassLoaderUtil.java b/src/java/jogamp/android/launcher/ClassLoaderUtil.java new file mode 100644 index 0000000..319a0fd --- /dev/null +++ b/src/java/jogamp/android/launcher/ClassLoaderUtil.java @@ -0,0 +1,193 @@ +/** + * Copyright 2011 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ + +package jogamp.android.launcher; + +import java.io.File; +import java.lang.ref.WeakReference; +import java.lang.reflect.Field; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; + +import android.app.Activity; +import android.content.Context; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageManager; +import android.util.Log; +import dalvik.system.DexClassLoader; + +public class ClassLoaderUtil { + private static final String TAG = "JogampClassLoader"; + + public static final String packageGlueGen = "com.jogamp.common"; + public static final String packageJogl = "javax.media.opengl"; // FIXME: a 'performance' hack + + public static final String dexPathName= "jogampDex"; + + private static LauncherTempFileCache tmpFileCache = null; + private static ClassLoader jogAmpClassLoader = null; + + /** + * + * @param ctx + * @param userPackageNames list of user package names, the last entry shall reflect the Activity + * @return + */ + public static synchronized ClassLoader createJogampClassLoaderSingleton(Context ctx, List<String> userPackageNames) { + if(null==jogAmpClassLoader) { + if(null!=tmpFileCache) { + throw new InternalError("XXX0"); + } + if(!LauncherTempFileCache.initSingleton(ctx)) { + throw new InternalError("TempFileCache initialization error"); + } + tmpFileCache = new LauncherTempFileCache(); + if(!tmpFileCache.isValid()) { + throw new InternalError("TempFileCache instantiation error"); + } + final ApplicationInfo ai = ctx.getApplicationInfo(); + Log.d(TAG, "S: userPackageName: "+userPackageNames+", dataDir: "+ai.dataDir+", nativeLibraryDir: "+ai.nativeLibraryDir); + + final String appDir = new File(ai.dataDir).getParent(); + final String libSub = ai.nativeLibraryDir.substring(ai.nativeLibraryDir.lastIndexOf('/')+1); + Log.d(TAG, "S: appDir: "+appDir+", libSub: "+libSub); + + final String libPathName = appDir + "/" + packageGlueGen + "/" + libSub + "/:" + + appDir + "/" + packageJogl + "/" + libSub + "/" ; + Log.d(TAG, "S: libPath: "+libPathName); + + String apkGlueGen = null; + String apkJogl = null; + + try { + apkGlueGen = ctx.getPackageManager().getApplicationInfo(packageGlueGen,0).sourceDir; + apkJogl = ctx.getPackageManager().getApplicationInfo(packageJogl,0).sourceDir; + } catch (PackageManager.NameNotFoundException e) { + Log.d(TAG, "error: "+e, e); + } + if(null == apkGlueGen || null == apkJogl) { + Log.d(TAG, "not found: gluegen <"+apkGlueGen+">, jogl <"+apkJogl+">"); + return null; + } + + final String cp = apkGlueGen + ":" + apkJogl ; + Log.d(TAG, "jogamp cp: " + cp); + + final File dexPath = new File(tmpFileCache.getTempDir(), dexPathName); + Log.d(TAG, "jogamp dexPath: " + dexPath.getAbsolutePath()); + dexPath.mkdir(); + jogAmpClassLoader = new DexClassLoader(cp, dexPath.getAbsolutePath(), libPathName, ctx.getClassLoader()); + } else { + if(null==tmpFileCache) { + throw new InternalError("XXX1"); + } + } + + StringBuilder userAPKs = new StringBuilder(); + int numUserAPKs = 0; + String lastUserPackageName = null; // the very last one reflects the Activity + for(Iterator<String> i=userPackageNames.iterator(); i.hasNext(); ) { + lastUserPackageName = i.next(); + String userAPK = null; + try { + userAPK = ctx.getPackageManager().getApplicationInfo(lastUserPackageName,0).sourceDir; + } catch (PackageManager.NameNotFoundException e) { + Log.d(TAG, "error: "+e, e); + } + if(null != userAPK) { + numUserAPKs++; + if(numUserAPKs>0) { + userAPKs.append(":"); + } + userAPKs.append(userAPK); + Log.d(TAG, "APK found: <"+lastUserPackageName+"> -> <"+userAPK+">"); + } else { + Log.d(TAG, "APK not found: <"+lastUserPackageName+">"); + } + } + if( userPackageNames.size()!=numUserAPKs ) { + Log.d(TAG, "APKs incomplete, abort"); + return null; + } + + final String userAPKs_s = userAPKs.toString(); + Log.d(TAG, "user cp: " + userAPKs_s); + final File dexPath = new File(tmpFileCache.getTempDir(), lastUserPackageName); + Log.d(TAG, "user dexPath: " + dexPath.getAbsolutePath()); + dexPath.mkdir(); + ClassLoader cl = new DexClassLoader(userAPKs_s, dexPath.getAbsolutePath(), null, jogAmpClassLoader); + Log.d(TAG, "cl: " + cl); + + return cl; + } + + public boolean setAPKClassLoader(String activityPackageName, ClassLoader classLoader) + { + try { + Field mMainThread = getField(Activity.class, "mMainThread"); + Object mainThread = mMainThread.get(this); + Class<?> threadClass = mainThread.getClass(); + Field mPackages = getField(threadClass, "mPackages"); + + @SuppressWarnings("unchecked") + HashMap<String,?> map = (HashMap<String,?>) mPackages.get(mainThread); + WeakReference<?> ref = (WeakReference<?>) map.get(activityPackageName); + Object apk = ref.get(); + Class<?> apkClass = apk.getClass(); + Field mClassLoader = getField(apkClass, "mClassLoader"); + + mClassLoader.set(apk, classLoader); + + Log.d(TAG, "setAPKClassLoader: OK"); + + return true; + } catch (IllegalArgumentException e) { + e.printStackTrace(); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + Log.d(TAG, "setAPKClassLoader: FAILED"); + return false; + } + + private Field getField(Class<?> cls, String name) + { + for (Field field: cls.getDeclaredFields()) + { + if (!field.isAccessible()) { + field.setAccessible(true); + } + if (field.getName().equals(name)) { + return field; + } + } + return null; + } + +} diff --git a/src/java/jogamp/android/launcher/LauncherMain.java b/src/java/jogamp/android/launcher/LauncherMain.java new file mode 100644 index 0000000..bbdee1d --- /dev/null +++ b/src/java/jogamp/android/launcher/LauncherMain.java @@ -0,0 +1,63 @@ +/** + * Copyright 2011 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ +package jogamp.android.launcher; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import android.app.ActivityGroup; +import android.content.Intent; +import android.os.Looper; +import android.util.Log; + +public class LauncherMain { + static final String TAG = "NEWTLauncherMain"; + + static String userActivityName = null; + static ArrayList<String> userPackageNames = new ArrayList<String>(); + static boolean setAPKClasspath = false; + + public static String getUserActivityName() { return userActivityName; } + public static List<String> getUserPackageNames() { return userPackageNames; } + + public static void main(String args[]) throws IOException, ClassNotFoundException { + userActivityName = "com.jogamp.opengl.test.android.NEWTGearsES2Activity"; + userPackageNames.add("com.jogamp.opengl.test"); + Looper.prepareMainLooper(); + ActivityGroup activityGroup = new ActivityGroup(true); + ClassLoader cl = ClassLoaderUtil.createJogampClassLoaderSingleton(activityGroup, getUserPackageNames()); + if(null != cl) { + Class<?> activityClazz = Class.forName(getUserActivityName(), true, cl); + Intent intent = new Intent(activityGroup, activityClazz); + Log.d(TAG, "Launching Activity: "+activityClazz+", "+intent); + android.view.Window activityWindow = activityGroup.getLocalActivityManager().startActivity ("ID001", intent); + // activityGroup.addContentView(view, params) + } + } +} diff --git a/src/java/jogamp/android/launcher/LauncherTempFileCache.java b/src/java/jogamp/android/launcher/LauncherTempFileCache.java new file mode 100644 index 0000000..06b8516 --- /dev/null +++ b/src/java/jogamp/android/launcher/LauncherTempFileCache.java @@ -0,0 +1,477 @@ +/** + * Copyright 2011 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ +package jogamp.android.launcher; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.FilenameFilter; +import java.io.IOException; +import java.nio.channels.FileChannel; +import java.nio.channels.FileLock; + +import android.content.Context; + +public class LauncherTempFileCache { + private static final boolean DEBUG = true; + + // Lifecycle: For all JVMs, ClassLoader and times. + private static final String tmpDirPrefix = "jogamp.tmp.cache"; + + // Get the value of the tmproot system property + // Lifecycle: For all JVMs and ClassLoader + /* package */ static final String tmpRootPropName = "jnlp.jogamp.tmp.cache.root"; + + // Flag indicating that we got a fatal error in the static initializer. + private static boolean staticInitError = false; + + private static File tmpBaseDir; + + // String representing the name of the temp root directory relative to the + // tmpBaseDir. Its value is "jlnNNNNN", which is the unique filename created + // by File.createTempFile() without the ".tmp" extension. + // + // Lifecycle: For all JVMs and ClassLoader + // + private static String tmpRootPropValue; + + private static File tmpRootDir; + + // Flag indicating that we got a fatal error in the initializer. + private boolean initError = false; + + private File individualTmpDir; + + /** + * Documented way to kick off static initialization + * @return true is static initialization was successful + */ + public static synchronized boolean initSingleton(Context ctx) { + if(null == tmpRootDir && !staticInitError) { + // Create / initialize the temp root directory, starting the Reaper + // thread to reclaim old installations if necessary. If we get an + // exception, set an error code. + try { + initTmpRoot(ctx); + } catch (Exception ex) { + ex.printStackTrace(); + staticInitError = true; + } + } + return !staticInitError; + } + + /** + * This method is called by the static initializer to create / initialize + * the temp root directory that will hold the temp directories for this + * instance of the JVM. This is done as follows: + * + * 1. Synchronize on a global lock. Note that for this purpose we will + * use System.out in the absence of a true global lock facility. + * We are careful not to hold this lock too long. + * + * 2. Check for the existence of the "jnlp.applet.launcher.tmproot" + * system property. + * + * a. If set, then some other thread in a different ClassLoader has + * already created the tmprootdir, so we just need to + * use it. The remaining steps are skipped. + * + * b. If not set, then we are the first thread in this JVM to run, + * and we need to create the the tmprootdir. + * + * 3. Create the tmprootdir, along with the appropriate locks. + * Note that we perform the operations in the following order, + * prior to creating tmprootdir itself, to work around the fact that + * the file creation and file lock steps are not atomic, and we need + * to ensure that a newly-created tmprootdir isn't reaped by a + * concurrently running JVM. + * + * create jlnNNNN.tmp using File.createTempFile() + * lock jlnNNNN.tmp + * create jlnNNNN.lck while holding the lock on the .tmp file + * lock jlnNNNN.lck + * + * Since the Reaper thread will enumerate the list of *.lck files + * before starting, we can guarantee that if there exists a *.lck file + * for an active process, then the corresponding *.tmp file is locked + * by that active process. This guarantee lets us avoid reaping an + * active process' files. + * + * 4. Set the "jnlp.applet.launcher.tmproot" system property. + * + * 5. Add a shutdown hook to cleanup jlnNNNN.lck and jlnNNNN.tmp. We + * don't actually expect that this shutdown hook will ever be called, + * but the act of doing this, ensures that the locks never get + * garbage-collected, which is necessary for correct behavior when + * the first ClassLoader is later unloaded, while subsequent Applets + * are still running. + * + * 6. Start the Reaper thread to cleanup old installations. + */ + private static void initTmpRoot(Context ctx) throws IOException { + if (DEBUG) { + System.err.println("TempFileCache: Static Initialization ----------------------------------------------"); + System.err.println("TempFileCache: Thread: "+Thread.currentThread().getName()+", CL 0x"+Integer.toHexString(LauncherTempFileCache.class.getClassLoader().hashCode())); + } + + synchronized (System.out) { + // Get the name of the tmpbase directory. + { + final File tmpRoot = ctx.getDir("temp", Context.MODE_WORLD_READABLE); + tmpBaseDir = new File(tmpRoot, tmpDirPrefix); + } + tmpRootPropValue = System.getProperty(tmpRootPropName); + + if (tmpRootPropValue == null) { + // Create the tmpbase directory if it doesn't already exist + tmpBaseDir.mkdir(); + if (!tmpBaseDir.isDirectory()) { + throw new IOException("Cannot create directory " + tmpBaseDir); + } + + // Create ${tmpbase}/jlnNNNN.tmp then lock the file + File tmpFile = File.createTempFile("jln", ".tmp", tmpBaseDir); + if (DEBUG) { + System.err.println("TempFileCache: tmpFile = " + tmpFile.getAbsolutePath()); + } + final FileOutputStream tmpOut = new FileOutputStream(tmpFile); + final FileChannel tmpChannel = tmpOut.getChannel(); + final FileLock tmpLock = tmpChannel.lock(); + + // Strip off the ".tmp" to get the name of the tmprootdir + String tmpFileName = tmpFile.getAbsolutePath(); + String tmpRootName = tmpFileName.substring(0, tmpFileName.lastIndexOf(".tmp")); + + // create ${tmpbase}/jlnNNNN.lck then lock the file + String lckFileName = tmpRootName + ".lck"; + File lckFile = new File(lckFileName); + if (DEBUG) { + System.err.println("TempFileCache: lckFile = " + lckFile.getAbsolutePath()); + } + lckFile.createNewFile(); + final FileOutputStream lckOut = new FileOutputStream(lckFile); + final FileChannel lckChannel = lckOut.getChannel(); + final FileLock lckLock = lckChannel.lock(); + + // Create tmprootdir + tmpRootDir = new File(tmpRootName); + if (DEBUG) { + System.err.println("TempFileCache: tmpRootDir = " + tmpRootDir.getAbsolutePath()); + } + if (!tmpRootDir.mkdir()) { + throw new IOException("Cannot create " + tmpRootDir); + } + + // Add shutdown hook to cleanup the OutputStream, FileChannel, + // and FileLock for the jlnNNNN.lck and jlnNNNN.lck files. + // We do this so that the locks never get garbage-collected. + Runtime.getRuntime().addShutdownHook(new Thread() { + /* @Override */ + public void run() { + // NOTE: we don't really expect that this code will ever + // be called. If it does, we will close the output + // stream, which will in turn close the channel. + // We will then release the lock. + try { + tmpOut.close(); + tmpLock.release(); + lckOut.close(); + lckLock.release(); + } catch (IOException ex) { + // Do nothing + } + } + }); + + // Set the system property... + tmpRootPropValue = tmpRootName.substring(tmpRootName.lastIndexOf(File.separator) + 1); + System.setProperty(tmpRootPropName, tmpRootPropValue); + if (DEBUG) { + System.err.println("TempFileCache: Setting " + tmpRootPropName + "=" + tmpRootPropValue); + } + + // Start a new Reaper thread to do stuff... + Thread reaperThread = new Thread() { + /* @Override */ + public void run() { + deleteOldTempDirs(); + } + }; + reaperThread.setName("TempFileCache-Reaper"); + reaperThread.start(); + } else { + // Make sure that the property is not set to an illegal value + if (tmpRootPropValue.indexOf('/') >= 0 || + tmpRootPropValue.indexOf(File.separatorChar) >= 0) { + throw new IOException("Illegal value of: " + tmpRootPropName); + } + + // Set tmpRootDir = ${tmpbase}/${jnlp.applet.launcher.tmproot} + if (DEBUG) { + System.err.println("TempFileCache: Using existing value of: " + + tmpRootPropName + "=" + tmpRootPropValue); + } + tmpRootDir = new File(tmpBaseDir, tmpRootPropValue); + if (DEBUG) { + System.err.println("TempFileCache: tmpRootDir = " + tmpRootDir.getAbsolutePath()); + } + if (!tmpRootDir.isDirectory()) { + throw new IOException("Cannot access " + tmpRootDir); + } + } + } + if (DEBUG) { + System.err.println("------------------------------------------------------------------ (static ok: "+(!staticInitError)+")"); + } + } + + /** + * Called by the Reaper thread to delete old temp directories + * Only one of these threads will run per JVM invocation. + */ + private static void deleteOldTempDirs() { + if (DEBUG) { + System.err.println("TempFileCache: *** Reaper: deleteOldTempDirs in " + + tmpBaseDir.getAbsolutePath()); + } + + // enumerate list of jnl*.lck files, ignore our own jlnNNNN file + final String ourLockFile = tmpRootPropValue + ".lck"; + FilenameFilter lckFilter = new FilenameFilter() { + /* @Override */ + public boolean accept(File dir, String name) { + return name.endsWith(".lck") && !name.equals(ourLockFile); + } + }; + + // For each file <file>.lck in the list we will first try to lock + // <file>.tmp if that succeeds then we will try to lock <file>.lck + // (which should always succeed unless there is a problem). If we can + // get the lock on both files, then it must be an old installation, and + // we will delete it. + String[] fileNames = tmpBaseDir.list(lckFilter); + if (fileNames != null) { + for (int i = 0; i < fileNames.length; i++) { + String lckFileName = fileNames[i]; + String tmpDirName = lckFileName.substring(0, lckFileName.lastIndexOf(".lck")); + String tmpFileName = tmpDirName + ".tmp"; + + File lckFile = new File(tmpBaseDir, lckFileName); + File tmpFile = new File(tmpBaseDir, tmpFileName); + File tmpDir = new File(tmpBaseDir, tmpDirName); + + if (lckFile.exists() && tmpFile.exists() && tmpDir.isDirectory()) { + FileOutputStream tmpOut = null; + FileChannel tmpChannel = null; + FileLock tmpLock = null; + + try { + tmpOut = new FileOutputStream(tmpFile); + tmpChannel = tmpOut.getChannel(); + tmpLock = tmpChannel.tryLock(); + } catch (Exception ex) { + // Ignore exceptions + if (DEBUG) { + ex.printStackTrace(); + } + } + + if (tmpLock != null) { + FileOutputStream lckOut = null; + FileChannel lckChannel = null; + FileLock lckLock = null; + + try { + lckOut = new FileOutputStream(lckFile); + lckChannel = lckOut.getChannel(); + lckLock = lckChannel.tryLock(); + } catch (Exception ex) { + if (DEBUG) { + ex.printStackTrace(); + } + } + + if (lckLock != null) { + // Recursively remove the old tmpDir and all of + // its contents + removeAll(tmpDir); + + // Close the streams and delete the .lck and .tmp + // files. Note that there is a slight race condition + // in that another process could open a stream at + // the same time we are trying to delete it, which will + // prevent deletion, but we won't worry about it, since + // the worst that will happen is we might have an + // occasional 0-byte .lck or .tmp file left around + try { + lckOut.close(); + } catch (IOException ex) { + } + lckFile.delete(); + try { + tmpOut.close(); + } catch (IOException ex) { + } + tmpFile.delete(); + } else { + try { + // Close the file and channel for the *.lck file + if (lckOut != null) { + lckOut.close(); + } + // Close the file/channel and release the lock + // on the *.tmp file + tmpOut.close(); + tmpLock.release(); + } catch (IOException ex) { + if (DEBUG) { + ex.printStackTrace(); + } + } + } + } + } else { + if (DEBUG) { + System.err.println("TempFileCache: Skipping: " + tmpDir.getAbsolutePath()); + } + } + } + } + } + + /** + * Remove the specified file or directory. If "path" is a directory, then + * recursively remove all entries, then remove the directory itself. + */ + private static void removeAll(File path) { + if (DEBUG) { + System.err.println("TempFileCache: removeAll(" + path + ")"); + } + + if (path.isDirectory()) { + // Recursively remove all files/directories in this directory + File[] list = path.listFiles(); + if (list != null) { + for (int i = 0; i < list.length; i++) { + removeAll(list[i]); + } + } + } + + path.delete(); + } + + public LauncherTempFileCache () { + if (DEBUG) { + System.err.println("TempFileCache: new TempFileCache() --------------------- (static ok: "+(!staticInitError)+")"); + System.err.println("TempFileCache: Thread: "+Thread.currentThread().getName()+", CL 0x"+Integer.toHexString(LauncherTempFileCache.class.getClassLoader().hashCode())+", this 0x"+Integer.toHexString(hashCode())); + } + if(!staticInitError) { + try { + createTmpDir(); + } catch (Exception ex) { + ex.printStackTrace(); + initError = true; + } + } + if (DEBUG) { + System.err.println("tempDir: "+individualTmpDir+" (ok: "+(!initError)+")"); + System.err.println("----------------------------------------------------------"); + } + } + + /** + * @return true is static and object initialization was successful + */ + public boolean isValid() { return !staticInitError && !initError; } + + /** + * Base temp directory used by TempFileCache. + * Lifecycle: For all JVMs, ClassLoader and times. + * + * This is set to: + * + * ${java.io.tmpdir}/<tmpDirPrefix> + * + * + * @return + */ + public File getBaseDir() { return tmpBaseDir; } + + /** + * Root temp directory for this JVM instance. Used to store individual + * directories. + * + * Lifecycle: For all JVMs and ClassLoader + * + * <tmpBaseDir>/<tmpRootPropValue> + * + * Use Case: Per ClassLoader files, eg. native libraries. + * + * Old temp directories are cleaned up the next time a JVM is launched that + * uses TempFileCache. + * + * + * @return + */ + public File getRootDir() { return tmpRootDir; } + + /** + * Temporary directory for individual files (eg. native libraries of one ClassLoader instance). + * The directory name is: + * + * Lifecycle: Within each JVM .. use case dependent, ie. per ClassLoader + * + * <tmpRootDir>/jlnMMMMM + * + * where jlnMMMMM is the unique filename created by File.createTempFile() + * without the ".tmp" extension. + * + * + * @return + */ + public File getTempDir() { return individualTmpDir; } + + + /** + * Create the temp directory in tmpRootDir. To do this, we create a temp + * file with a ".tmp" extension, and then create a directory of the + * same name but without the ".tmp". The temp file, directory, and all + * files in the directory will be reaped the next time this is started. + * We avoid deleteOnExit, because it doesn't work reliably. + */ + private void createTmpDir() throws IOException { + File tmpFile = File.createTempFile("jln", ".tmp", tmpRootDir); + String tmpFileName = tmpFile.getAbsolutePath(); + String tmpDirName = tmpFileName.substring(0, tmpFileName.lastIndexOf(".tmp")); + individualTmpDir = new File(tmpDirName); + if (!individualTmpDir.mkdir()) { + throw new IOException("Cannot create " + individualTmpDir); + } + } +} diff --git a/src/java/jogamp/android/launcher/LauncherUtil.java b/src/java/jogamp/android/launcher/LauncherUtil.java new file mode 100644 index 0000000..63452b7 --- /dev/null +++ b/src/java/jogamp/android/launcher/LauncherUtil.java @@ -0,0 +1,320 @@ +/** + * Copyright 2012 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ +package jogamp.android.launcher; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import android.app.Activity; +import android.content.Intent; +import android.net.Uri; +import android.os.Bundle; +import android.util.Log; + +/** + * Helper class to parse Uri's and programmatically add package names and properties to create an Uri or Intend. + * <p> + * The order of the Uri segments (any arguments) is preserved. + * </p> + */ +public class LauncherUtil { + + /** Default launch mode. */ + public static final String LAUNCH_ACTIVITY_NORMAL = "org.jogamp.launcher.action.LAUNCH_ACTIVITY_NORMAL"; + + /** Transparent launch mode. Note: This seems to be required to achieve translucency, since setTheme(..) doesn't work. */ + public static final String LAUNCH_ACTIVITY_TRANSPARENT = "org.jogamp.launcher.action.LAUNCH_ACTIVITY_TRANSPARENT"; + + /** FIXME: TODO */ + public static final String LAUNCH_MAIN = "org.jogamp.launcher.action.LAUNCH_MAIN"; + + /** FIXME: TODO */ + public static final String LAUNCH_JUNIT = "org.jogamp.launcher.action.LAUNCH_JUNIT"; + + /** The protocol <code>launch</code> */ + public static final String SCHEME = "launch"; + + /** The host <code>jogamp.org</code> */ + public static final String HOST = "jogamp.org"; + + static final String PKG = "pkg"; + + public static abstract class BaseActivityLauncher extends Activity { + final OrderedProperties props = new OrderedProperties(); + + /** + * Returns the default {@link LauncherUtil#LAUNCH_ACTIVITY_NORMAL} action. + * <p> + * Should be overridden for other action, eg. {@link LauncherUtil#LAUNCH_ACTIVITY_TRANSPARENT}. + * </p> + */ + public String getAction() { return LAUNCH_ACTIVITY_NORMAL; } + + /** + * Returns the properties, which are being propagated to the target activity. + * <p> + * Maybe be used to set custom properties. + * </p> + */ + public final OrderedProperties getProperties() { return props; } + + /** Custom initialization hook which can be overriden to setup data, e.g. fill the properties retrieved by {@link #getProperties()}. */ + public void init() { } + + /** Returns true if this launcher activity shall end after starting the downstream activity. Defaults to <code>true</code>, override to change behavior. */ + public boolean finishAfterDelegate() { return true; } + + /** Must return the downstream Activity class name */ + public abstract String getActivityName(); + + /** Must return a list of required packages, at least one. */ + public abstract List<String> getPackages(); + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + init(); + + final DataSet data = new DataSet(); + data.setActivityName(getActivityName()); + data.addAllPackages(getPackages()); + data.addAllProperties(props); + + final Intent intent = LauncherUtil.getIntent(getAction(), data); + Log.d(getClass().getSimpleName(), "Launching Activity: "+intent); + startActivity (intent); + + if(finishAfterDelegate()) { + finish(); // done + } + } + } + + public static class OrderedProperties { + HashMap<String, String> map = new HashMap<String, String>(); + ArrayList<String> keyList = new ArrayList<String>(); + + public final void setProperty(String key, String value) { + if(key.equals(PKG)) { + throw new IllegalArgumentException("Illegal property key, '"+PKG+"' is reserved"); + } + final String oval = map.put(key, value); + if(null != oval) { + map.put(key, oval); // restore + throw new IllegalArgumentException("Property overwriting not allowed: "+key+": "+oval+" -> "+value); + } + keyList.add(key); // new key + } + + public final void addAll(OrderedProperties props) { + Iterator<String> argKeys = props.keyList.iterator(); + while(argKeys.hasNext()) { + final String key = argKeys.next(); + setProperty(key, props.map.get(key)); + } + } + + public final void setSystemProperties() { + Iterator<String> argKeys = keyList.iterator(); + while(argKeys.hasNext()) { + final String key = argKeys.next(); + System.setProperty(key, map.get(key)); + } + } + + public final String getProperty(String key) { return map.get(key); } + public final Map<String, String> getProperties() { return map; } + + /** Returns the list of property keys in the order, as they were added. */ + public final List<String> getPropertyKeys() { return keyList; } + } + + public static class DataSet { + static final char SLASH = '/'; + static final char QMARK = '?'; + static final char AMPER = '&'; + static final char ASSIG = '='; + static final String COLSLASH2 = "://"; + static final String EMPTY = ""; + + String activityName = null; + ArrayList<String> packages = new ArrayList<String>(); + OrderedProperties properties = new OrderedProperties(); + + public final void setActivityName(String name) { activityName = name; } + public final String getActivityName() { return activityName; } + + public final void addPackage(String p) { + packages.add(p); + } + public final void addAllPackages(List<String> plist) { + packages.addAll(plist); + } + public final List<String> getPackages() { return packages; } + + public final void setProperty(String key, String value) { + properties.setProperty(key, value); + } + public final void addAllProperties(OrderedProperties props) { + properties.addAll(props); + } + public final void setSystemProperties() { + properties.setSystemProperties(); + } + public final String getProperty(String key) { return properties.getProperty(key); } + public final OrderedProperties getProperties() { return properties; } + public final List<String> getPropertyKeys() { return properties.getPropertyKeys(); } + + public final Uri getUri() { + StringBuilder sb = new StringBuilder(); + sb.append(SCHEME).append(COLSLASH2).append(HOST).append(SLASH).append(getActivityName()); + boolean needsSep = false; + if(packages.size()>0) { + sb.append(QMARK); + for(int i=0; i<packages.size(); i++) { + if(needsSep) { + sb.append(AMPER); + } + sb.append(PKG).append(ASSIG).append(packages.get(i)); + needsSep = true; + } + } + Iterator<String> argKeys = properties.keyList.iterator(); + while(argKeys.hasNext()) { + if(needsSep) { + sb.append(AMPER); + } + final String key = argKeys.next(); + sb.append(key).append(ASSIG).append(properties.map.get(key)); + needsSep = true; + } + return Uri.parse(sb.toString()); + } + + public static final DataSet create(Uri uri) { + if(!uri.getScheme().equals(SCHEME)) { + return null; + } + if(!uri.getHost().equals(HOST)) { + return null; + } + DataSet data = new DataSet(); + { + String an = uri.getPath(); + if(SLASH == an.charAt(0)) { + an = an.substring(1); + } + if(SLASH == an.charAt(an.length()-1)) { + an = an.substring(0, an.length()-1); + } + data.setActivityName(an); + } + + final String q = uri.getQuery(); + final int q_l = q.length(); + int q_e = -1; + while(q_e < q_l) { + int q_b = q_e + 1; // next term + q_e = q.indexOf(AMPER, q_b); + if(0 == q_e) { + // single seperator + continue; + } + if(0 > q_e) { + // end + q_e = q_l; + } + // n-part + final String part = q.substring(q_b, q_e); + final int assignment = part.indexOf(ASSIG); + if(0 < assignment) { + // assignment + final String k = part.substring(0, assignment); + final String v = part.substring(assignment+1); + if(k.equals(PKG)) { + if(v.length()==0) { + throw new IllegalArgumentException("Empty package name: part <"+part+">, query <"+q+"> of "+uri); + } + data.addPackage(v); + } else { + data.setProperty(k, v); + } + } else { + // property key only + if(part.equals(PKG)) { + throw new IllegalArgumentException("Empty package name: part <"+part+">, query <"+q+"> of "+uri); + } + data.setProperty(part, EMPTY); + } + } + data.validate(); + return data; + } + + public final void validate() { + if(null == activityName) { + throw new RuntimeException("Activity is not NULL"); + } + if(packages.size() == 0) { + throw new RuntimeException("Empty package list"); + } + } + } + + public final static Intent getIntent(String action, DataSet data) { + data.validate(); + return new Intent(action, data.getUri()); + } + + public static void main(String[] args) { + if(args.length==0) { + args = new String[] { + SCHEME+"://"+HOST+"/com.jogamp.TestActivity?"+PKG+"=jogamp.pack1&"+PKG+"=javax.pack2&"+PKG+"=com.jogamp.pack3&jogamp.common.debug=true&com.jogamp.test=false", + SCHEME+"://"+HOST+"/com.jogamp.TestActivity?"+PKG+"=jogamp.pack1&jogamp.common.debug=true&com.jogamp.test=false", + SCHEME+"://"+HOST+"/com.jogamp.TestActivity?"+PKG+"=jogamp.pack1" + }; + } + for(int i=0; i<args.length; i++) { + String uri_s = args[i]; + Uri uri0 = Uri.parse(uri_s); + DataSet data = DataSet.create(uri0); + if(null == data) { + System.err.println("Error: NULL JogAmpLauncherUtil: <"+uri_s+"> -> "+uri0+" -> NULL"); + } + Uri uri1 = data.getUri(); + if(!uri0.equals(uri1)) { + System.err.println("Error: Not equal: <"+uri_s+"> -> "+uri0+" -> "+uri1); + } + } + } + +} |