Android Build & Test ; WavLoader/Data javax.audio separation (part-1)

7 files changed, 837 insertions, 41 deletions

diff --git a/src/test/com/jogamp/openal/test/android/BaseActivity.java b/src/test/com/jogamp/openal/test/android/BaseActivity.java
new file mode 100644
index 0000000..9aec18a
--- /dev/null
+++ b/src/test/com/jogamp/openal/test/android/BaseActivity.java
@@ -0,0 +1,115 @@
+/**
+ * Copyright 2013 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 com.jogamp.openal.test.android;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+
+public class BaseActivity extends Activity {    
+   boolean isDelegatedActivity;
+   Activity rootActivity;
+   boolean setThemeCalled = false;
+      
+   public BaseActivity() {
+       super();
+       isDelegatedActivity = false;
+       rootActivity = this;
+   }
+   
+   public void setRootActivity(Activity rootActivity) {
+       this.rootActivity = rootActivity;
+       this.isDelegatedActivity = this != rootActivity;
+   }
+   
+   public final boolean isDelegatedActivity() {
+       return isDelegatedActivity;
+   }
+   
+   public final Activity getActivity() {
+       return rootActivity;
+   }     
+   
+   @Override
+   public void onCreate(Bundle savedInstanceState) {
+       Log.d(MD.TAG, "onCreate");
+       if(!isDelegatedActivity()) {
+           super.onCreate(savedInstanceState);
+       }
+       jogamp.common.os.android.StaticContext.init(rootActivity.getApplicationContext());
+   }
+   
+   @Override
+   public void onStart() {
+     Log.d(MD.TAG, "onStart");
+     if(!isDelegatedActivity()) {
+         super.onStart();
+     }
+   }
+     
+   @Override
+   public void onRestart() {
+     Log.d(MD.TAG, "onRestart");
+     if(!isDelegatedActivity()) {
+         super.onRestart();
+     }
+   }
+
+   @Override
+   public void onResume() {
+     Log.d(MD.TAG, "onResume");
+     if(!isDelegatedActivity()) {
+         super.onResume();
+     }
+   }
+
+   @Override
+   public void onPause() {
+     Log.d(MD.TAG, "onPause");
+     if(!isDelegatedActivity()) {
+         super.onPause();
+     }
+   }
+
+   @Override
+   public void onStop() {
+     Log.d(MD.TAG, "onStop");
+     if(!isDelegatedActivity()) {
+         super.onStop();  
+     }
+   }
+
+   @Override
+   public void onDestroy() {
+     Log.d(MD.TAG, "onDestroy");
+     jogamp.common.os.android.StaticContext.clear();
+     if(!isDelegatedActivity()) {
+         super.onDestroy(); 
+     }
+   }   
+}
diff --git a/src/test/com/jogamp/openal/test/android/LauncherUtil.java b/src/test/com/jogamp/openal/test/android/LauncherUtil.java
new file mode 100644
index 0000000..d416e5d
--- /dev/null
+++ b/src/test/com/jogamp/openal/test/android/LauncherUtil.java
@@ -0,0 +1,430 @@
+/**
+ * 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 com.jogamp.openal.test.android;
+
+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 SYS_PKG = "sys";
+   
+   static final String USR_PKG = "pkg";
+   
+   static final String ARG = "arg";
+   
+   public static abstract class BaseActivityLauncher extends Activity {
+       final OrderedProperties props = new OrderedProperties();
+       final ArrayList<String> args = new ArrayList<String>();
+       /** 
+        * 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; }
+       
+       /**
+        * Returns the commandline arguments, which are being propagated to the target activity.
+        * <p>
+        * Maybe be used to set custom commandline arguments.
+        * </p>
+        */
+       public final ArrayList<String> getArguments() { return args; } 
+       
+       /** 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 user packages, at least one containing the activity. */
+       public abstract List<String> getUsrPackages();
+       
+       /** Return a list of required system packages w/ native libraries, may return null or a zero sized list. */
+       public abstract List<String> getSysPackages();
+
+       @Override
+       public void onCreate(Bundle savedInstanceState) {
+           super.onCreate(savedInstanceState);
+           
+           init();
+           
+           final DataSet data = new DataSet();
+           data.setActivityName(getActivityName());
+           data.addAllSysPackages(getSysPackages());
+           data.addAllUsrPackages(getUsrPackages());
+           data.addAllProperties(props);
+           data.addAllArguments(args);
+           
+           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(SYS_PKG)) {
+               throw new IllegalArgumentException("Illegal property key, '"+SYS_PKG+"' is reserved");
+           }
+           if(key.equals(USR_PKG)) {
+               throw new IllegalArgumentException("Illegal property key, '"+USR_PKG+"' is reserved");
+           }
+           if(key.equals(ARG)) {
+               throw new IllegalArgumentException("Illegal property key, '"+ARG+"' 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 void clearSystemProperties() {
+           Iterator<String> argKeys = keyList.iterator();
+           while(argKeys.hasNext()) {
+               System.clearProperty(argKeys.next());
+           }
+       }
+       
+       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; }       
+   }
+   
+   /**
+    * Data set to transfer from and to launch URI consisting out of:
+    * <ul>
+    *   <li>system packages w/ native libraries used on Android, which may use a cached ClassLoader, see {@link DataSet#getSysPackages()}.</li>
+    *   <li>user packages w/o native libraries used on Android, which do not use a cached ClassLoader, see {@link DataSet#getUsrPackages()}.</li>
+    *   <li>activity name, used to launch an Android activity, see {@link DataSet#getActivityName()}.</li>
+    *   <li>properties, which will be added to the system properties, see {@link DataSet#getProperties()}.</li>
+    *   <li>arguments, used to launch a class main-entry, see {@link DataSet#getArguments()}.</li>
+    * </ul>
+    * {@link DataSet#getUri()} returns a URI representation of all components.
+    */
+   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> sysPackages = new ArrayList<String>();
+       ArrayList<String> usrPackages = new ArrayList<String>();
+       OrderedProperties properties = new OrderedProperties();
+       ArrayList<String> arguments = new ArrayList<String>();
+       
+       public final void setActivityName(String name) { activityName = name; }
+       public final String getActivityName() { return activityName; }
+              
+       public final void addSysPackage(String p) { 
+           sysPackages.add(p); 
+       }   
+       public final void addAllSysPackages(List<String> plist) { 
+           sysPackages.addAll(plist);
+       }   
+       public final List<String> getSysPackages()  { return sysPackages; }
+       
+       public final void addUsrPackage(String p) { 
+           usrPackages.add(p); 
+       }   
+       public final void addAllUsrPackages(List<String> plist) { 
+           usrPackages.addAll(plist);
+       }   
+       public final List<String> getUsrPackages()  { return usrPackages; }
+       
+       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 void clearSystemProperties() {
+           properties.clearSystemProperties();
+       }   
+       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 void addArgument(String arg) { arguments.add(arg); }
+       public final void addAllArguments(List<String> args) {
+           arguments.addAll(args);
+       }
+       public final ArrayList<String> getArguments() { return arguments; }
+       
+       public final Uri getUri() {
+           StringBuilder sb = new StringBuilder();
+           sb.append(SCHEME).append(COLSLASH2).append(HOST).append(SLASH).append(getActivityName());
+           boolean needsQMark = true;
+           boolean needsSep = false;
+           if(sysPackages.size()>0) {
+               if( needsQMark ) {
+                   sb.append(QMARK);
+                   needsQMark = false;
+               }
+               for(int i=0; i<sysPackages.size(); i++) {
+                   if(needsSep) {
+                       sb.append(AMPER);
+                   }
+                   sb.append(SYS_PKG).append(ASSIG).append(sysPackages.get(i));
+                   needsSep = true;
+               }
+           }
+           if(usrPackages.size()>0) {
+               if( needsQMark ) {
+                   sb.append(QMARK);
+                   needsQMark = false;
+               }
+               for(int i=0; i<usrPackages.size(); i++) {
+                   if(needsSep) {
+                       sb.append(AMPER);
+                   }
+                   sb.append(USR_PKG).append(ASSIG).append(usrPackages.get(i));
+                   needsSep = true;
+               }
+           }
+           Iterator<String> propKeys = properties.keyList.iterator();
+           while(propKeys.hasNext()) {
+               if( needsQMark ) {
+                   sb.append(QMARK);
+                   needsQMark = false;
+               }
+               if(needsSep) {
+                   sb.append(AMPER);
+               }
+               final String key = propKeys.next();
+               sb.append(key).append(ASSIG).append(properties.map.get(key));
+               needsSep = true;
+           }
+           Iterator<String> args = arguments.iterator();
+           while(args.hasNext()) {
+               if( needsQMark ) {
+                   sb.append(QMARK);
+                   needsQMark = false;
+               }
+               if(needsSep) {
+                   sb.append(AMPER);
+               }
+               sb.append(ARG).append(ASSIG).append(args.next());
+               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 = null != q ? q.length() : -1;
+           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 separator
+                   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(SYS_PKG)) {
+                       if(v.length()==0) {
+                           throw new IllegalArgumentException("Empty package name: part <"+part+">, query <"+q+"> of "+uri);
+                       }
+                       data.addSysPackage(v);
+                   } else if(k.equals(USR_PKG)) {
+                       if(v.length()==0) {
+                           throw new IllegalArgumentException("Empty package name: part <"+part+">, query <"+q+"> of "+uri);
+                       }
+                       data.addUsrPackage(v);
+                   } else if(k.equals(ARG)) {
+                       if(v.length()==0) {
+                           throw new IllegalArgumentException("Empty argument name: part <"+part+">, query <"+q+"> of "+uri);
+                       }
+                       data.addArgument(v);
+                   } else {
+                       data.setProperty(k, v);
+                   }
+               } else {
+                   // property key only
+                   if( part.equals(USR_PKG) || part.equals(ARG) ) {
+                       throw new IllegalArgumentException("Reserved key <"+part+"> in 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");
+           }
+       }
+   }
+   
+   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?"+SYS_PKG+"=jogamp.pack1&"+SYS_PKG+"=javax.pack2&"+USR_PKG+"=com.jogamp.pack3&"+USR_PKG+"=com.jogamp.pack4&jogamp.common.debug=true&com.jogamp.test=false",   
+               SCHEME+"://"+HOST+"/com.jogamp.TestActivity?"+SYS_PKG+"=jogamp.pack1&jogamp.common.debug=true&com.jogamp.test=false",
+               SCHEME+"://"+HOST+"/com.jogamp.TestActivity?"+USR_PKG+"=jogamp.pack1&jogamp.common.debug=true&com.jogamp.test=false",
+               SCHEME+"://"+HOST+"/com.jogamp.TestActivity?"+USR_PKG+"=jogamp.pack1&"+USR_PKG+"=com.jogamp.pack2",
+               SCHEME+"://"+HOST+"/com.jogamp.TestActivity?"+USR_PKG+"=jogamp.pack1&"+USR_PKG+"=javax.pack2&"+USR_PKG+"=com.jogamp.pack3&jogamp.common.debug=true&com.jogamp.test=false&"+ARG+"=arg1&"+ARG+"=arg2=arg2value&"+ARG+"=arg3",   
+               SCHEME+"://"+HOST+"/com.jogamp.TestActivity?"+USR_PKG+"=jogamp.pack1&jogamp.common.debug=true&com.jogamp.test=false&"+ARG+"=arg1&"+ARG+"=arg2=arg2value&"+ARG+"=arg3",   
+               SCHEME+"://"+HOST+"/com.jogamp.TestActivity?"+USR_PKG+"=jogamp.pack1&"+ARG+"=arg1&"+ARG+"=arg2=arg2value&"+ARG+"=arg3"   
+           };
+       }
+       int errors = 0;
+       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) {
+               errors++;
+               System.err.println("Error: NULL JogAmpLauncherUtil: <"+uri_s+"> -> "+uri0+" -> NULL");
+           } else {
+               Uri uri1 = data.getUri();
+               if(!uri0.equals(uri1)) {
+                   errors++;
+                   System.err.println("Error: Not equal: <"+uri_s+"> -> "+uri0+" -> "+uri1);
+               } else {
+                   System.err.println("OK: "+uri1);
+               }
+           }
+       }
+       System.err.println("LauncherUtil Self Test: Errors: "+errors);
+   }
+   
+}
diff --git a/src/test/com/jogamp/openal/test/android/MD.java b/src/test/com/jogamp/openal/test/android/MD.java
new file mode 100644
index 0000000..113203e
--- /dev/null
+++ b/src/test/com/jogamp/openal/test/android/MD.java
@@ -0,0 +1,53 @@
+/**
+ * Copyright 2013 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 com.jogamp.openal.test.android;
+
+import com.jogamp.common.GlueGenVersion;
+import com.jogamp.common.os.Platform;
+import com.jogamp.common.util.VersionUtil;
+import com.jogamp.openal.JoalVersion;
+
+public class MD {
+   public static final String TAG = "JogAmp.JOAL";
+   
+   public static String getInfo() {        
+        StringBuilder sb = new StringBuilder();
+        
+        sb.append(VersionUtil.getPlatformInfo()).append(Platform.NEWLINE)
+              .append(GlueGenVersion.getInstance()).append(Platform.NEWLINE)
+              .append(JoalVersion.getInstance()).append(Platform.NEWLINE)
+              .append(Platform.NEWLINE);
+              
+        return sb.toString();       
+   }
+   
+    public static void main(String args[]) {
+        
+        System.err.println(getInfo());
+    }
+}
diff --git a/src/test/com/jogamp/openal/test/android/OpenALTestActivity.java b/src/test/com/jogamp/openal/test/android/OpenALTestActivity.java
new file mode 100644
index 0000000..960d447
--- /dev/null
+++ b/src/test/com/jogamp/openal/test/android/OpenALTestActivity.java
@@ -0,0 +1,85 @@
+/**
+ * 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 com.jogamp.openal.test.android;
+
+import com.jogamp.openal.test.manual.OpenALTest;
+
+import android.os.Bundle;
+import android.util.Log;
+
+public class OpenALTestActivity extends BaseActivity {
+   static String TAG = "OpenALTestActivity";
+   
+   OpenALTest demo = null;
+   
+   @Override
+   public void onCreate(Bundle savedInstanceState) {
+       Log.d(TAG, "onCreate - 0");
+       super.onCreate(savedInstanceState);
+       
+       demo = new OpenALTest();
+       try {
+           demo.init();
+       } catch (Exception e) {
+           e.printStackTrace();
+           demo.dispose();
+           demo = null;
+       }
+       
+       Log.d(TAG, "onCreate - X");
+   }
+   
+   @Override
+   public void onResume() {
+     Log.d(MD.TAG, "onResume");
+     super.onResume();
+     if( null != demo ) {
+         demo.play();
+     }
+   }
+
+   @Override
+   public void onPause() {
+     Log.d(MD.TAG, "onPause");
+     if( null != demo ) {
+         demo.pause();
+     }
+     super.onPause();
+   }
+
+   @Override
+   public void onDestroy() {
+     Log.d(MD.TAG, "onDestroy");
+     if( null != demo ) {
+         demo.dispose();
+         demo = null;
+     }
+     super.onDestroy(); 
+   }   
+   
+}
diff --git a/src/test/com/jogamp/openal/test/android/OpenALTestActivityLauncher.java b/src/test/com/jogamp/openal/test/android/OpenALTestActivityLauncher.java
new file mode 100644
index 0000000..3ebbd80
--- /dev/null
+++ b/src/test/com/jogamp/openal/test/android/OpenALTestActivityLauncher.java
@@ -0,0 +1,36 @@
+package com.jogamp.openal.test.android;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.jogamp.openal.test.android.LauncherUtil.OrderedProperties;
+
+public class OpenALTestActivityLauncher extends LauncherUtil.BaseActivityLauncher {
+    static String demo = "com.jogamp.openal.test.android.OpenALTestActivity";
+    static String[] sys_pkgs = new String[] { "com.jogamp.common", "com.jogamp.openal" };    
+    static String[] usr_pkgs = new String[] { "com.jogamp.openal.test" };
+    
+    @Override
+    public void init() {
+       final OrderedProperties props = getProperties();       
+       props.setProperty("jogamp.debug.JNILibLoader", "true");
+       props.setProperty("jogamp.debug.NativeLibrary", "true");
+       props.setProperty("jogamp.debug.NativeLibrary.Lookup", "true");
+       props.setProperty("jogamp.debug.IOUtil", "true");
+    }
+    
+    @Override
+    public String getActivityName() {
+        return demo;
+    }
+    
+    @Override
+    public List<String> getSysPackages() {
+        return Arrays.asList(sys_pkgs);
+    }
+    
+    @Override
+    public List<String> getUsrPackages() {
+        return Arrays.asList(usr_pkgs);
+    }
+}
diff --git a/src/test/com/jogamp/openal/test/manual/OpenALTest.java b/src/test/com/jogamp/openal/test/manual/OpenALTest.java
index 864a9fd..1bc8b78 100644
--- a/src/test/com/jogamp/openal/test/manual/OpenALTest.java
+++ b/src/test/com/jogamp/openal/test/manual/OpenALTest.java
@@ -2,6 +2,7 @@ package com.jogamp.openal.test.manual;
 
 /**
  * Copyright (c) 2003 Sun Microsystems, Inc. All  Rights Reserved.
+ * Copyright (c) 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:
@@ -32,45 +33,64 @@ package com.jogamp.openal.test.manual;
  * You acknowledge that this software is not designed or intended for use in the
  * design, construction, operation or maintenance of any nuclear facility.
  */
+import java.io.IOException;
+import java.nio.IntBuffer;
+
 import com.jogamp.common.nio.Buffers;
 import com.jogamp.openal.AL;
 import com.jogamp.openal.ALC;
 import com.jogamp.openal.ALCcontext;
 import com.jogamp.openal.ALCdevice;
 import com.jogamp.openal.ALFactory;
-import java.io.IOException;
-import java.nio.*;
-
-import com.jogamp.openal.eax.*;
+import com.jogamp.openal.UnsupportedAudioFileException;
+import com.jogamp.openal.eax.EAX;
+import com.jogamp.openal.eax.EAXFactory;
 import com.jogamp.openal.test.resources.ResourceLocation;
-import com.jogamp.openal.util.*;
-import java.io.InputStream;
-import javax.sound.sampled.UnsupportedAudioFileException;
+import com.jogamp.openal.util.WAVData;
 
 /**
- * @author Athomas Goldberg
- * @author Michael Bien
+ * @author Athomas Goldberg, Michael Bien, et.al.
  */
 public class OpenALTest {
-    public static void main(String[] args) throws InterruptedException, UnsupportedAudioFileException, IOException {
-        ALC alc = ALFactory.getALC();
-        ALCdevice device = alc.alcOpenDevice(null);
-        ALCcontext context = alc.alcCreateContext(device, null);
+    private ALC alc = null;
+    private ALCdevice device = null;
+    private ALCcontext context = null;
+    private AL al = null;
+    private int[] sources = null;
+    private boolean initialized = false;
+    
+    public OpenALTest() {        
+    }
+    
+    public void init() throws UnsupportedAudioFileException, IOException {
+        if( initialized ) {
+            return;
+        }
+        alc = ALFactory.getALC();
+        device = alc.alcOpenDevice(null);
+        context = alc.alcCreateContext(device, null);
         alc.alcMakeContextCurrent(context);
-        AL al = ALFactory.getAL();
+        al = ALFactory.getAL();
         
-        System.out.println("devices:");
-        String[] devices = alc.alcGetDeviceSpecifiers();
-        for (String name : devices) {
-            System.out.println("    "+name);
+        System.out.println("output devices:");
+        {
+            final String[] outDevices = alc.alcGetDeviceSpecifiers();
+            if( null != outDevices ) {
+                for (String name : outDevices) {
+                    System.out.println("    "+name);
+                }
+            }
         }
         System.out.println("capture devices:");
-        devices = alc.alcGetCaptureDeviceSpecifiers();
-        for (String name : devices) {
-            System.out.println("    "+name);
+        {
+            final String[] inDevices = alc.alcGetCaptureDeviceSpecifiers();
+            if( null != inDevices ) {
+                for (String name : inDevices) {
+                    System.out.println("    "+name);
+                }
+            }
         }
 
-
         boolean eaxPresent = al.alIsExtensionPresent("EAX2.0");
         EAX eax = ( eaxPresent ) ? EAXFactory.getEAX() : null;
         System.err.println("EAX present:" + eaxPresent + ", EAX retrieved: "+ (null != eax));
@@ -78,10 +98,10 @@ public class OpenALTest {
         int[] buffers = new int[1];
         al.alGenBuffers(1, buffers, 0);
 
-        WAVData wd = WAVLoader.loadFromStream(ResourceLocation.getTestStream0());
+        WAVData wd = WAVData.loadFromStream(ResourceLocation.getTestStream0(), 1, 8, 22050);
         al.alBufferData(buffers[0], wd.format, wd.data, wd.size, wd.freq);
-
-        int[] sources = new int[1];
+        
+        sources = new int[1];
         al.alGenSources(1, sources, 0);
         al.alSourcei(sources[0], AL.AL_BUFFER, buffers[0]);
 
@@ -98,26 +118,68 @@ public class OpenALTest {
             env.put(EAX.EAX_ENVIRONMENT_BATHROOM);
             eax.setListenerProperty(EAX.DSPROPERTY_EAXLISTENER_ENVIRONMENT, env);
         }
-
+        initialized = true;
+    }
+    
+    public void play() {
+        if( !initialized ) {
+            return;
+        }
+        System.out.println("play direct");
         al.alSourcePlay(sources[0]);
-
+    }
+    
+    public void play3f(float x, float y, float z) {
+        if( !initialized ) {
+            return;
+        }
+        System.out.println("play3f "+x+", "+y+", "+z);
+        al.alSource3f(sources[0], AL.AL_POSITION, x, y, z);
+    }
+    
+    public void pause() {
+        if( !initialized ) {
+            return;
+        }
+        al.alSourcePause(sources[0]);
+    }
+    
+    public void dispose() {
+        if( !initialized ) {
+            return;
+        }
+        if( null != sources ) {
+            al.alSourceStop(sources[0]);
+            al.alDeleteSources(1, sources, 0);
+            sources = null;
+        }
+        if( null != context ) {
+            alc.alcDestroyContext(context);
+            context = null;
+        }
+        if( null != device ) {
+            alc.alcCloseDevice(device);
+            device = null;
+        }
+        initialized = false;
+    }
+    
+    public static void main(String[] args) throws InterruptedException, UnsupportedAudioFileException, IOException {
+        OpenALTest demo = new OpenALTest();
+        demo.init();
+      
+        demo.play();
         Thread.sleep(5000);
 
-        al.alSource3f(sources[0], AL.AL_POSITION, 2f, 2f, 2f);
-
+        demo.play3f(2f, 2f, 2f);
         Thread.sleep(5000);
 
-        al.alListener3f(AL.AL_POSITION, 3f, 3f, 3f);
-
+        demo.play3f(3f, 3f, 3f);
         Thread.sleep(5000);
 
-        al.alSource3f(sources[0], AL.AL_POSITION, 0, 0, 0);
-
+        demo.play3f(0f, 0f, 0f);
         Thread.sleep(10000);
-
-        al.alSourceStop(sources[0]);
-        al.alDeleteSources(1, sources, 0);
-        alc.alcDestroyContext(context);
-        alc.alcCloseDevice(device);
+        
+        demo.dispose();
     }
 }
diff --git a/src/test/com/jogamp/openal/test/resources/ResourceLocation.java b/src/test/com/jogamp/openal/test/resources/ResourceLocation.java
index cc9f29f..9b2eb75 100644
--- a/src/test/com/jogamp/openal/test/resources/ResourceLocation.java
+++ b/src/test/com/jogamp/openal/test/resources/ResourceLocation.java
@@ -1,8 +1,12 @@
 
 package com.jogamp.openal.test.resources;
 
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.BufferedInputStream;
+import java.net.URLConnection;
+
+import com.jogamp.common.util.IOUtil;
 
 /** just a tag to locate the resources */
 public class ResourceLocation {
@@ -24,9 +28,20 @@ public class ResourceLocation {
     }
 
     public static InputStream getInputStream(String fileName, boolean throwException) {
-        InputStream stream = new BufferedInputStream(rl.getClass().getResourceAsStream(fileName));
-        if(throwException && null == stream) {
-            throw new RuntimeException("File '"+fileName+"' not found");
+        URLConnection conn = IOUtil.getResource(rl.getClass(), fileName);        
+        if (conn == null) {
+            return null;
+        }
+        InputStream stream = null;
+        try {
+            stream = new BufferedInputStream(conn.getInputStream());
+        } catch (IOException e) {
+            if(throwException && null == stream) {
+                throw new RuntimeException("File '"+fileName+"' not found: "+e.getMessage());
+            } else {
+                System.err.println("File '"+fileName+"' not found");
+                e.printStackTrace();                
+            }
         }
         return stream;
     }