ANDROID: scheme start can be zipped

Author: chrisws

src/platform/android/src/net/sourceforge/smallbasic/MainActivity.java

@@ -3,13 +3,15 @@
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.io.InputStreamReader;
 import java.io.UnsupportedEncodingException;
 import java.net.ServerSocket;
 import java.net.Socket;
@@ -22,6 +24,7 @@
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.zip.GZIPInputStream;
 
 import android.annotation.TargetApi;
 import android.app.Activity;
@@ -35,6 +38,7 @@
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
+import android.util.Base64;
 import android.util.Log;
 import android.view.InputDevice;
 import android.view.View;
@@ -51,10 +55,10 @@ public class MainActivity extends NativeActivity {
   private static final String WEB_BAS = "web.bas";
   private static final String SCHEME_BAS = "scheme.bas";
   private static final String SCHEME = "smallbasic://x/";
-  private String startupBas = null;
-  private boolean untrusted = false;
-  private ExecutorService audioExecutor = Executors.newSingleThreadExecutor();
-  private Queue<Sound> sounds = new ConcurrentLinkedQueue<Sound>();
+  private String _startupBas = null;
+  private boolean _untrusted = false;
+  private ExecutorService _audioExecutor = Executors.newSingleThreadExecutor();
+  private Queue<Sound> _sounds = new ConcurrentLinkedQueue<Sound>();
 
   static {
     System.loadLibrary("smallbasic");
@@ -66,19 +70,19 @@ public class MainActivity extends NativeActivity {
 
   public void clearSoundQueue() {
     Log.i(TAG, "clearSoundQueue");
-    for (Sound sound : sounds) {
+    for (Sound sound : _sounds) {
       sound.setSilent(true);
     }
   }
 
   public boolean getSoundPlaying() {
-    boolean result = this.sounds.size() > 0;
+    boolean result = this._sounds.size() > 0;
     Log.i(TAG, "getSoundPlaying = " + result);
     return result;
   }
 
   public String getStartupBas() {
-    return this.startupBas;
+    return this._startupBas;
   }
 
   public int getUnicodeChar(int keyCode, int metaState) {
@@ -94,7 +98,7 @@ public int getUnicodeChar(int keyCode, int metaState) {
 
   public boolean getUntrusted() {
     Log.i(TAG, "getUntrusted");
-    return this.untrusted;
+    return this._untrusted;
   }
 
   @Override
@@ -131,12 +135,12 @@ public void playTone(int frq, int dur, int vol) {
     Log.i(TAG, "playTone: " + frq + " " + dur + " " + vol + " " + volume);
 
     final Sound sound = new Sound(frq, dur, volume);
-    sounds.add(sound);
-    audioExecutor.execute(new Runnable() {
+    _sounds.add(sound);
+    _audioExecutor.execute(new Runnable() {
       @Override
       public void run() {
         sound.play();
-        sounds.remove(sound);
+        _sounds.remove(sound);
       }
     });
   }
@@ -182,9 +186,9 @@ protected void onCreate(Bundle savedInstanceState) {
         execScheme(data);
         Log.i(TAG, "data="+ data);
       } else {
-        startupBas = uri.getPath();
+        _startupBas = uri.getPath();
       }
-      Log.i(TAG, "startupBas="+ startupBas);
+      Log.i(TAG, "startupBas="+ _startupBas);
     }
     try {
       Properties p = new Properties();
@@ -239,9 +243,25 @@ private String execBuffer(final String buffer, final String name, boolean run) t
 
   private void execScheme(final String data) {
     try {
-      String bas = URLDecoder.decode(data.substring(SCHEME.length()), "utf-8");
-      startupBas = execBuffer(bas, SCHEME_BAS, false);
-      untrusted = true;
+      String input = data.substring(SCHEME.length());
+      byte[] decodedBytes = Base64.decode(input, Base64.DEFAULT);
+      int magic = (decodedBytes[1] & 0xFF) << 8 | decodedBytes[0];
+      BufferedReader reader;
+      String bas;
+      if (magic == GZIPInputStream.GZIP_MAGIC) {
+        GZIPInputStream zipStream = new GZIPInputStream(new ByteArrayInputStream(decodedBytes));
+        reader = new BufferedReader(new InputStreamReader(zipStream));
+        StringBuilder out = new StringBuilder();
+        String s;
+        while ((s = reader.readLine()) != null) {
+          out.append(s).append('\n');
+        }
+        bas = out.toString();
+      } else {
+        bas = URLDecoder.decode(input, "utf-8");
+      }
+      _startupBas = execBuffer(bas, SCHEME_BAS, false);
+      _untrusted = true;
     } catch (IOException e) {
       Log.i(TAG, "saveSchemeData failed: ", e);
     }

src/platform/android/src/net/sourceforge/smallbasic/Sound.java

@@ -1,7 +1,6 @@
 package net.sourceforge.smallbasic;
 
 import android.annotation.TargetApi;
-import android.content.Context;
 import android.media.AudioFormat;
 import android.media.AudioManager;
 import android.media.AudioTrack;
@@ -17,33 +16,33 @@
 public class Sound {
   private static final String TAG = "smallbasic";
   static final int AUDIO_SAMPLE_RATE = 8000;
-  private byte[] sound;
-  private float volume;
-  private int dur;
-  private boolean silent;
+  private byte[] _sound;
+  private float _volume;
+  private int _dur;
+  private boolean _silent;
 
   public Sound(int frq, int dur, float vol) {
-    this.sound = generateTone(frq, dur);
-    this.volume = vol;
-    this.dur = dur;
-    this.silent = false;
+    this._sound = generateTone(frq, dur);
+    this._volume = vol;
+    this._dur = dur;
+    this._silent = false;
   }
 
   public boolean isSilent() {
-    return silent;
+    return _silent;
   }
 
   public void play() {
-    if (!silent) {
+    if (!_silent) {
       try {
         AudioTrack audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
             AUDIO_SAMPLE_RATE, AudioFormat.CHANNEL_OUT_MONO,
-            AudioFormat.ENCODING_PCM_16BIT, sound.length, AudioTrack.MODE_STATIC);
-        if (audioTrack.write(sound, 0, sound.length) == sound.length) {
-          audioTrack.setStereoVolume(volume, volume);
+            AudioFormat.ENCODING_PCM_16BIT, _sound.length, AudioTrack.MODE_STATIC);
+        if (audioTrack.write(_sound, 0, _sound.length) == _sound.length) {
+          audioTrack.setStereoVolume(_volume, _volume);
           playTrack(audioTrack);
         } else {
-          Log.i(TAG, "Failed to write audio: " + sound.length);
+          Log.i(TAG, "Failed to write audio: " + _sound.length);
         }
       } catch (Exception e) {
         Log.i(TAG, "play failed: ", e);
@@ -52,7 +51,7 @@ public void play() {
   }
 
   public void setSilent(boolean silent) {
-    this.silent = silent;
+    this._silent = silent;
   }
 
   /**
@@ -112,10 +111,10 @@ private final byte[] generateTone(int freqOfTone, int durationMillis) {
 
   private void playTrack(AudioTrack audioTrack) throws InterruptedException {
     int frame;
-    int frames = sound.length / 2;
+    int frames = _sound.length / 2;
     audioTrack.play();
     do {
-      Thread.sleep(dur / 2);
+      Thread.sleep(_dur / 2);
       frame = audioTrack.getPlaybackHeadPosition();
     } while (frame < frames);
     audioTrack.release();