The Tor Browser: mobile/android/base/GeckoAppShell.java@fc2d59ddac77 (annotated)

mobile/android/base/GeckoAppShell.java@fc2d59ddac77 (annotated)

mobile/android/base/GeckoAppShell.java

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 package org.mozilla.gecko;
 import java.io.BufferedReader;
 import java.io.Closeable;
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.net.Proxy;
 import java.net.URL;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Queue;
 import java.util.StringTokenizer;
 import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import org.mozilla.gecko.favicons.OnFaviconLoadedListener;
 import org.mozilla.gecko.favicons.decoders.FaviconDecoder;
 import org.mozilla.gecko.gfx.BitmapUtils;
 import org.mozilla.gecko.gfx.LayerView;
 import org.mozilla.gecko.gfx.PanZoomController;
 import org.mozilla.gecko.mozglue.GeckoLoader;
 import org.mozilla.gecko.mozglue.JNITarget;
 import org.mozilla.gecko.mozglue.RobocopTarget;
 import org.mozilla.gecko.mozglue.generatorannotations.OptionalGeneratedParameter;
 import org.mozilla.gecko.mozglue.generatorannotations.WrapElementForJNI;
 import org.mozilla.gecko.prompts.PromptService;
 import org.mozilla.gecko.util.GeckoEventListener;
 import org.mozilla.gecko.util.HardwareUtils;
 import org.mozilla.gecko.util.NativeJSContainer;
 import org.mozilla.gecko.util.ProxySelector;
 import org.mozilla.gecko.util.ThreadUtils;
 import org.mozilla.gecko.webapp.Allocator;
 import android.app.Activity;
 import android.app.ActivityManager;
 import android.app.PendingIntent;
 import android.content.ActivityNotFoundException;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.pm.ActivityInfo;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
 import android.content.pm.Signature;
 import android.content.res.TypedArray;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.ImageFormat;
 import android.graphics.Paint;
 import android.graphics.PixelFormat;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.graphics.SurfaceTexture;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.hardware.Sensor;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
 import android.location.Criteria;
 import android.location.Location;
 import android.location.LocationListener;
 import android.location.LocationManager;
 import android.media.MediaScannerConnection;
 import android.media.MediaScannerConnection.MediaScannerConnectionClient;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
 import android.os.MessageQueue;
 import android.os.SystemClock;
 import android.os.Vibrator;
 import android.provider.Settings;
 import android.telephony.TelephonyManager;
 import android.text.TextUtils;
 import android.util.Base64;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.ContextThemeWrapper;
 import android.view.HapticFeedbackConstants;
 import android.view.Surface;
 import android.view.SurfaceView;
 import android.view.TextureView;
 import android.view.View;
 import android.view.inputmethod.InputMethodManager;
 import android.webkit.MimeTypeMap;
 import android.webkit.URLUtil;
 import android.widget.AbsoluteLayout;
 import android.widget.Toast;
 public class GeckoAppShell
 {
     private static final String LOGTAG = "GeckoAppShell";
     private static final boolean LOGGING = false;
     // We have static members only.
     private GeckoAppShell() { }
     private static boolean restartScheduled = false;
     private static GeckoEditableListener editableListener = null;
     private static final Queue<GeckoEvent> PENDING_EVENTS = new ConcurrentLinkedQueue<GeckoEvent>();
     private static final Map<String, String> ALERT_COOKIES = new ConcurrentHashMap<String, String>();
     private static volatile boolean locationHighAccuracyEnabled;
     // Accessed by NotificationHelper. This should be encapsulated.
     /* package */ static NotificationClient notificationClient;
     // See also HardwareUtils.LOW_MEMORY_THRESHOLD_MB.
     private static final int HIGH_MEMORY_DEVICE_THRESHOLD_MB = 768;
     public static final String SHORTCUT_TYPE_WEBAPP = "webapp";
     public static final String SHORTCUT_TYPE_BOOKMARK = "bookmark";
     static private int sDensityDpi = 0;
     static private int sScreenDepth = 0;
     private static final EventDispatcher sEventDispatcher = new EventDispatcher();
     /* Default colors. */
     private static final float[] DEFAULT_LAUNCHER_ICON_HSV = { 32.0f, 1.0f, 1.0f };
     /* Is the value in sVibrationEndTime valid? */
     private static boolean sVibrationMaybePlaying = false;
     /* Time (in System.nanoTime() units) when the currently-playing vibration
      * is scheduled to end.  This value is valid only when
      * sVibrationMaybePlaying is true. */
     private static long sVibrationEndTime = 0;
     /* Default value of how fast we should hint the Android sensors. */
     private static int sDefaultSensorHint = 100;
     private static Sensor gAccelerometerSensor = null;
     private static Sensor gLinearAccelerometerSensor = null;
     private static Sensor gGyroscopeSensor = null;
     private static Sensor gOrientationSensor = null;
     private static Sensor gProximitySensor = null;
     private static Sensor gLightSensor = null;
     /*
      * Keep in sync with constants found here:
      * http://mxr.mozilla.org/mozilla-central/source/uriloader/base/nsIWebProgressListener.idl
     */
     static public final int WPL_STATE_START = 0x00000001;
     static public final int WPL_STATE_STOP = 0x00000010;
     static public final int WPL_STATE_IS_DOCUMENT = 0x00020000;
     static public final int WPL_STATE_IS_NETWORK = 0x00040000;
     /* Keep in sync with constants found here:
       http://mxr.mozilla.org/mozilla-central/source/netwerk/base/public/nsINetworkLinkService.idl
     */
     static public final int LINK_TYPE_UNKNOWN = 0;
     static public final int LINK_TYPE_ETHERNET = 1;
     static public final int LINK_TYPE_USB = 2;
     static public final int LINK_TYPE_WIFI = 3;
     static public final int LINK_TYPE_WIMAX = 4;
     static public final int LINK_TYPE_2G = 5;
     static public final int LINK_TYPE_3G = 6;
     static public final int LINK_TYPE_4G = 7;
     /* The Android-side API: API methods that Android calls */
     // Initialization methods
     public static native void nativeInit();
     // helper methods
     //    public static native void setSurfaceView(GeckoSurfaceView sv);
     public static native void setLayerClient(Object client);
     public static native void onResume();
     public static void callObserver(String observerKey, String topic, String data) {
         sendEventToGecko(GeckoEvent.createCallObserverEvent(observerKey, topic, data));
     }
     public static void removeObserver(String observerKey) {
         sendEventToGecko(GeckoEvent.createRemoveObserverEvent(observerKey));
     }
     public static native Message getNextMessageFromQueue(MessageQueue queue);
     public static native void onSurfaceTextureFrameAvailable(Object surfaceTexture, int id);
     public static native void dispatchMemoryPressure();
     public static void registerGlobalExceptionHandler() {
         Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
             @Override
             public void uncaughtException(Thread thread, Throwable e) {
                 handleUncaughtException(thread, e);
             }
         });
     }
     private static String getStackTraceString(Throwable e) {
         StringWriter sw = new StringWriter();
         PrintWriter pw = new PrintWriter(sw);
         e.printStackTrace(pw);
         pw.flush();
         return sw.toString();
     }
     private static native void reportJavaCrash(String stackTrace);
     public static void notifyUriVisited(String uri) {
         sendEventToGecko(GeckoEvent.createVisitedEvent(uri));
     }
     public static native void processNextNativeEvent(boolean mayWait);
     public static native void notifyBatteryChange(double aLevel, boolean aCharging, double aRemainingTime);
     public static native void scheduleComposite();
     // Resuming the compositor is a synchronous request, so be
     // careful of possible deadlock. Resuming the compositor will also cause
     // a composition, so there is no need to schedule a composition after
     // resuming.
     public static native void scheduleResumeComposition(int width, int height);
     public static native float computeRenderIntegrity();
     public static native SurfaceBits getSurfaceBits(Surface surface);
     public static native void onFullScreenPluginHidden(View view);
     public static class CreateShortcutFaviconLoadedListener implements OnFaviconLoadedListener {
         private final String title;
         private final String url;
         public CreateShortcutFaviconLoadedListener(final String url, final String title) {
             this.url = url;
             this.title = title;
         }
         @Override
         public void onFaviconLoaded(String pageUrl, String faviconURL, Bitmap favicon) {
             GeckoAppShell.createShortcut(title, url, url, favicon, "");
         }
     }
     private static final class GeckoMediaScannerClient implements MediaScannerConnectionClient {
         private final String mFile;
         private final String mMimeType;
         private MediaScannerConnection mScanner;
         public static void startScan(Context context, String file, String mimeType) {
             new GeckoMediaScannerClient(context, file, mimeType);
         }
         private GeckoMediaScannerClient(Context context, String file, String mimeType) {
             mFile = file;
             mMimeType = mimeType;
             mScanner = new MediaScannerConnection(context, this);
             mScanner.connect();
         }
         @Override
         public void onMediaScannerConnected() {
             mScanner.scanFile(mFile, mMimeType);
         }
         @Override
         public void onScanCompleted(String path, Uri uri) {
             if(path.equals(mFile)) {
                 mScanner.disconnect();
                 mScanner = null;
             }
         }
     }
     private static LayerView sLayerView;
     public static void setLayerView(LayerView lv) {
         sLayerView = lv;
     }
     @RobocopTarget
     public static LayerView getLayerView() {
         return sLayerView;
     }
     public static void runGecko(String apkPath, String args, String url, String type) {
         // Preparation for pumpMessageLoop()
         MessageQueue.IdleHandler idleHandler = new MessageQueue.IdleHandler() {
             @Override public boolean queueIdle() {
                 final Handler geckoHandler = ThreadUtils.sGeckoHandler;
                 Message idleMsg = Message.obtain(geckoHandler);
                 // Use |Message.obj == GeckoHandler| to identify our "queue is empty" message
                 idleMsg.obj = geckoHandler;
                 geckoHandler.sendMessageAtFrontOfQueue(idleMsg);
                 // Keep this IdleHandler
                 return true;
             }
         };
         Looper.myQueue().addIdleHandler(idleHandler);
         // run gecko -- it will spawn its own thread
         GeckoAppShell.nativeInit();
         if (sLayerView != null)
             GeckoAppShell.setLayerClient(sLayerView.getLayerClientObject());
         // First argument is the .apk path
         String combinedArgs = apkPath + " -greomni " + apkPath;
         if (args != null)
             combinedArgs += " " + args;
         if (url != null)
             combinedArgs += " -url " + url;
         if (type != null)
             combinedArgs += " " + type;
         DisplayMetrics metrics = getContext().getResources().getDisplayMetrics();
         combinedArgs += " -width " + metrics.widthPixels + " -height " + metrics.heightPixels;
         ThreadUtils.postToUiThread(new Runnable() {
                 @Override
                 public void run() {
                     geckoLoaded();
                 }
             });
         // and go
         Log.d(LOGTAG, "GeckoLoader.nativeRun " + combinedArgs);
         GeckoLoader.nativeRun(combinedArgs);
         // Remove pumpMessageLoop() idle handler
         Looper.myQueue().removeIdleHandler(idleHandler);
     }
     // Called on the UI thread after Gecko loads.
     private static void geckoLoaded() {
         GeckoEditable editable = new GeckoEditable();
         // install the gecko => editable listener
         editableListener = editable;
     }
     static void sendPendingEventsToGecko() {
         try {
             while (!PENDING_EVENTS.isEmpty()) {
                 final GeckoEvent e = PENDING_EVENTS.poll();
                 notifyGeckoOfEvent(e);
             }
         } catch (NoSuchElementException e) {}
     }
     /**
      * If the Gecko thread is running, immediately dispatches the event to
      * Gecko.
      *
      * If the Gecko thread is not running, queues the event. If the queue is
      * full, throws {@link IllegalStateException}.
      *
      * Queued events will be dispatched in order of arrival when the Gecko
      * thread becomes live.
      *
      * This method can be called from any thread.
      *
      * @param e
      *            the event to dispatch. Cannot be null.
      */
     @RobocopTarget
     public static void sendEventToGecko(GeckoEvent e) {
         if (e == null) {
             throw new IllegalArgumentException("e cannot be null.");
         }
         if (GeckoThread.checkLaunchState(GeckoThread.LaunchState.GeckoRunning)) {
             notifyGeckoOfEvent(e);
             // Gecko will copy the event data into a normal C++ object. We can recycle the event now.
             e.recycle();
             return;
         }
         // Throws if unable to add the event due to capacity restrictions.
         PENDING_EVENTS.add(e);
     }
     // Tell the Gecko event loop that an event is available.
     public static native void notifyGeckoOfEvent(GeckoEvent event);
     /*
      *  The Gecko-side API: API methods that Gecko calls
      */
     @WrapElementForJNI(allowMultithread = true, generateStatic = true, noThrow = true)
     public static void handleUncaughtException(Thread thread, Throwable e) {
         if (GeckoThread.checkLaunchState(GeckoThread.LaunchState.GeckoExited)) {
             // We've called System.exit. All exceptions after this point are Android
             // berating us for being nasty to it.
             return;
         }
         if (thread == null) {
             thread = Thread.currentThread();
         }
         // If the uncaught exception was rethrown, walk the exception `cause` chain to find
         // the original exception so Socorro can correctly collate related crash reports.
         Throwable cause;
         while ((cause = e.getCause()) != null) {
             e = cause;
         }
         try {
             Log.e(LOGTAG, ">>> REPORTING UNCAUGHT EXCEPTION FROM THREAD "
                           + thread.getId() + " (\"" + thread.getName() + "\")", e);
             Thread mainThread = ThreadUtils.getUiThread();
             if (mainThread != null && thread != mainThread) {
                 Log.e(LOGTAG, "Main thread stack:");
                 for (StackTraceElement ste : mainThread.getStackTrace()) {
                     Log.e(LOGTAG, ste.toString());
                 }
             }
             if (e instanceof OutOfMemoryError) {
                 SharedPreferences prefs = getSharedPreferences();
                 SharedPreferences.Editor editor = prefs.edit();
                 editor.putBoolean(GeckoApp.PREFS_OOM_EXCEPTION, true);
                 editor.commit();
             }
         } finally {
             reportJavaCrash(getStackTraceString(e));
         }
     }
     @WrapElementForJNI(generateStatic = true)
     public static void notifyIME(int type) {
         if (editableListener != null) {
             editableListener.notifyIME(type);
         }
     }
     @WrapElementForJNI(generateStatic = true)
     public static void notifyIMEContext(int state, String typeHint,
                                         String modeHint, String actionHint) {
         if (editableListener != null) {
             editableListener.notifyIMEContext(state, typeHint,
                                                modeHint, actionHint);
         }
     }
     @WrapElementForJNI(generateStatic = true)
     public static void notifyIMEChange(String text, int start, int end, int newEnd) {
         if (newEnd < 0) { // Selection change
             editableListener.onSelectionChange(start, end);
         } else { // Text change
             editableListener.onTextChange(text, start, end, newEnd);
         }
     }
     private static final Object sEventAckLock = new Object();
     private static boolean sWaitingForEventAck;
     // Block the current thread until the Gecko event loop is caught up
     public static void sendEventToGeckoSync(GeckoEvent e) {
         e.setAckNeeded(true);
         long time = SystemClock.uptimeMillis();
         boolean isUiThread = ThreadUtils.isOnUiThread();
         synchronized (sEventAckLock) {
             if (sWaitingForEventAck) {
                 // should never happen since we always leave it as false when we exit this function.
                 Log.e(LOGTAG, "geckoEventSync() may have been called twice concurrently!", new Exception());
                 // fall through for graceful handling
             }
             sendEventToGecko(e);
             sWaitingForEventAck = true;
             while (true) {
                 try {
                     sEventAckLock.wait(1000);
                 } catch (InterruptedException ie) {
                 }
                 if (!sWaitingForEventAck) {
                     // response received
                     break;
                 }
                 long waited = SystemClock.uptimeMillis() - time;
                 Log.d(LOGTAG, "Gecko event sync taking too long: " + waited + "ms");
             }
         }
     }
     // Signal the Java thread that it's time to wake up
     @WrapElementForJNI
     public static void acknowledgeEvent() {
         synchronized (sEventAckLock) {
             sWaitingForEventAck = false;
             sEventAckLock.notifyAll();
         }
     }
     private static float getLocationAccuracy(Location location) {
         float radius = location.getAccuracy();
         return (location.hasAccuracy() && radius > 0) ? radius : 1001;
     }
     private static Location getLastKnownLocation(LocationManager lm) {
         Location lastKnownLocation = null;
         List<String> providers = lm.getAllProviders();
         for (String provider : providers) {
             Location location = lm.getLastKnownLocation(provider);
             if (location == null) {
                 continue;
             }
             if (lastKnownLocation == null) {
                 lastKnownLocation = location;
                 continue;
             }
             long timeDiff = location.getTime() - lastKnownLocation.getTime();
             if (timeDiff > 0 ||
                 (timeDiff == 0 &&
                  getLocationAccuracy(location) < getLocationAccuracy(lastKnownLocation))) {
                 lastKnownLocation = location;
             }
         }
         return lastKnownLocation;
     }
     @WrapElementForJNI
     public static void enableLocation(final boolean enable) {
         ThreadUtils.postToUiThread(new Runnable() {
                 @Override
                 public void run() {
                     LocationManager lm = getLocationManager(getContext());
                     if (lm == null) {
                         return;
                     }
                     if (enable) {
                         Location lastKnownLocation = getLastKnownLocation(lm);
                         if (lastKnownLocation != null) {
                             getGeckoInterface().getLocationListener().onLocationChanged(lastKnownLocation);
                         }
                         Criteria criteria = new Criteria();
                         criteria.setSpeedRequired(false);
                         criteria.setBearingRequired(false);
                         criteria.setAltitudeRequired(false);
                         if (locationHighAccuracyEnabled) {
                             criteria.setAccuracy(Criteria.ACCURACY_FINE);
                             criteria.setCostAllowed(true);
                             criteria.setPowerRequirement(Criteria.POWER_HIGH);
                         } else {
                             criteria.setAccuracy(Criteria.ACCURACY_COARSE);
                             criteria.setCostAllowed(false);
                             criteria.setPowerRequirement(Criteria.POWER_LOW);
                         }
                         String provider = lm.getBestProvider(criteria, true);
                         if (provider == null)
                             return;
                         Looper l = Looper.getMainLooper();
                         lm.requestLocationUpdates(provider, 100, (float).5, getGeckoInterface().getLocationListener(), l);
                     } else {
                         lm.removeUpdates(getGeckoInterface().getLocationListener());
                     }
                 }
             });
     }
     private static LocationManager getLocationManager(Context context) {
         try {
             return (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
         } catch (NoSuchFieldError e) {
             // Some Tegras throw exceptions about missing the CONTROL_LOCATION_UPDATES permission,
             // which allows enabling/disabling location update notifications from the cell radio.
             // CONTROL_LOCATION_UPDATES is not for use by normal applications, but we might be
             // hitting this problem if the Tegras are confused about missing cell radios.
             Log.e(LOGTAG, "LOCATION_SERVICE not found?!", e);
             return null;
         }
     }
     @WrapElementForJNI
     public static void enableLocationHighAccuracy(final boolean enable) {
         locationHighAccuracyEnabled = enable;
     }
     @WrapElementForJNI
     public static void enableSensor(int aSensortype) {
         GeckoInterface gi = getGeckoInterface();
         if (gi == null)
             return;
         SensorManager sm = (SensorManager)
             getContext().getSystemService(Context.SENSOR_SERVICE);
         switch(aSensortype) {
         case GeckoHalDefines.SENSOR_ORIENTATION:
             if(gOrientationSensor == null)
                 gOrientationSensor = sm.getDefaultSensor(Sensor.TYPE_ORIENTATION);
             if (gOrientationSensor != null)
                 sm.registerListener(gi.getSensorEventListener(), gOrientationSensor, sDefaultSensorHint);
             break;
         case GeckoHalDefines.SENSOR_ACCELERATION:
             if(gAccelerometerSensor == null)
                 gAccelerometerSensor = sm.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
             if (gAccelerometerSensor != null)
                 sm.registerListener(gi.getSensorEventListener(), gAccelerometerSensor, sDefaultSensorHint);
             break;
         case GeckoHalDefines.SENSOR_PROXIMITY:
             if(gProximitySensor == null  )
                 gProximitySensor = sm.getDefaultSensor(Sensor.TYPE_PROXIMITY);
             if (gProximitySensor != null)
                 sm.registerListener(gi.getSensorEventListener(), gProximitySensor, SensorManager.SENSOR_DELAY_NORMAL);
             break;
         case GeckoHalDefines.SENSOR_LIGHT:
             if(gLightSensor == null)
                 gLightSensor = sm.getDefaultSensor(Sensor.TYPE_LIGHT);
             if (gLightSensor != null)
                 sm.registerListener(gi.getSensorEventListener(), gLightSensor, SensorManager.SENSOR_DELAY_NORMAL);
             break;
         case GeckoHalDefines.SENSOR_LINEAR_ACCELERATION:
             if(gLinearAccelerometerSensor == null)
                 gLinearAccelerometerSensor = sm.getDefaultSensor(10 /* API Level 9 - TYPE_LINEAR_ACCELERATION */);
             if (gLinearAccelerometerSensor != null)
                 sm.registerListener(gi.getSensorEventListener(), gLinearAccelerometerSensor, sDefaultSensorHint);
             break;
         case GeckoHalDefines.SENSOR_GYROSCOPE:
             if(gGyroscopeSensor == null)
                 gGyroscopeSensor = sm.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
             if (gGyroscopeSensor != null)
                 sm.registerListener(gi.getSensorEventListener(), gGyroscopeSensor, sDefaultSensorHint);
             break;
         default:
             Log.w(LOGTAG, "Error! Can't enable unknown SENSOR type " + aSensortype);
         }
     }
     @WrapElementForJNI
     public static void disableSensor(int aSensortype) {
         GeckoInterface gi = getGeckoInterface();
         if (gi == null)
             return;
         SensorManager sm = (SensorManager)
             getContext().getSystemService(Context.SENSOR_SERVICE);
         switch (aSensortype) {
         case GeckoHalDefines.SENSOR_ORIENTATION:
             if (gOrientationSensor != null)
                 sm.unregisterListener(gi.getSensorEventListener(), gOrientationSensor);
             break;
         case GeckoHalDefines.SENSOR_ACCELERATION:
             if (gAccelerometerSensor != null)
                 sm.unregisterListener(gi.getSensorEventListener(), gAccelerometerSensor);
             break;
         case GeckoHalDefines.SENSOR_PROXIMITY:
             if (gProximitySensor != null)
                 sm.unregisterListener(gi.getSensorEventListener(), gProximitySensor);
             break;
         case GeckoHalDefines.SENSOR_LIGHT:
             if (gLightSensor != null)
                 sm.unregisterListener(gi.getSensorEventListener(), gLightSensor);
             break;
         case GeckoHalDefines.SENSOR_LINEAR_ACCELERATION:
             if (gLinearAccelerometerSensor != null)
                 sm.unregisterListener(gi.getSensorEventListener(), gLinearAccelerometerSensor);
             break;
         case GeckoHalDefines.SENSOR_GYROSCOPE:
             if (gGyroscopeSensor != null)
                 sm.unregisterListener(gi.getSensorEventListener(), gGyroscopeSensor);
             break;
         default:
             Log.w(LOGTAG, "Error! Can't disable unknown SENSOR type " + aSensortype);
         }
     }
     @WrapElementForJNI
     public static void moveTaskToBack() {
         if (getGeckoInterface() != null)
             getGeckoInterface().getActivity().moveTaskToBack(true);
     }
     public static void returnIMEQueryResult(String result, int selectionStart, int selectionLength) {
         // This method may be called from JNI to report Gecko's current selection indexes, but
         // Native Fennec doesn't care because the Java code already knows the selection indexes.
     }
     @WrapElementForJNI(stubName = "NotifyXreExit")
     static void onXreExit() {
         // The launch state can only be Launched or GeckoRunning at this point
         GeckoThread.setLaunchState(GeckoThread.LaunchState.GeckoExiting);
         if (getGeckoInterface() != null) {
             if (restartScheduled) {
                 getGeckoInterface().doRestart();
             } else {
                 getGeckoInterface().getActivity().finish();
             }
         }
         systemExit();
     }
     static void systemExit() {
         Log.d(LOGTAG, "Killing via System.exit()");
         GeckoThread.setLaunchState(GeckoThread.LaunchState.GeckoExited);
         System.exit(0);
     }
     @WrapElementForJNI
     static void scheduleRestart() {
         restartScheduled = true;
     }
     public static Intent getWebappIntent(String aURI, String aOrigin, String aTitle, Bitmap aIcon) {
         Intent intent;
         if (AppConstants.MOZ_ANDROID_SYNTHAPKS) {
             Allocator slots = Allocator.getInstance(getContext());
             int index = slots.getIndexForOrigin(aOrigin);
             if (index == -1) {
                 return null;
             }
             String packageName = slots.getAppForIndex(index);
             intent = getContext().getPackageManager().getLaunchIntentForPackage(packageName);
             if (aURI != null) {
                 intent.setData(Uri.parse(aURI));
             }
         } else {
             int index;
             if (aIcon != null && !TextUtils.isEmpty(aTitle))
                 index = WebappAllocator.getInstance(getContext()).findAndAllocateIndex(aOrigin, aTitle, aIcon);
             else
                 index = WebappAllocator.getInstance(getContext()).getIndexForApp(aOrigin);
             if (index == -1)
                 return null;
             intent = getWebappIntent(index, aURI);
         }
         return intent;
     }
     // The old implementation of getWebappIntent.  Not used by MOZ_ANDROID_SYNTHAPKS.
     public static Intent getWebappIntent(int aIndex, String aURI) {
         Intent intent = new Intent();
         intent.setAction(GeckoApp.ACTION_WEBAPP_PREFIX + aIndex);
         intent.setData(Uri.parse(aURI));
         intent.setClassName(AppConstants.ANDROID_PACKAGE_NAME,
                             AppConstants.ANDROID_PACKAGE_NAME + ".WebApps$WebApp" + aIndex);
         return intent;
     }
     // "Installs" an application by creating a shortcut
     // This is the entry point from AndroidBridge.h
     @WrapElementForJNI
     static void createShortcut(String aTitle, String aURI, String aIconData, String aType) {
         if ("webapp".equals(aType)) {
             Log.w(LOGTAG, "createShortcut with no unique URI should not be used for aType = webapp!");
         }
         createShortcut(aTitle, aURI, aURI, aIconData, aType);
     }
     // For non-webapps.
     public static void createShortcut(String aTitle, String aURI, Bitmap aBitmap, String aType) {
         createShortcut(aTitle, aURI, aURI, aBitmap, aType);
     }
     // Internal, for webapps.
     static void createShortcut(final String aTitle, final String aURI, final String aUniqueURI, final String aIconData, final String aType) {
         ThreadUtils.postToBackgroundThread(new Runnable() {
             @Override
             public void run() {
                 // TODO: use the cache. Bug 961600.
                 Bitmap icon = FaviconDecoder.getMostSuitableBitmapFromDataURI(aIconData, getPreferredIconSize());
                 GeckoAppShell.doCreateShortcut(aTitle, aURI, aURI, icon, aType);
             }
         });
     }
     public static void createShortcut(final String aTitle, final String aURI, final String aUniqueURI,
                                       final Bitmap aIcon, final String aType) {
         ThreadUtils.postToBackgroundThread(new Runnable() {
             @Override
             public void run() {
                 GeckoAppShell.doCreateShortcut(aTitle, aURI, aUniqueURI, aIcon, aType);
             }
         });
     }
     /**
      * Call this method only on the background thread.
      */
     private static void doCreateShortcut(final String aTitle, final String aURI, final String aUniqueURI,
                                          final Bitmap aIcon, final String aType) {
         // The intent to be launched by the shortcut.
         Intent shortcutIntent;
         if (aType.equalsIgnoreCase(SHORTCUT_TYPE_WEBAPP)) {
             shortcutIntent = getWebappIntent(aURI, aUniqueURI, aTitle, aIcon);
         } else {
             shortcutIntent = new Intent();
             shortcutIntent.setAction(GeckoApp.ACTION_BOOKMARK);
             shortcutIntent.setData(Uri.parse(aURI));
             shortcutIntent.setClassName(AppConstants.ANDROID_PACKAGE_NAME,
                                         AppConstants.BROWSER_INTENT_CLASS_NAME);
         }
         Intent intent = new Intent();
         intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
         intent.putExtra(Intent.EXTRA_SHORTCUT_ICON, getLauncherIcon(aIcon, aType));
         if (aTitle != null) {
             intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, aTitle);
         } else {
             intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, aURI);
         }
         // Do not allow duplicate items.
         intent.putExtra("duplicate", false);
         intent.setAction("com.android.launcher.action.INSTALL_SHORTCUT");
         getContext().sendBroadcast(intent);
     }
     public static void removeShortcut(final String aTitle, final String aURI, final String aType) {
         removeShortcut(aTitle, aURI, null, aType);
     }
     public static void removeShortcut(final String aTitle, final String aURI, final String aUniqueURI, final String aType) {
         ThreadUtils.postToBackgroundThread(new Runnable() {
             @Override
             public void run() {
                 // the intent to be launched by the shortcut
                 Intent shortcutIntent;
                 if (aType.equalsIgnoreCase(SHORTCUT_TYPE_WEBAPP)) {
                     shortcutIntent = getWebappIntent(aURI, aUniqueURI, "", null);
                     if (shortcutIntent == null)
                         return;
                 } else {
                     shortcutIntent = new Intent();
                     shortcutIntent.setAction(GeckoApp.ACTION_BOOKMARK);
                     shortcutIntent.setClassName(AppConstants.ANDROID_PACKAGE_NAME,
                                                 AppConstants.BROWSER_INTENT_CLASS_NAME);
                     shortcutIntent.setData(Uri.parse(aURI));
                 }
                 Intent intent = new Intent();
                 intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
                 if (aTitle != null)
                     intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, aTitle);
                 else
                     intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, aURI);
                 intent.setAction("com.android.launcher.action.UNINSTALL_SHORTCUT");
                 getContext().sendBroadcast(intent);
             }
         });
     }
     @JNITarget
     static public int getPreferredIconSize() {
         if (android.os.Build.VERSION.SDK_INT >= 11) {
             ActivityManager am = (ActivityManager)getContext().getSystemService(Context.ACTIVITY_SERVICE);
             return am.getLauncherLargeIconSize();
         } else {
             switch (getDpi()) {
                 case DisplayMetrics.DENSITY_MEDIUM:
                     return 48;
                 case DisplayMetrics.DENSITY_XHIGH:
                     return 96;
                 case DisplayMetrics.DENSITY_HIGH:
                 default:
                     return 72;
             }
         }
     }
     static private Bitmap getLauncherIcon(Bitmap aSource, String aType) {
         final int kOffset = 6;
         final int kRadius = 5;
         int size = getPreferredIconSize();
         int insetSize = aSource != null ? size * 2 / 3 : size;
         Bitmap bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);
         Canvas canvas = new Canvas(bitmap);
         // draw a base color
         Paint paint = new Paint();
         if (aSource == null) {
             // If we aren't drawing a favicon, just use an orange color.
             paint.setColor(Color.HSVToColor(DEFAULT_LAUNCHER_ICON_HSV));
             canvas.drawRoundRect(new RectF(kOffset, kOffset, size - kOffset, size - kOffset), kRadius, kRadius, paint);
         } else if (aType.equalsIgnoreCase(SHORTCUT_TYPE_WEBAPP) || aSource.getWidth() >= insetSize || aSource.getHeight() >= insetSize) {
             // otherwise, if this is a webapp or if the icons is lare enough, just draw it
             Rect iconBounds = new Rect(0, 0, size, size);
             canvas.drawBitmap(aSource, null, iconBounds, null);
             return bitmap;
         } else {
             // otherwise use the dominant color from the icon + a layer of transparent white to lighten it somewhat
             int color = BitmapUtils.getDominantColor(aSource);
             paint.setColor(color);
             canvas.drawRoundRect(new RectF(kOffset, kOffset, size - kOffset, size - kOffset), kRadius, kRadius, paint);
             paint.setColor(Color.argb(100, 255, 255, 255));
             canvas.drawRoundRect(new RectF(kOffset, kOffset, size - kOffset, size - kOffset), kRadius, kRadius, paint);
         }
         // draw the overlay
         Bitmap overlay = BitmapUtils.decodeResource(getContext(), R.drawable.home_bg);
         canvas.drawBitmap(overlay, null, new Rect(0, 0, size, size), null);
         // draw the favicon
         if (aSource == null)
             aSource = BitmapUtils.decodeResource(getContext(), R.drawable.home_star);
         // by default, we scale the icon to this size
         int sWidth = insetSize / 2;
         int sHeight = sWidth;
         int halfSize = size / 2;
         canvas.drawBitmap(aSource,
                           null,
                           new Rect(halfSize - sWidth,
                                    halfSize - sHeight,
                                    halfSize + sWidth,
                                    halfSize + sHeight),
                           null);
         return bitmap;
     }
     @WrapElementForJNI(stubName = "GetHandlersForMimeTypeWrapper")
     static String[] getHandlersForMimeType(String aMimeType, String aAction) {
         Intent intent = getIntentForActionString(aAction);
         if (aMimeType != null && aMimeType.length() > 0)
             intent.setType(aMimeType);
         return getHandlersForIntent(intent);
     }
     @WrapElementForJNI(stubName = "GetHandlersForURLWrapper")
     static String[] getHandlersForURL(String aURL, String aAction) {
         // aURL may contain the whole URL or just the protocol
         Uri uri = aURL.indexOf(':') >= 0 ? Uri.parse(aURL) : new Uri.Builder().scheme(aURL).build();
         Intent intent = getOpenURIIntent(getContext(), uri.toString(), "",
             TextUtils.isEmpty(aAction) ? Intent.ACTION_VIEW : aAction, "");
         return getHandlersForIntent(intent);
     }
     static boolean hasHandlersForIntent(Intent intent) {
         PackageManager pm = getContext().getPackageManager();
         List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
         return !list.isEmpty();
     }
     static String[] getHandlersForIntent(Intent intent) {
         PackageManager pm = getContext().getPackageManager();
         List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
         int numAttr = 4;
         String[] ret = new String[list.size() * numAttr];
         for (int i = 0; i < list.size(); i++) {
             ResolveInfo resolveInfo = list.get(i);
             ret[i * numAttr] = resolveInfo.loadLabel(pm).toString();
             if (resolveInfo.isDefault)
                 ret[i * numAttr + 1] = "default";
             else
                 ret[i * numAttr + 1] = "";
             ret[i * numAttr + 2] = resolveInfo.activityInfo.applicationInfo.packageName;
             ret[i * numAttr + 3] = resolveInfo.activityInfo.name;
         }
         return ret;
     }
     static Intent getIntentForActionString(String aAction) {
         // Default to the view action if no other action as been specified.
         if (TextUtils.isEmpty(aAction)) {
             return new Intent(Intent.ACTION_VIEW);
         }
         return new Intent(aAction);
     }
     @WrapElementForJNI(stubName = "GetExtensionFromMimeTypeWrapper")
     static String getExtensionFromMimeType(String aMimeType) {
         return MimeTypeMap.getSingleton().getExtensionFromMimeType(aMimeType);
     }
     @WrapElementForJNI(stubName = "GetMimeTypeFromExtensionsWrapper")
     static String getMimeTypeFromExtensions(String aFileExt) {
         StringTokenizer st = new StringTokenizer(aFileExt, ".,; ");
         String type = null;
         String subType = null;
         while (st.hasMoreElements()) {
             String ext = st.nextToken();
             String mt = getMimeTypeFromExtension(ext);
             if (mt == null)
                 continue;
             int slash = mt.indexOf('/');
             String tmpType = mt.substring(0, slash);
             if (!tmpType.equalsIgnoreCase(type))
                 type = type == null ? tmpType : "*";
             String tmpSubType = mt.substring(slash + 1);
             if (!tmpSubType.equalsIgnoreCase(subType))
                 subType = subType == null ? tmpSubType : "*";
         }
         if (type == null)
             type = "*";
         if (subType == null)
             subType = "*";
         return type + "/" + subType;
     }
     static void safeStreamClose(Closeable stream) {
         try {
             if (stream != null)
                 stream.close();
         } catch (IOException e) {}
     }
     static boolean isUriSafeForScheme(Uri aUri) {
         // Bug 794034 - We don't want to pass MWI or USSD codes to the
         // dialer, and ensure the Uri class doesn't parse a URI
         // containing a fragment ('#')
         final String scheme = aUri.getScheme();
         if ("tel".equals(scheme) || "sms".equals(scheme)) {
             final String number = aUri.getSchemeSpecificPart();
             if (number.contains("#") || number.contains("*") || aUri.getFragment() != null) {
                 return false;
             }
         }
         return true;
     }
     /**
      * Given the inputs to <code>getOpenURIIntent</code>, plus an optional
      * package name and class name, create and fire an intent to open the
      * provided URI. If a class name is specified but a package name is not,
      * we will default to using the current fennec package.
      *
      * @param targetURI the string spec of the URI to open.
      * @param mimeType an optional MIME type string.
      * @param packageName an optional app package name.
      * @param className an optional intent class name.
      * @param action an Android action specifier, such as
      *               <code>Intent.ACTION_SEND</code>.
      * @param title the title to use in <code>ACTION_SEND</code> intents.
      * @return true if the activity started successfully; false otherwise.
      */
     @WrapElementForJNI
     public static boolean openUriExternal(String targetURI,
                                           String mimeType,
               @OptionalGeneratedParameter String packageName,
               @OptionalGeneratedParameter String className,
               @OptionalGeneratedParameter String action,
               @OptionalGeneratedParameter String title) {
         final Context context = getContext();
         final Intent intent = getOpenURIIntent(context, targetURI,
                                                mimeType, action, title);
         if (intent == null) {
             return false;
         }
         if (!TextUtils.isEmpty(className)) {
             if (!TextUtils.isEmpty(packageName)) {
                 intent.setClassName(packageName, className);
             } else {
                 // Default to using the fennec app context.
                 intent.setClassName(context, className);
             }
         }
         intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
         try {
             context.startActivity(intent);
             return true;
         } catch (ActivityNotFoundException e) {
             return false;
         }
     }
     /**
      * Return a <code>Uri</code> instance which is equivalent to <code>u</code>,
      * but with a guaranteed-lowercase scheme as if the API level 16 method
      * <code>u.normalizeScheme</code> had been called.
      *
      * @param u the <code>Uri</code> to normalize.
      * @return a <code>Uri</code>, which might be <code>u</code>.
      */
     static Uri normalizeUriScheme(final Uri u) {
         final String scheme = u.getScheme();
         final String lower  = scheme.toLowerCase(Locale.US);
         if (lower.equals(scheme)) {
             return u;
         }
         // Otherwise, return a new URI with a normalized scheme.
         return u.buildUpon().scheme(lower).build();
     }
     /**
      * Given a URI, a MIME type, and a title,
      * produce a share intent which can be used to query all activities
      * than can open the specified URI.
      *
      * @param context a <code>Context</code> instance.
      * @param targetURI the string spec of the URI to open.
      * @param mimeType an optional MIME type string.
      * @param title the title to use in <code>ACTION_SEND</code> intents.
      * @return an <code>Intent</code>, or <code>null</code> if none could be
      *         produced.
      */
     public static Intent getShareIntent(final Context context,
                                         final String targetURI,
                                         final String mimeType,
                                         final String title) {
         Intent shareIntent = getIntentForActionString(Intent.ACTION_SEND);
         shareIntent.putExtra(Intent.EXTRA_TEXT, targetURI);
         shareIntent.putExtra(Intent.EXTRA_SUBJECT, title);
         // Note that EXTRA_TITLE is intended to be used for share dialog
         // titles. Common usage (e.g., Pocket) suggests that it's sometimes
         // interpreted as an alternate to EXTRA_SUBJECT, so we include it.
         shareIntent.putExtra(Intent.EXTRA_TITLE, title);
         if (mimeType != null && mimeType.length() > 0) {
             shareIntent.setType(mimeType);
         }
         return shareIntent;
     }
     /**
      * Given a URI, a MIME type, an Android intent "action", and a title,
      * produce an intent which can be used to start an activity to open
      * the specified URI.
      *
      * @param context a <code>Context</code> instance.
      * @param targetURI the string spec of the URI to open.
      * @param mimeType an optional MIME type string.
      * @param action an Android action specifier, such as
      *               <code>Intent.ACTION_SEND</code>.
      * @param title the title to use in <code>ACTION_SEND</code> intents.
      * @return an <code>Intent</code>, or <code>null</code> if none could be
      *         produced.
      */
     static Intent getOpenURIIntent(final Context context,
                                    final String targetURI,
                                    final String mimeType,
                                    final String action,
                                    final String title) {
         if (action.equalsIgnoreCase(Intent.ACTION_SEND)) {
             Intent shareIntent = getShareIntent(context, targetURI, mimeType, title);
             return Intent.createChooser(shareIntent,
                                         context.getResources().getString(R.string.share_title));
         }
         final Uri uri = normalizeUriScheme(targetURI.indexOf(':') >= 0 ? Uri.parse(targetURI) : new Uri.Builder().scheme(targetURI).build());
         if (mimeType.length() > 0) {
             Intent intent = getIntentForActionString(action);
             intent.setDataAndType(uri, mimeType);
             return intent;
         }
         if (!isUriSafeForScheme(uri)) {
             return null;
         }
         final String scheme = uri.getScheme();
         final Intent intent;
         // Compute our most likely intent, then check to see if there are any
         // custom handlers that would apply.
         // Start with the original URI. If we end up modifying it, we'll
         // overwrite it.
         final Intent likelyIntent = getIntentForActionString(action);
         likelyIntent.setData(uri);
         if ("vnd.youtube".equals(scheme) && !hasHandlersForIntent(likelyIntent)) {
             // Special-case YouTube to use our own player if no system handler
             // exists.
             intent = new Intent(VideoPlayer.VIDEO_ACTION);
             intent.setClassName(AppConstants.ANDROID_PACKAGE_NAME,
                                 "org.mozilla.gecko.VideoPlayer");
             intent.setData(uri);
         } else {
             intent = likelyIntent;
         }
         // Have a special handling for SMS, as the message body
         // is not extracted from the URI automatically.
         if (!"sms".equals(scheme)) {
             return intent;
         }
         final String query = uri.getEncodedQuery();
         if (TextUtils.isEmpty(query)) {
             return intent;
         }
         final String[] fields = query.split("&");
         boolean foundBody = false;
         String resultQuery = "";
         for (String field : fields) {
             if (foundBody || !field.startsWith("body=")) {
                 resultQuery = resultQuery.concat(resultQuery.length() > 0 ? "&" + field : field);
                 continue;
             }
             // Found the first body param. Put it into the intent.
             final String body = Uri.decode(field.substring(5));
             intent.putExtra("sms_body", body);
             foundBody = true;
         }
         if (!foundBody) {
             // No need to rewrite the URI, then.
             return intent;
         }
         // Form a new URI without the body field in the query part, and
         // push that into the new Intent.
         final String newQuery = resultQuery.length() > 0 ? "?" + resultQuery : "";
         final Uri pruned = uri.buildUpon().encodedQuery(newQuery).build();
         intent.setData(pruned);
         return intent;
     }
     /**
      * Only called from GeckoApp.
      */
     public static void setNotificationClient(NotificationClient client) {
         if (notificationClient == null) {
             notificationClient = client;
         } else {
             Log.d(LOGTAG, "Notification client already set");
         }
     }
     @WrapElementForJNI(stubName = "ShowAlertNotificationWrapper")
     public static void showAlertNotification(String aImageUrl, String aAlertTitle, String aAlertText,
                                              String aAlertCookie, String aAlertName) {
         // The intent to launch when the user clicks the expanded notification
         String app = getContext().getClass().getName();
         Intent notificationIntent = new Intent(GeckoApp.ACTION_ALERT_CALLBACK);
         notificationIntent.setClassName(AppConstants.ANDROID_PACKAGE_NAME, app);
         notificationIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
         int notificationID = aAlertName.hashCode();
         // Put the strings into the intent as an URI "alert:?name=<alertName>&app=<appName>&cookie=<cookie>"
         Uri.Builder b = new Uri.Builder();
         Uri dataUri = b.scheme("alert").path(Integer.toString(notificationID))
                                        .appendQueryParameter("name", aAlertName)
                                        .appendQueryParameter("cookie", aAlertCookie)
                                        .build();
         notificationIntent.setData(dataUri);
         PendingIntent contentIntent = PendingIntent.getActivity(
                 getContext(), 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);
         ALERT_COOKIES.put(aAlertName, aAlertCookie);
         callObserver(aAlertName, "alertshow", aAlertCookie);
         notificationClient.add(notificationID, aImageUrl, aAlertTitle, aAlertText, contentIntent);
     }
     @WrapElementForJNI
     public static void alertsProgressListener_OnProgress(String aAlertName, long aProgress, long aProgressMax, String aAlertText) {
         int notificationID = aAlertName.hashCode();
         notificationClient.update(notificationID, aProgress, aProgressMax, aAlertText);
     }
     @WrapElementForJNI
     public static void closeNotification(String aAlertName) {
         String alertCookie = ALERT_COOKIES.get(aAlertName);
         if (alertCookie != null) {
             callObserver(aAlertName, "alertfinished", alertCookie);
             ALERT_COOKIES.remove(aAlertName);
         }
         removeObserver(aAlertName);
         int notificationID = aAlertName.hashCode();
         notificationClient.remove(notificationID);
     }
     public static void handleNotification(String aAction, String aAlertName, String aAlertCookie) {
         int notificationID = aAlertName.hashCode();
         if (GeckoApp.ACTION_ALERT_CALLBACK.equals(aAction)) {
             callObserver(aAlertName, "alertclickcallback", aAlertCookie);
             if (notificationClient.isOngoing(notificationID)) {
                 // When clicked, keep the notification if it displays progress
                 return;
             }
         }
         closeNotification(aAlertName);
     }
     @WrapElementForJNI(stubName = "GetDpiWrapper")
     public static int getDpi() {
         if (sDensityDpi == 0) {
             sDensityDpi = getContext().getResources().getDisplayMetrics().densityDpi;
         }
         return sDensityDpi;
     }
     @WrapElementForJNI
     public static float getDensity() {
         return getContext().getResources().getDisplayMetrics().density;
     }
     private static boolean isHighMemoryDevice() {
         return HardwareUtils.getMemSize() > HIGH_MEMORY_DEVICE_THRESHOLD_MB;
     }
     /**
      * Returns the colour depth of the default screen. This will either be
      * 24 or 16.
      */
     @WrapElementForJNI(stubName = "GetScreenDepthWrapper")
     public static synchronized int getScreenDepth() {
         if (sScreenDepth == 0) {
             sScreenDepth = 16;
             PixelFormat info = new PixelFormat();
             PixelFormat.getPixelFormatInfo(getGeckoInterface().getActivity().getWindowManager().getDefaultDisplay().getPixelFormat(), info);
             if (info.bitsPerPixel >= 24 && isHighMemoryDevice()) {
                 sScreenDepth = 24;
             }
         }
         return sScreenDepth;
     }
     public static synchronized void setScreenDepthOverride(int aScreenDepth) {
         if (sScreenDepth != 0) {
             Log.e(LOGTAG, "Tried to override screen depth after it's already been set");
             return;
         }
         sScreenDepth = aScreenDepth;
     }
     @WrapElementForJNI
     public static void setFullScreen(boolean fullscreen) {
         if (getGeckoInterface() != null)
             getGeckoInterface().setFullScreen(fullscreen);
     }
     @WrapElementForJNI
     public static void performHapticFeedback(boolean aIsLongPress) {
         // Don't perform haptic feedback if a vibration is currently playing,
         // because the haptic feedback will nuke the vibration.
         if (!sVibrationMaybePlaying || System.nanoTime() >= sVibrationEndTime) {
             LayerView layerView = getLayerView();
             layerView.performHapticFeedback(aIsLongPress ?
                                             HapticFeedbackConstants.LONG_PRESS :
                                             HapticFeedbackConstants.VIRTUAL_KEY);
         }
     }
     private static Vibrator vibrator() {
         LayerView layerView = getLayerView();
         return (Vibrator) layerView.getContext().getSystemService(Context.VIBRATOR_SERVICE);
     }
     @WrapElementForJNI(stubName = "Vibrate1")
     public static void vibrate(long milliseconds) {
         sVibrationEndTime = System.nanoTime() + milliseconds * 1000000;
         sVibrationMaybePlaying = true;
         vibrator().vibrate(milliseconds);
     }
     @WrapElementForJNI(stubName = "VibrateA")
     public static void vibrate(long[] pattern, int repeat) {
         // If pattern.length is even, the last element in the pattern is a
         // meaningless delay, so don't include it in vibrationDuration.
         long vibrationDuration = 0;
         int iterLen = pattern.length - (pattern.length % 2 == 0 ? 1 : 0);
         for (int i = 0; i < iterLen; i++) {
           vibrationDuration += pattern[i];
         }
         sVibrationEndTime = System.nanoTime() + vibrationDuration * 1000000;
         sVibrationMaybePlaying = true;
         vibrator().vibrate(pattern, repeat);
     }
     @WrapElementForJNI
     public static void cancelVibrate() {
         sVibrationMaybePlaying = false;
         sVibrationEndTime = 0;
         vibrator().cancel();
     }
     @WrapElementForJNI
     public static void showInputMethodPicker() {
         InputMethodManager imm = (InputMethodManager)
             getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
         imm.showInputMethodPicker();
     }
     @WrapElementForJNI
     public static void setKeepScreenOn(final boolean on) {
         ThreadUtils.postToUiThread(new Runnable() {
             @Override
             public void run() {
                 // TODO
             }
         });
     }
     @WrapElementForJNI
     public static void notifyDefaultPrevented(final boolean defaultPrevented) {
         ThreadUtils.postToUiThread(new Runnable() {
             @Override
             public void run() {
                 LayerView view = getLayerView();
                 PanZoomController controller = (view == null ? null : view.getPanZoomController());
                 if (controller != null) {
                     controller.notifyDefaultActionPrevented(defaultPrevented);
                 }
             }
         });
     }
     @WrapElementForJNI
     public static boolean isNetworkLinkUp() {
         ConnectivityManager cm = (ConnectivityManager)
            getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
         try {
             NetworkInfo info = cm.getActiveNetworkInfo();
             if (info == null || !info.isConnected())
                 return false;
         } catch (SecurityException se) {
             return false;
         }
         return true;
     }
     @WrapElementForJNI
     public static boolean isNetworkLinkKnown() {
         ConnectivityManager cm = (ConnectivityManager)
             getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
         try {
             if (cm.getActiveNetworkInfo() == null)
                 return false;
         } catch (SecurityException se) {
             return false;
         }
         return true;
     }
     @WrapElementForJNI
     public static int networkLinkType() {
         ConnectivityManager cm = (ConnectivityManager)
             getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
         NetworkInfo info = cm.getActiveNetworkInfo();
         if (info == null) {
             return LINK_TYPE_UNKNOWN;
         }
         switch (info.getType()) {
             case ConnectivityManager.TYPE_ETHERNET:
                 return LINK_TYPE_ETHERNET;
             case ConnectivityManager.TYPE_WIFI:
                 return LINK_TYPE_WIFI;
             case ConnectivityManager.TYPE_WIMAX:
                 return LINK_TYPE_WIMAX;
             case ConnectivityManager.TYPE_MOBILE:
                 break; // We will handle sub-types after the switch.
             default:
                 Log.w(LOGTAG, "Ignoring the current network type.");
                 return LINK_TYPE_UNKNOWN;
         }
         TelephonyManager tm = (TelephonyManager)
             getContext().getSystemService(Context.TELEPHONY_SERVICE);
         if (tm == null) {
             Log.e(LOGTAG, "Telephony service does not exist");
             return LINK_TYPE_UNKNOWN;
         }
         switch (tm.getNetworkType()) {
             case TelephonyManager.NETWORK_TYPE_IDEN:
             case TelephonyManager.NETWORK_TYPE_CDMA:
             case TelephonyManager.NETWORK_TYPE_GPRS:
                 return LINK_TYPE_2G;
             case TelephonyManager.NETWORK_TYPE_1xRTT:
             case TelephonyManager.NETWORK_TYPE_EDGE:
                 return LINK_TYPE_2G; // 2.5G
             case TelephonyManager.NETWORK_TYPE_UMTS:
             case TelephonyManager.NETWORK_TYPE_EVDO_0:
                 return LINK_TYPE_3G;
             case TelephonyManager.NETWORK_TYPE_HSPA:
             case TelephonyManager.NETWORK_TYPE_HSDPA:
             case TelephonyManager.NETWORK_TYPE_HSUPA:
             case TelephonyManager.NETWORK_TYPE_EVDO_A:
             case TelephonyManager.NETWORK_TYPE_EVDO_B:
             case TelephonyManager.NETWORK_TYPE_EHRPD:
                 return LINK_TYPE_3G; // 3.5G
             case TelephonyManager.NETWORK_TYPE_HSPAP:
                 return LINK_TYPE_3G; // 3.75G
             case TelephonyManager.NETWORK_TYPE_LTE:
                 return LINK_TYPE_4G; // 3.9G
             case TelephonyManager.NETWORK_TYPE_UNKNOWN:
             default:
                 Log.w(LOGTAG, "Connected to an unknown mobile network!");
                 return LINK_TYPE_UNKNOWN;
         }
     }
     @WrapElementForJNI(stubName = "GetSystemColoursWrapper")
     public static int[] getSystemColors() {
         // attrsAppearance[] must correspond to AndroidSystemColors structure in android/AndroidBridge.h
         final int[] attrsAppearance = {
             android.R.attr.textColor,
             android.R.attr.textColorPrimary,
             android.R.attr.textColorPrimaryInverse,
             android.R.attr.textColorSecondary,
             android.R.attr.textColorSecondaryInverse,
             android.R.attr.textColorTertiary,
             android.R.attr.textColorTertiaryInverse,
             android.R.attr.textColorHighlight,
             android.R.attr.colorForeground,
             android.R.attr.colorBackground,
             android.R.attr.panelColorForeground,
             android.R.attr.panelColorBackground
         };
         int[] result = new int[attrsAppearance.length];
         final ContextThemeWrapper contextThemeWrapper =
             new ContextThemeWrapper(getContext(), android.R.style.TextAppearance);
         final TypedArray appearance = contextThemeWrapper.getTheme().obtainStyledAttributes(attrsAppearance);
         if (appearance != null) {
             for (int i = 0; i < appearance.getIndexCount(); i++) {
                 int idx = appearance.getIndex(i);
                 int color = appearance.getColor(idx, 0);
                 result[idx] = color;
             }
             appearance.recycle();
         }
         return result;
     }
     @WrapElementForJNI
     public static void killAnyZombies() {
         GeckoProcessesVisitor visitor = new GeckoProcessesVisitor() {
             @Override
             public boolean callback(int pid) {
                 if (pid != android.os.Process.myPid())
                     android.os.Process.killProcess(pid);
                 return true;
             }
         };
         EnumerateGeckoProcesses(visitor);
     }
     public static boolean checkForGeckoProcs() {
         class GeckoPidCallback implements GeckoProcessesVisitor {
             public boolean otherPidExist = false;
             @Override
             public boolean callback(int pid) {
                 if (pid != android.os.Process.myPid()) {
                     otherPidExist = true;
                     return false;
                 }
                 return true;
             }
         }
         GeckoPidCallback visitor = new GeckoPidCallback();
         EnumerateGeckoProcesses(visitor);
         return visitor.otherPidExist;
     }
     interface GeckoProcessesVisitor{
         boolean callback(int pid);
     }
     private static void EnumerateGeckoProcesses(GeckoProcessesVisitor visiter) {
         int pidColumn = -1;
         int userColumn = -1;
         try {
             // run ps and parse its output
             java.lang.Process ps = Runtime.getRuntime().exec("ps");
             BufferedReader in = new BufferedReader(new InputStreamReader(ps.getInputStream()),
 );
             String headerOutput = in.readLine();
             // figure out the column offsets.  We only care about the pid and user fields
             StringTokenizer st = new StringTokenizer(headerOutput);
             int tokenSoFar = 0;
             while (st.hasMoreTokens()) {
                 String next = st.nextToken();
                 if (next.equalsIgnoreCase("PID"))
                     pidColumn = tokenSoFar;
                 else if (next.equalsIgnoreCase("USER"))
                     userColumn = tokenSoFar;
                 tokenSoFar++;
             }
             // alright, the rest are process entries.
             String psOutput = null;
             while ((psOutput = in.readLine()) != null) {
                 String[] split = psOutput.split("\\s+");
                 if (split.length <= pidColumn || split.length <= userColumn)
                     continue;
                 int uid = android.os.Process.getUidForName(split[userColumn]);
                 if (uid == android.os.Process.myUid() &&
                     !split[split.length - 1].equalsIgnoreCase("ps")) {
                     int pid = Integer.parseInt(split[pidColumn]);
                     boolean keepGoing = visiter.callback(pid);
                     if (keepGoing == false)
                         break;
                 }
             }
             in.close();
         }
         catch (Exception e) {
             Log.w(LOGTAG, "Failed to enumerate Gecko processes.",  e);
         }
     }
     public static void waitForAnotherGeckoProc(){
         int countdown = 40;
         while (!checkForGeckoProcs() &&  --countdown > 0) {
             try {
                 Thread.sleep(100);
             } catch (InterruptedException ie) {}
         }
     }
     public static String getAppNameByPID(int pid) {
         BufferedReader cmdlineReader = null;
         String path = "/proc/" + pid + "/cmdline";
         try {
             File cmdlineFile = new File(path);
             if (!cmdlineFile.exists())
                 return "";
             cmdlineReader = new BufferedReader(new FileReader(cmdlineFile));
             return cmdlineReader.readLine().trim();
         } catch (Exception ex) {
             return "";
         } finally {
             if (null != cmdlineReader) {
                 try {
                     cmdlineReader.close();
                 } catch (Exception e) {}
             }
         }
     }
     public static void listOfOpenFiles() {
         int pidColumn = -1;
         int nameColumn = -1;
         try {
             String filter = GeckoProfile.get(getContext()).getDir().toString();
             Log.i(LOGTAG, "[OPENFILE] Filter: " + filter);
             // run lsof and parse its output
             java.lang.Process lsof = Runtime.getRuntime().exec("lsof");
             BufferedReader in = new BufferedReader(new InputStreamReader(lsof.getInputStream()), 2048);
             String headerOutput = in.readLine();
             StringTokenizer st = new StringTokenizer(headerOutput);
             int token = 0;
             while (st.hasMoreTokens()) {
                 String next = st.nextToken();
                 if (next.equalsIgnoreCase("PID"))
                     pidColumn = token;
                 else if (next.equalsIgnoreCase("NAME"))
                     nameColumn = token;
                 token++;
             }
             // alright, the rest are open file entries.
             Map<Integer, String> pidNameMap = new TreeMap<Integer, String>();
             String output = null;
             while ((output = in.readLine()) != null) {
                 String[] split = output.split("\\s+");
                 if (split.length <= pidColumn || split.length <= nameColumn)
                     continue;
                 Integer pid = new Integer(split[pidColumn]);
                 String name = pidNameMap.get(pid);
                 if (name == null) {
                     name = getAppNameByPID(pid.intValue());
                     pidNameMap.put(pid, name);
                 }
                 String file = split[nameColumn];
                 if (!TextUtils.isEmpty(name) && !TextUtils.isEmpty(file) && file.startsWith(filter))
                     Log.i(LOGTAG, "[OPENFILE] " + name + "(" + split[pidColumn] + ") : " + file);
             }
             in.close();
         } catch (Exception e) { }
     }
     @WrapElementForJNI
     public static void scanMedia(String aFile, String aMimeType) {
         // If the platform didn't give us a mimetype, try to guess one from the filename
         if (TextUtils.isEmpty(aMimeType)) {
             int extPosition = aFile.lastIndexOf(".");
             if (extPosition > 0 && extPosition < aFile.length() - 1) {
                 aMimeType = getMimeTypeFromExtension(aFile.substring(extPosition+1));
             }
         }
         Context context = getContext();
         GeckoMediaScannerClient.startScan(context, aFile, aMimeType);
     }
     @WrapElementForJNI(stubName = "GetIconForExtensionWrapper")
     public static byte[] getIconForExtension(String aExt, int iconSize) {
         try {
             if (iconSize <= 0)
                 iconSize = 16;
             if (aExt != null && aExt.length() > 1 && aExt.charAt(0) == '.')
                 aExt = aExt.substring(1);
             PackageManager pm = getContext().getPackageManager();
             Drawable icon = getDrawableForExtension(pm, aExt);
             if (icon == null) {
                 // Use a generic icon
                 icon = pm.getDefaultActivityIcon();
             }
             Bitmap bitmap = ((BitmapDrawable)icon).getBitmap();
             if (bitmap.getWidth() != iconSize || bitmap.getHeight() != iconSize)
                 bitmap = Bitmap.createScaledBitmap(bitmap, iconSize, iconSize, true);
             ByteBuffer buf = ByteBuffer.allocate(iconSize * iconSize * 4);
             bitmap.copyPixelsToBuffer(buf);
             return buf.array();
         }
         catch (Exception e) {
             Log.w(LOGTAG, "getIconForExtension failed.",  e);
             return null;
         }
     }
     private static String getMimeTypeFromExtension(String ext) {
         final MimeTypeMap mtm = MimeTypeMap.getSingleton();
         return mtm.getMimeTypeFromExtension(ext);
     }
     private static Drawable getDrawableForExtension(PackageManager pm, String aExt) {
         Intent intent = new Intent(Intent.ACTION_VIEW);
         final String mimeType = getMimeTypeFromExtension(aExt);
         if (mimeType != null && mimeType.length() > 0)
             intent.setType(mimeType);
         else
             return null;
         List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
         if (list.size() == 0)
             return null;
         ResolveInfo resolveInfo = list.get(0);
         if (resolveInfo == null)
             return null;
         ActivityInfo activityInfo = resolveInfo.activityInfo;
         return activityInfo.loadIcon(pm);
     }
     @WrapElementForJNI
     public static boolean getShowPasswordSetting() {
         try {
             int showPassword =
                 Settings.System.getInt(getContext().getContentResolver(),
                                        Settings.System.TEXT_SHOW_PASSWORD, 1);
             return (showPassword > 0);
         }
         catch (Exception e) {
             return true;
         }
     }
     @WrapElementForJNI(stubName = "AddPluginViewWrapper")
     public static void addPluginView(View view,
                                      float x, float y,
                                      float w, float h,
                                      boolean isFullScreen) {
         if (getGeckoInterface() != null)
              getGeckoInterface().addPluginView(view, new RectF(x, y, x + w, y + h), isFullScreen);
     }
     @WrapElementForJNI
     public static void removePluginView(View view, boolean isFullScreen) {
         if (getGeckoInterface() != null)
             getGeckoInterface().removePluginView(view, isFullScreen);
     }
     /**
      * A plugin that wish to be loaded in the WebView must provide this permission
      * in their AndroidManifest.xml.
      */
     public static final String PLUGIN_ACTION = "android.webkit.PLUGIN";
     public static final String PLUGIN_PERMISSION = "android.webkit.permission.PLUGIN";
     private static final String PLUGIN_SYSTEM_LIB = "/system/lib/plugins/";
     private static final String PLUGIN_TYPE = "type";
     private static final String TYPE_NATIVE = "native";
     static public ArrayList<PackageInfo> mPackageInfoCache = new ArrayList<PackageInfo>();
     // Returns null if plugins are blocked on the device.
     static String[] getPluginDirectories() {
         // An awful hack to detect Tegra devices. Easiest way to do it without spinning up a EGL context.
         boolean isTegra = (new File("/system/lib/hw/gralloc.tegra.so")).exists() ||
                           (new File("/system/lib/hw/gralloc.tegra3.so")).exists();
         if (isTegra) {
             // disable Flash on Tegra ICS with CM9 and other custom firmware (bug 736421)
             File vfile = new File("/proc/version");
             FileReader vreader = null;
             try {
                 if (vfile.canRead()) {
                     vreader = new FileReader(vfile);
                     String version = new BufferedReader(vreader).readLine();
                     if (version.indexOf("CM9") != -1 ||
                         version.indexOf("cyanogen") != -1 ||
                         version.indexOf("Nova") != -1)
                     {
                         Log.w(LOGTAG, "Blocking plugins because of Tegra 2 + unofficial ICS bug (bug 736421)");
                         return null;
                     }
                 }
             } catch (IOException ex) {
                 // nothing
             } finally {
                 try {
                     if (vreader != null) {
                         vreader.close();
                     }
                 } catch (IOException ex) {
                     // nothing
                 }
             }
             // disable on KitKat (bug 957694)
             if (Build.VERSION.SDK_INT >= 19) {
                 Log.w(LOGTAG, "Blocking plugins because of Tegra (bug 957694)");
                 return null;
             }
         }
         ArrayList<String> directories = new ArrayList<String>();
         PackageManager pm = getContext().getPackageManager();
         List<ResolveInfo> plugins = pm.queryIntentServices(new Intent(PLUGIN_ACTION),
                 PackageManager.GET_SERVICES | PackageManager.GET_META_DATA);
         synchronized(mPackageInfoCache) {
             // clear the list of existing packageInfo objects
             mPackageInfoCache.clear();
             for (ResolveInfo info : plugins) {
                 // retrieve the plugin's service information
                 ServiceInfo serviceInfo = info.serviceInfo;
                 if (serviceInfo == null) {
                     Log.w(LOGTAG, "Ignoring bad plugin.");
                     continue;
                 }
                 // Blacklist HTC's flash lite.
                 // See bug #704516 - We're not quite sure what Flash Lite does,
                 // but loading it causes Flash to give errors and fail to draw.
                 if (serviceInfo.packageName.equals("com.htc.flashliteplugin")) {
                     Log.w(LOGTAG, "Skipping HTC's flash lite plugin");
                     continue;
                 }
                 // Retrieve information from the plugin's manifest.
                 PackageInfo pkgInfo;
                 try {
                     pkgInfo = pm.getPackageInfo(serviceInfo.packageName,
                                     PackageManager.GET_PERMISSIONS
                                     | PackageManager.GET_SIGNATURES);
                 } catch (Exception e) {
                     Log.w(LOGTAG, "Can't find plugin: " + serviceInfo.packageName);
                     continue;
                 }
                 if (pkgInfo == null) {
                     Log.w(LOGTAG, "Not loading plugin: " + serviceInfo.packageName + ". Could not load package information.");
                     continue;
                 }
                 /*
                  * find the location of the plugin's shared library. The default
                  * is to assume the app is either a user installed app or an
                  * updated system app. In both of these cases the library is
                  * stored in the app's data directory.
                  */
                 String directory = pkgInfo.applicationInfo.dataDir + "/lib";
                 final int appFlags = pkgInfo.applicationInfo.flags;
                 final int updatedSystemFlags = ApplicationInfo.FLAG_SYSTEM |
                                                ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
                 // preloaded system app with no user updates
                 if ((appFlags & updatedSystemFlags) == ApplicationInfo.FLAG_SYSTEM) {
                     directory = PLUGIN_SYSTEM_LIB + pkgInfo.packageName;
                 }
                 // check if the plugin has the required permissions
                 String permissions[] = pkgInfo.requestedPermissions;
                 if (permissions == null) {
                     Log.w(LOGTAG, "Not loading plugin: " + serviceInfo.packageName + ". Does not have required permission.");
                     continue;
                 }
                 boolean permissionOk = false;
                 for (String permit : permissions) {
                     if (PLUGIN_PERMISSION.equals(permit)) {
                         permissionOk = true;
                         break;
                     }
                 }
                 if (!permissionOk) {
                     Log.w(LOGTAG, "Not loading plugin: " + serviceInfo.packageName + ". Does not have required permission (2).");
                     continue;
                 }
                 // check to ensure the plugin is properly signed
                 Signature signatures[] = pkgInfo.signatures;
                 if (signatures == null) {
                     Log.w(LOGTAG, "Not loading plugin: " + serviceInfo.packageName + ". Not signed.");
                     continue;
                 }
                 // determine the type of plugin from the manifest
                 if (serviceInfo.metaData == null) {
                     Log.e(LOGTAG, "The plugin '" + serviceInfo.name + "' has no defined type.");
                     continue;
                 }
                 String pluginType = serviceInfo.metaData.getString(PLUGIN_TYPE);
                 if (!TYPE_NATIVE.equals(pluginType)) {
                     Log.e(LOGTAG, "Unrecognized plugin type: " + pluginType);
                     continue;
                 }
                 try {
                     Class<?> cls = getPluginClass(serviceInfo.packageName, serviceInfo.name);
                     //TODO implement any requirements of the plugin class here!
                     boolean classFound = true;
                     if (!classFound) {
                         Log.e(LOGTAG, "The plugin's class' " + serviceInfo.name + "' does not extend the appropriate class.");
                         continue;
                     }
                 } catch (NameNotFoundException e) {
                     Log.e(LOGTAG, "Can't find plugin: " + serviceInfo.packageName);
                     continue;
                 } catch (ClassNotFoundException e) {
                     Log.e(LOGTAG, "Can't find plugin's class: " + serviceInfo.name);
                     continue;
                 }
                 // if all checks have passed then make the plugin available
                 mPackageInfoCache.add(pkgInfo);
                 directories.add(directory);
             }
         }
         return directories.toArray(new String[directories.size()]);
     }
     static String getPluginPackage(String pluginLib) {
         if (pluginLib == null || pluginLib.length() == 0) {
             return null;
         }
         synchronized(mPackageInfoCache) {
             for (PackageInfo pkgInfo : mPackageInfoCache) {
                 if (pluginLib.contains(pkgInfo.packageName)) {
                     return pkgInfo.packageName;
                 }
             }
         }
         return null;
     }
     static Class<?> getPluginClass(String packageName, String className)
             throws NameNotFoundException, ClassNotFoundException {
         Context pluginContext = getContext().createPackageContext(packageName,
                 Context.CONTEXT_INCLUDE_CODE |
                 Context.CONTEXT_IGNORE_SECURITY);
         ClassLoader pluginCL = pluginContext.getClassLoader();
         return pluginCL.loadClass(className);
     }
     @WrapElementForJNI(allowMultithread = true)
     public static Class<?> loadPluginClass(String className, String libName) {
         if (getGeckoInterface() == null)
             return null;
         try {
             final String packageName = getPluginPackage(libName);
             final int contextFlags = Context.CONTEXT_INCLUDE_CODE | Context.CONTEXT_IGNORE_SECURITY;
             final Context pluginContext = getContext().createPackageContext(packageName, contextFlags);
             return pluginContext.getClassLoader().loadClass(className);
         } catch (java.lang.ClassNotFoundException cnfe) {
             Log.w(LOGTAG, "Couldn't find plugin class " + className, cnfe);
             return null;
         } catch (android.content.pm.PackageManager.NameNotFoundException nnfe) {
             Log.w(LOGTAG, "Couldn't find package.", nnfe);
             return null;
         }
     }
     private static ContextGetter sContextGetter;
     @WrapElementForJNI(allowMultithread = true)
     public static Context getContext() {
         return sContextGetter.getContext();
     }
     public static void setContextGetter(ContextGetter cg) {
         sContextGetter = cg;
     }
     public static SharedPreferences getSharedPreferences() {
         if (sContextGetter == null) {
             throw new IllegalStateException("No ContextGetter; cannot fetch prefs.");
         }
         return sContextGetter.getSharedPreferences();
     }
     public interface AppStateListener {
         public void onPause();
         public void onResume();
         public void onOrientationChanged();
     }
     public interface GeckoInterface {
         public GeckoProfile getProfile();
         public PromptService getPromptService();
         public Activity getActivity();
         public String getDefaultUAString();
         public LocationListener getLocationListener();
         public SensorEventListener getSensorEventListener();
         public void doRestart();
         public void setFullScreen(boolean fullscreen);
         public void addPluginView(View view, final RectF rect, final boolean isFullScreen);
         public void removePluginView(final View view, final boolean isFullScreen);
         public void enableCameraView();
         public void disableCameraView();
         public void addAppStateListener(AppStateListener listener);
         public void removeAppStateListener(AppStateListener listener);
         public View getCameraView();
         public void notifyWakeLockChanged(String topic, String state);
         public FormAssistPopup getFormAssistPopup();
         public boolean areTabsShown();
         public AbsoluteLayout getPluginContainer();
         public void notifyCheckUpdateResult(String result);
         public boolean hasTabsSideBar();
         public void invalidateOptionsMenu();
     };
     private static GeckoInterface sGeckoInterface;
     public static GeckoInterface getGeckoInterface() {
         return sGeckoInterface;
     }
     public static void setGeckoInterface(GeckoInterface aGeckoInterface) {
         sGeckoInterface = aGeckoInterface;
     }
     public static android.hardware.Camera sCamera = null;
     static native void cameraCallbackBridge(byte[] data);
     static int kPreferedFps = 25;
     static byte[] sCameraBuffer = null;
     @WrapElementForJNI(stubName = "InitCameraWrapper")
     static int[] initCamera(String aContentType, int aCamera, int aWidth, int aHeight) {
         ThreadUtils.postToUiThread(new Runnable() {
                 @Override
                 public void run() {
                     try {
                         if (getGeckoInterface() != null)
                             getGeckoInterface().enableCameraView();
                     } catch (Exception e) {}
                 }
             });
         // [0] = 0|1 (failure/success)
         // [1] = width
         // [2] = height
         // [3] = fps
         int[] result = new int[4];
         result[0] = 0;
         if (Build.VERSION.SDK_INT >= 9) {
             if (android.hardware.Camera.getNumberOfCameras() == 0)
                 return result;
         }
         try {
             // no front/back camera before API level 9
             if (Build.VERSION.SDK_INT >= 9)
                 sCamera = android.hardware.Camera.open(aCamera);
             else
                 sCamera = android.hardware.Camera.open();
             android.hardware.Camera.Parameters params = sCamera.getParameters();
             params.setPreviewFormat(ImageFormat.NV21);
             // use the preview fps closest to 25 fps.
             int fpsDelta = 1000;
             try {
                 Iterator<Integer> it = params.getSupportedPreviewFrameRates().iterator();
                 while (it.hasNext()) {
                     int nFps = it.next();
                     if (Math.abs(nFps - kPreferedFps) < fpsDelta) {
                         fpsDelta = Math.abs(nFps - kPreferedFps);
                         params.setPreviewFrameRate(nFps);
                     }
                 }
             } catch(Exception e) {
                 params.setPreviewFrameRate(kPreferedFps);
             }
             // set up the closest preview size available
             Iterator<android.hardware.Camera.Size> sit = params.getSupportedPreviewSizes().iterator();
             int sizeDelta = 10000000;
             int bufferSize = 0;
             while (sit.hasNext()) {
                 android.hardware.Camera.Size size = sit.next();
                 if (Math.abs(size.width * size.height - aWidth * aHeight) < sizeDelta) {
                     sizeDelta = Math.abs(size.width * size.height - aWidth * aHeight);
                     params.setPreviewSize(size.width, size.height);
                     bufferSize = size.width * size.height;
                 }
             }
             try {
                 if (getGeckoInterface() != null) {
                     View cameraView = getGeckoInterface().getCameraView();
                     if (cameraView instanceof SurfaceView) {
                         sCamera.setPreviewDisplay(((SurfaceView)cameraView).getHolder());
                     } else if (cameraView instanceof TextureView) {
                         sCamera.setPreviewTexture(((TextureView)cameraView).getSurfaceTexture());
                     }
                 }
             } catch(IOException e) {
                 Log.w(LOGTAG, "Error setPreviewXXX:", e);
             } catch(RuntimeException e) {
                 Log.w(LOGTAG, "Error setPreviewXXX:", e);
             }
             sCamera.setParameters(params);
             sCameraBuffer = new byte[(bufferSize * 12) / 8];
             sCamera.addCallbackBuffer(sCameraBuffer);
             sCamera.setPreviewCallbackWithBuffer(new android.hardware.Camera.PreviewCallback() {
                 @Override
                 public void onPreviewFrame(byte[] data, android.hardware.Camera camera) {
                     cameraCallbackBridge(data);
                     if (sCamera != null)
                         sCamera.addCallbackBuffer(sCameraBuffer);
                 }
             });
             sCamera.startPreview();
             params = sCamera.getParameters();
             result[0] = 1;
             result[1] = params.getPreviewSize().width;
             result[2] = params.getPreviewSize().height;
             result[3] = params.getPreviewFrameRate();
         } catch(RuntimeException e) {
             Log.w(LOGTAG, "initCamera RuntimeException.", e);
             result[0] = result[1] = result[2] = result[3] = 0;
         }
         return result;
     }
     @WrapElementForJNI
     static synchronized void closeCamera() {
         ThreadUtils.postToUiThread(new Runnable() {
                 @Override
                 public void run() {
                     try {
                         if (getGeckoInterface() != null)
                             getGeckoInterface().disableCameraView();
                     } catch (Exception e) {}
                 }
             });
         if (sCamera != null) {
             sCamera.stopPreview();
             sCamera.release();
             sCamera = null;
             sCameraBuffer = null;
         }
     }
     /**
      * Adds a listener for a gecko event.
      * This method is thread-safe and may be called at any time. In particular, calling it
      * with an event that is currently being processed has the properly-defined behaviour that
      * any added listeners will not be invoked on the event currently being processed, but
      * will be invoked on future events of that type.
      */
     @RobocopTarget
     public static void registerEventListener(String event, GeckoEventListener listener) {
         sEventDispatcher.registerEventListener(event, listener);
     }
     public static EventDispatcher getEventDispatcher() {
         return sEventDispatcher;
     }
     /**
      * Remove a previously-registered listener for a gecko event.
      * This method is thread-safe and may be called at any time. In particular, calling it
      * with an event that is currently being processed has the properly-defined behaviour that
      * any removed listeners will still be invoked on the event currently being processed, but
      * will not be invoked on future events of that type.
      */
     @RobocopTarget
     public static void unregisterEventListener(String event, GeckoEventListener listener) {
         sEventDispatcher.unregisterEventListener(event, listener);
     }
     /*
      * Battery API related methods.
      */
     @WrapElementForJNI
     public static void enableBatteryNotifications() {
         GeckoBatteryManager.enableNotifications();
     }
     @WrapElementForJNI(stubName = "HandleGeckoMessageWrapper")
     public static void handleGeckoMessage(final NativeJSContainer message) {
         sEventDispatcher.dispatchEvent(message);
         message.dispose();
     }
     @WrapElementForJNI
     public static void disableBatteryNotifications() {
         GeckoBatteryManager.disableNotifications();
     }
     @WrapElementForJNI(stubName = "GetCurrentBatteryInformationWrapper")
     public static double[] getCurrentBatteryInformation() {
         return GeckoBatteryManager.getCurrentInformation();
     }
     @WrapElementForJNI(stubName = "CheckURIVisited")
     static void checkUriVisited(String uri) {
         GlobalHistory.getInstance().checkUriVisited(uri);
     }
     @WrapElementForJNI(stubName = "MarkURIVisited")
     static void markUriVisited(final String uri) {
         ThreadUtils.postToBackgroundThread(new Runnable() {
             @Override
             public void run() {
                 GlobalHistory.getInstance().add(uri);
             }
         });
     }
     @WrapElementForJNI(stubName = "SetURITitle")
     static void setUriTitle(final String uri, final String title) {
         ThreadUtils.postToBackgroundThread(new Runnable() {
             @Override
             public void run() {
                 GlobalHistory.getInstance().update(uri, title);
             }
         });
     }
     @WrapElementForJNI
     static void hideProgressDialog() {
         // unused stub
     }
     /*
      * WebSMS related methods.
      */
     @WrapElementForJNI(stubName = "SendMessageWrapper")
     public static void sendMessage(String aNumber, String aMessage, int aRequestId) {
         if (SmsManager.getInstance() == null) {
             return;
         }
         SmsManager.getInstance().send(aNumber, aMessage, aRequestId);
     }
     @WrapElementForJNI(stubName = "GetMessageWrapper")
     public static void getMessage(int aMessageId, int aRequestId) {
         if (SmsManager.getInstance() == null) {
             return;
         }
         SmsManager.getInstance().getMessage(aMessageId, aRequestId);
     }
     @WrapElementForJNI(stubName = "DeleteMessageWrapper")
     public static void deleteMessage(int aMessageId, int aRequestId) {
         if (SmsManager.getInstance() == null) {
             return;
         }
         SmsManager.getInstance().deleteMessage(aMessageId, aRequestId);
     }
     @WrapElementForJNI(stubName = "CreateMessageListWrapper")
     public static void createMessageList(long aStartDate, long aEndDate, String[] aNumbers, int aNumbersCount, int aDeliveryState, boolean aReverse, int aRequestId) {
         if (SmsManager.getInstance() == null) {
             return;
         }
         SmsManager.getInstance().createMessageList(aStartDate, aEndDate, aNumbers, aNumbersCount, aDeliveryState, aReverse, aRequestId);
     }
     @WrapElementForJNI(stubName = "GetNextMessageInListWrapper")
     public static void getNextMessageInList(int aListId, int aRequestId) {
         if (SmsManager.getInstance() == null) {
             return;
         }
         SmsManager.getInstance().getNextMessageInList(aListId, aRequestId);
     }
     @WrapElementForJNI
     public static void clearMessageList(int aListId) {
         if (SmsManager.getInstance() == null) {
             return;
         }
         SmsManager.getInstance().clearMessageList(aListId);
     }
     /* Called by JNI from AndroidBridge, and by reflection from tests/BaseTest.java.in */
     @WrapElementForJNI
     @RobocopTarget
     public static boolean isTablet() {
         return HardwareUtils.isTablet();
     }
     public static void viewSizeChanged() {
         LayerView v = getLayerView();
         if (v != null && v.isIMEEnabled()) {
             sendEventToGecko(GeckoEvent.createBroadcastEvent(
                     "ScrollTo:FocusedInput", ""));
         }
     }
     @WrapElementForJNI(stubName = "GetCurrentNetworkInformationWrapper")
     public static double[] getCurrentNetworkInformation() {
         return GeckoNetworkManager.getInstance().getCurrentInformation();
     }
     @WrapElementForJNI
     public static void enableNetworkNotifications() {
         GeckoNetworkManager.getInstance().enableNotifications();
     }
     @WrapElementForJNI
     public static void disableNetworkNotifications() {
         GeckoNetworkManager.getInstance().disableNotifications();
     }
     // values taken from android's Base64
     public static final int BASE64_DEFAULT = 0;
     public static final int BASE64_URL_SAFE = 8;
     /**
      * taken from http://www.source-code.biz/base64coder/java/Base64Coder.java.txt and modified (MIT License)
      */
     // Mapping table from 6-bit nibbles to Base64 characters.
     private static final byte[] map1 = new byte[64];
     private static final byte[] map1_urlsafe;
     static {
       int i=0;
       for (byte c='A'; c<='Z'; c++) map1[i++] = c;
       for (byte c='a'; c<='z'; c++) map1[i++] = c;
       for (byte c='0'; c<='9'; c++) map1[i++] = c;
       map1[i++] = '+'; map1[i++] = '/';
       map1_urlsafe = map1.clone();
       map1_urlsafe[62] = '-'; map1_urlsafe[63] = '_';
     }
     // Mapping table from Base64 characters to 6-bit nibbles.
     private static final byte[] map2 = new byte[128];
     static {
         for (int i=0; i<map2.length; i++) map2[i] = -1;
         for (int i=0; i<64; i++) map2[map1[i]] = (byte)i;
         map2['-'] = (byte)62; map2['_'] = (byte)63;
     }
     final static byte EQUALS_ASCII = (byte) '=';
     /**
      * Encodes a byte array into Base64 format.
      * No blanks or line breaks are inserted in the output.
      * @param in    An array containing the data bytes to be encoded.
      * @return      A character array containing the Base64 encoded data.
      */
     public static byte[] encodeBase64(byte[] in, int flags) {
         if (Build.VERSION.SDK_INT >=Build.VERSION_CODES.FROYO)
             return Base64.encode(in, flags | Base64.NO_WRAP);
         int oDataLen = (in.length*4+2)/3;       // output length without padding
         int oLen = ((in.length+2)/3)*4;         // output length including padding
         byte[] out = new byte[oLen];
         int ip = 0;
         int iEnd = in.length;
         int op = 0;
         byte[] toMap = ((flags & BASE64_URL_SAFE) == 0 ? map1 : map1_urlsafe);
         while (ip < iEnd) {
             int i0 = in[ip++] & 0xff;
             int i1 = ip < iEnd ? in[ip++] & 0xff : 0;
             int i2 = ip < iEnd ? in[ip++] & 0xff : 0;
             int o0 = i0 >>> 2;
             int o1 = ((i0 &   3) << 4) | (i1 >>> 4);
             int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);
             int o3 = i2 & 0x3F;
             out[op++] = toMap[o0];
             out[op++] = toMap[o1];
             out[op] = op < oDataLen ? toMap[o2] : EQUALS_ASCII; op++;
             out[op] = op < oDataLen ? toMap[o3] : EQUALS_ASCII; op++;
         }
         return out;
     }
     /**
      * Decodes a byte array from Base64 format.
      * No blanks or line breaks are allowed within the Base64 encoded input data.
      * @param in    A character array containing the Base64 encoded data.
      * @param iOff  Offset of the first character in <code>in</code> to be processed.
      * @param iLen  Number of characters to process in <code>in</code>, starting at <code>iOff</code>.
      * @return      An array containing the decoded data bytes.
      * @throws      IllegalArgumentException If the input is not valid Base64 encoded data.
      */
     public static byte[] decodeBase64(byte[] in, int flags) {
         if (Build.VERSION.SDK_INT >=Build.VERSION_CODES.FROYO)
             return Base64.decode(in, flags);
         int iOff = 0;
         int iLen = in.length;
         if (iLen%4 != 0) throw new IllegalArgumentException ("Length of Base64 encoded input string is not a multiple of 4.");
         while (iLen > 0 && in[iOff+iLen-1] == '=') iLen--;
         int oLen = (iLen*3) / 4;
         byte[] out = new byte[oLen];
         int ip = iOff;
         int iEnd = iOff + iLen;
         int op = 0;
         while (ip < iEnd) {
             int i0 = in[ip++];
             int i1 = in[ip++];
             int i2 = ip < iEnd ? in[ip++] : 'A';
             int i3 = ip < iEnd ? in[ip++] : 'A';
             if (i0 > 127 || i1 > 127 || i2 > 127 || i3 > 127)
                 throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
             int b0 = map2[i0];
             int b1 = map2[i1];
             int b2 = map2[i2];
             int b3 = map2[i3];
             if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0)
                 throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
             int o0 = ( b0       <<2) | (b1>>>4);
             int o1 = ((b1 & 0xf)<<4) | (b2>>>2);
             int o2 = ((b2 &   3)<<6) |  b3;
             out[op++] = (byte)o0;
             if (op<oLen) out[op++] = (byte)o1;
             if (op<oLen) out[op++] = (byte)o2; }
         return out;
     }
     public static byte[] decodeBase64(String s, int flags) {
         return decodeBase64(s.getBytes(), flags);
     }
     @WrapElementForJNI(stubName = "GetScreenOrientationWrapper")
     public static short getScreenOrientation() {
         return GeckoScreenOrientation.getInstance().getScreenOrientation().value;
     }
     @WrapElementForJNI
     public static void enableScreenOrientationNotifications() {
         GeckoScreenOrientation.getInstance().enableNotifications();
     }
     @WrapElementForJNI
     public static void disableScreenOrientationNotifications() {
         GeckoScreenOrientation.getInstance().disableNotifications();
     }
     @WrapElementForJNI
     public static void lockScreenOrientation(int aOrientation) {
         GeckoScreenOrientation.getInstance().lock(aOrientation);
     }
     @WrapElementForJNI
     public static void unlockScreenOrientation() {
         GeckoScreenOrientation.getInstance().unlock();
     }
     @WrapElementForJNI
     public static boolean pumpMessageLoop() {
         Handler geckoHandler = ThreadUtils.sGeckoHandler;
         Message msg = getNextMessageFromQueue(ThreadUtils.sGeckoQueue);
         if (msg == null)
             return false;
         if (msg.obj == geckoHandler && msg.getTarget() == geckoHandler) {
             // Our "queue is empty" message; see runGecko()
             msg.recycle();
             return false;
         }
         if (msg.getTarget() == null)
             Looper.myLooper().quit();
         else
             msg.getTarget().dispatchMessage(msg);
         msg.recycle();
         return true;
     }
     @WrapElementForJNI
     public static void notifyWakeLockChanged(String topic, String state) {
         if (getGeckoInterface() != null)
             getGeckoInterface().notifyWakeLockChanged(topic, state);
     }
     @WrapElementForJNI
     public static void registerSurfaceTextureFrameListener(Object surfaceTexture, final int id) {
         ((SurfaceTexture)surfaceTexture).setOnFrameAvailableListener(new SurfaceTexture.OnFrameAvailableListener() {
             @Override
             public void onFrameAvailable(SurfaceTexture surfaceTexture) {
                 GeckoAppShell.onSurfaceTextureFrameAvailable(surfaceTexture, id);
             }
         });
     }
     @WrapElementForJNI(allowMultithread = true)
     public static void unregisterSurfaceTextureFrameListener(Object surfaceTexture) {
         ((SurfaceTexture)surfaceTexture).setOnFrameAvailableListener(null);
     }
     @WrapElementForJNI
     public static boolean unlockProfile() {
         // Try to kill any zombie Fennec's that might be running
         GeckoAppShell.killAnyZombies();
         // Then force unlock this profile
         if (getGeckoInterface() != null) {
             GeckoProfile profile = getGeckoInterface().getProfile();
             File lock = profile.getFile(".parentlock");
             return lock.exists() && lock.delete();
         }
         return false;
     }
     @WrapElementForJNI(stubName = "GetProxyForURIWrapper")
     public static String getProxyForURI(String spec, String scheme, String host, int port) {
         final ProxySelector ps = new ProxySelector();
         Proxy proxy = ps.select(scheme, host);
         if (Proxy.NO_PROXY.equals(proxy)) {
             return "DIRECT";
         }
         switch (proxy.type()) {
             case HTTP:
                 return "PROXY " + proxy.address().toString();
             case SOCKS:
                 return "SOCKS " + proxy.address().toString();
         }
         return "DIRECT";
     }
     /* Downloads the uri pointed to by a share intent, and alters the intent to point to the locally stored file.
      */
     public static void downloadImageForIntent(final Intent intent) {
         final String src = intent.getStringExtra(Intent.EXTRA_TEXT);
         final File dir = GeckoApp.getTempDirectory();
         if (dir == null) {
             showImageShareFailureToast();
             return;
         }
         GeckoApp.deleteTempFiles();
         String type = intent.getType();
         OutputStream os = null;
         try {
             // Create a temporary file for the image
             if (src.startsWith("data:")) {
                 final int dataStart = src.indexOf(",");
                 String extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(type);
                 // If we weren't given an explicit mimetype, try to dig one out of the data uri.
                 if (TextUtils.isEmpty(extension) && dataStart > 5) {
                     type = src.substring(5, dataStart).replace(";base64", "");
                     extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(type);
                 }
                 final File imageFile = File.createTempFile("image", "." + extension, dir);
                 os = new FileOutputStream(imageFile);
                 byte[] buf = Base64.decode(src.substring(dataStart + 1), Base64.DEFAULT);
                 os.write(buf);
                 // Only alter the intent when we're sure everything has worked
                 intent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(imageFile));
             } else {
                 InputStream is = null;
                 try {
                     final byte[] buf = new byte[2048];
                     final URL url = new URL(src);
                     final String filename = URLUtil.guessFileName(src, null, type);
                     is = url.openStream();
                     final File imageFile = new File(dir, filename);
                     os = new FileOutputStream(imageFile);
                     int length;
                     while ((length = is.read(buf)) != -1) {
                         os.write(buf, 0, length);
                     }
                     // Only alter the intent when we're sure everything has worked
                     intent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(imageFile));
                 } finally {
                     safeStreamClose(is);
                 }
             }
         } catch(IOException ex) {
             // If something went wrong, we'll just leave the intent un-changed
         } finally {
             safeStreamClose(os);
         }
     }
     // Don't fail silently, tell the user that we weren't able to share the image
     private static final void showImageShareFailureToast() {
         Toast toast = Toast.makeText(getContext(),
                                      getContext().getResources().getString(R.string.share_image_failed),
                                      Toast.LENGTH_SHORT);
         toast.show();
     }
 }

The Tor Browser / annotate

mobile/android/base/GeckoAppShell.java@fc2d59ddac77 (annotated)

mobile/android/base/GeckoAppShell.java