增加佳明相机业务

collect-library/src/main/java/org/videolan/vlc/MurmurHash.java

@@ -0,0 +1,183 @@
+package org.videolan.vlc;
+
+/** Murmur hash 2.0.
+ *
+ * The murmur hash is a relative fast hash function from
+ * http://murmurhash.googlepages.com/ for platforms with efficient
+ * multiplication.
+ *
+ * This is a re-implementation of the original C code plus some
+ * additional features.
+ *
+ * Public domain.
+ *
+ * @author Viliam Holub
+ * @version 1.0.2
+ *
+ */
+public final class MurmurHash {
+
+    /** Generates 32 bit hash from byte array of the given length and
+     * seed.
+     *
+     * @param data byte array to hash
+     * @param length length of the array to hash
+     * @param seed initial seed value
+     * @return 32 bit hash of the given array
+     */
+    public static int hash32(final byte[] data, int length, int seed) {
+        // 'm' and 'r' are mixing constants generated offline.
+        // They're not really 'magic', they just happen to work well.
+        final int m = 0x5bd1e995;
+        final int r = 24;
+        // Initialize the hash to a random value
+        int h = seed ^ length;
+        int length4 = length / 4;
+
+        for (int i = 0; i < length4; i++) {
+            final int i4 = i * 4;
+            int k = (data[i4 + 0] & 0xff) + ((data[i4 + 1] & 0xff) << 8)
+                    + ((data[i4 + 2] & 0xff) << 16) + ((data[i4 + 3] & 0xff) << 24);
+            k *= m;
+            k ^= k >>> r;
+            k *= m;
+            h *= m;
+            h ^= k;
+        }
+
+        // Handle the last few bytes of the input array
+        switch (length % 4) {
+            case 3:
+                h ^= (data[(length & ~3) + 2] & 0xff) << 16;
+            case 2:
+                h ^= (data[(length & ~3) + 1] & 0xff) << 8;
+            case 1:
+                h ^= (data[length & ~3] & 0xff);
+                h *= m;
+        }
+
+        h ^= h >>> 13;
+        h *= m;
+        h ^= h >>> 15;
+
+        return h;
+    }
+
+    /** Generates 32 bit hash from byte array with default seed value.
+     *
+     * @param data byte array to hash
+     * @param length length of the array to hash
+     * @return 32 bit hash of the given array
+     */
+    public static int hash32(final byte[] data, int length) {
+        return hash32(data, length, 0x9747b28c);
+    }
+
+    /** Generates 32 bit hash from a string.
+     *
+     * @param text string to hash
+     * @return 32 bit hash of the given string
+     */
+    public static int hash32(final String text) {
+        final byte[] bytes = text.getBytes();
+        return hash32(bytes, bytes.length);
+    }
+
+    /** Generates 32 bit hash from a substring.
+     *
+     * @param text string to hash
+     * @param from starting index
+     * @param length length of the substring to hash
+     * @return 32 bit hash of the given string
+     */
+    public static int hash32(final String text, int from, int length) {
+        return hash32(text.substring(from, from + length));
+    }
+
+    /** Generates 64 bit hash from byte array of the given length and seed.
+     *
+     * @param data byte array to hash
+     * @param length length of the array to hash
+     * @param seed initial seed value
+     * @return 64 bit hash of the given array
+     */
+    public static long hash64(final byte[] data, int length, int seed) {
+        final long m = 0xc6a4a7935bd1e995L;
+        final int r = 47;
+
+        long h = (seed & 0xffffffffl) ^ (length * m);
+
+        int length8 = length / 8;
+
+        for (int i = 0; i < length8; i++) {
+            final int i8 = i * 8;
+            long k = ((long) data[i8 + 0] & 0xff) + (((long) data[i8 + 1] & 0xff) << 8)
+                    + (((long) data[i8 + 2] & 0xff) << 16) + (((long) data[i8 + 3] & 0xff) << 24)
+                    + (((long) data[i8 + 4] & 0xff) << 32) + (((long) data[i8 + 5] & 0xff) << 40)
+                    + (((long) data[i8 + 6] & 0xff) << 48) + (((long) data[i8 + 7] & 0xff) << 56);
+
+            k *= m;
+            k ^= k >>> r;
+            k *= m;
+
+            h ^= k;
+            h *= m;
+        }
+
+        switch (length % 8) {
+            case 7:
+                h ^= (long) (data[(length & ~7) + 6] & 0xff) << 48;
+            case 6:
+                h ^= (long) (data[(length & ~7) + 5] & 0xff) << 40;
+            case 5:
+                h ^= (long) (data[(length & ~7) + 4] & 0xff) << 32;
+            case 4:
+                h ^= (long) (data[(length & ~7) + 3] & 0xff) << 24;
+            case 3:
+                h ^= (long) (data[(length & ~7) + 2] & 0xff) << 16;
+            case 2:
+                h ^= (long) (data[(length & ~7) + 1] & 0xff) << 8;
+            case 1:
+                h ^= (long) (data[length & ~7] & 0xff);
+                h *= m;
+        }
+        ;
+
+        h ^= h >>> r;
+        h *= m;
+        h ^= h >>> r;
+
+        return h;
+    }
+
+    /** Generates 64 bit hash from byte array with default seed value.
+     *
+     * @param data byte array to hash
+     * @param length length of the array to hash
+     * @return 64 bit hash of the given string
+     */
+    public static long hash64(final byte[] data, int length) {
+        return hash64(data, length, 0xe17a1465);
+    }
+
+    /** Generates 64 bit hash from a string.
+     *
+     * @param text string to hash
+     * @return 64 bit hash of the given string
+     */
+    public static long hash64(final String text) {
+        final byte[] bytes = text.getBytes();
+        return hash64(bytes, bytes.length);
+    }
+
+    /** Generates 64 bit hash from a substring.
+     *
+     * @param text string to hash
+     * @param from starting index
+     * @param length length of the substring to hash
+     * @return 64 bit hash of the given array
+     */
+    public static long hash64(final String text, int from, int length) {
+        return hash64(text.substring(from, from + length));
+    }
+}

collect-library/src/main/java/org/videolan/vlc/PhoneStateReceiver.java

@@ -0,0 +1,44 @@
+/*****************************************************************************
+ * PhoneStateReceiver.java
+ *****************************************************************************
+ * Copyright © 2011-2012 VLC authors and VideoLAN
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+package org.videolan.vlc;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.telephony.TelephonyManager;
+import org.videolan.libvlc.LibVLC;
+
+public class PhoneStateReceiver extends BroadcastReceiver {
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
+
+        if (state.equals(TelephonyManager.EXTRA_STATE_RINGING) ||
+                state.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)) {
+
+            LibVLC libVLC = LibVLC.getExistingInstance();
+            if (libVLC != null && libVLC.isPlaying())
+                libVLC.pause();
+        }
+    }
+
+}

collect-library/src/main/java/org/videolan/vlc/RepeatType.java

@@ -0,0 +1,26 @@
+/*****************************************************************************
+ * RepeatType.java
+ *****************************************************************************
+ * Copyright © 2012 VLC authors and VideoLAN
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+package org.videolan.vlc;
+
+public enum RepeatType {
+    None,
+    Once,
+    All
+}

collect-library/src/main/java/org/videolan/vlc/Util.java

@@ -0,0 +1,546 @@
+/*****************************************************************************
+ * Util.java
+ *****************************************************************************
+ * Copyright © 2011-2013 VLC authors and VideoLAN
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+package org.videolan.vlc;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Environment;
+import android.preference.PreferenceManager;
+import android.telephony.TelephonyManager;
+import android.util.DisplayMetrics;
+import android.util.TypedValue;
+import android.view.Display;
+import android.view.WindowManager;
+import android.widget.Toast;
+import com.navinfo.collect.library.system.VLCApplication;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.videolan.libvlc.LibVLC;
+import org.videolan.libvlc.LibVlcException;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.StringTokenizer;
+
+public class Util {
+    public final static String TAG = "VLC/Util";
+    private final static boolean hasNavBar;
+    private Context context;
+    private static volatile Util mInstance;
+
+    /** A set of utility functions for the VLC application */
+
+    static {
+        HashSet<String> devicesWithoutNavBar = new HashSet<String>();
+        devicesWithoutNavBar.add("HTC One V");
+        devicesWithoutNavBar.add("HTC One S");
+        devicesWithoutNavBar.add("HTC One X");
+        devicesWithoutNavBar.add("HTC One XL");
+        hasNavBar = isICSOrLater() && !devicesWithoutNavBar.contains(android.os.Build.MODEL);
+    }
+
+    public static Util getInstance() {
+        if (mInstance == null) {
+            synchronized (Util.class) {
+                if (mInstance == null) {
+                    mInstance = new Util();
+                }
+            }
+        }
+        return mInstance;
+    }
+
+    public void init(Context con){
+        this.context = con;
+        // Are we using advanced debugging - locale?
+        SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(con);
+        String p = pref.getString("set_locale", "");
+        if (p != null && !p.equals("")) {
+            Locale locale;
+            // workaround due to region code
+            if(p.equals("zh-TW")) {
+                locale = Locale.TRADITIONAL_CHINESE;
+            } else if(p.startsWith("zh")) {
+                locale = Locale.CHINA;
+            } else if(p.equals("pt-BR")) {
+                locale = new Locale("pt", "BR");
+            } else if(p.equals("bn-IN") || p.startsWith("bn")) {
+                locale = new Locale("bn", "IN");
+            } else {
+                /**
+                 * Avoid a crash of
+                 * java.lang.AssertionError: couldn't initialize LocaleData for locale
+                 * if the user enters nonsensical region codes.
+                 */
+                if(p.contains("-"))
+                    p = p.substring(0, p.indexOf('-'));
+                locale = new Locale(p);
+            }
+            Locale.setDefault(locale);
+            Configuration config = new Configuration();
+            config.locale = locale;
+            con.getResources().updateConfiguration(config,
+                    con.getResources().getDisplayMetrics());
+        }
+    }
+
+    public LibVLC getLibVlcInstance() throws LibVlcException {
+
+        LibVLC instance = LibVLC.getExistingInstance();
+
+        if (instance == null) {
+
+            Thread.setDefaultUncaughtExceptionHandler(new VlcCrashHandler());
+
+            instance = LibVLC.getInstance();
+
+            SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(context);
+
+            updateLibVlcSettings(pref);
+
+            instance.init(context);
+
+        }
+
+        return instance;
+    }
+
+    public static float[] getFloatArray(SharedPreferences pref, String key) {
+        float[] array = null;
+        String s = pref.getString(key, null);
+        if (s != null) {
+            try {
+                JSONArray json = new JSONArray(s);
+                array = new float[json.length()];
+                for (int i = 0; i < array.length; i++)
+                    array[i] = (float) json.getDouble(i);
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+        }
+        return array;
+    }
+
+    public static void putFloatArray(Editor editor, String key, float[] array) {
+        try {
+            JSONArray json = new JSONArray();
+            for (float f : array)
+                json.put(f);
+            editor.putString("equalizer_values", json.toString());
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void updateLibVlcSettings(SharedPreferences pref) {
+        LibVLC instance = LibVLC.getExistingInstance();
+        if (instance == null)
+            return;
+
+        instance.setIomx(pref.getBoolean("enable_iomx", false));
+        instance.setSubtitlesEncoding(pref.getString("subtitles_text_encoding", ""));
+        instance.setTimeStretching(pref.getBoolean("enable_time_stretching_audio", false));
+        instance.setFrameSkip(pref.getBoolean("enable_frame_skip", false));
+        instance.setChroma(pref.getString("chroma_format", ""));
+        instance.setVerboseMode(pref.getBoolean("enable_verbose_mode", true));
+
+        if (pref.getBoolean("equalizer_enabled", false))
+            instance.setEqualizer(getFloatArray(pref, "equalizer_values"));
+
+        int aout;
+        try {
+            aout = Integer.parseInt(pref.getString("aout", "-1"));
+        }
+        catch (NumberFormatException nfe) {
+            aout = -1;
+        }
+        int deblocking;
+        try {
+            deblocking = Integer.parseInt(pref.getString("deblocking", "-1"));
+        }
+        catch(NumberFormatException nfe) {
+            deblocking = -1;
+        }
+        int networkCaching = pref.getInt("network_caching_value", 0);
+        if(networkCaching > 60000)
+            networkCaching = 60000;
+        else if(networkCaching < 0)
+            networkCaching = 0;
+        instance.setAout(aout);
+        instance.setDeblocking(deblocking);
+        instance.setNetworkCaching(networkCaching);
+    }
+
+    /** Print an on-screen message to alert the user */
+    public static void toaster(Context context, int stringId, int duration) {
+        Toast.makeText(context, stringId, duration).show();
+    }
+
+    public static void toaster(Context context, int stringId) {
+        toaster(context, stringId, Toast.LENGTH_SHORT);
+    }
+
+    public static File URItoFile(String URI) {
+        return new File(Uri.decode(URI).replace("file://",""));
+    }
+
+    public static String URItoFileName(String URI) {
+        return URItoFile(URI).getName();
+    }
+
+    public static String stripTrailingSlash(String s) {
+        if( s.endsWith("/") && s.length() > 1 )
+            return s.substring(0, s.length() - 1);
+        return s;
+    }
+
+    public static String readAsset(String assetName, String defaultS) {
+        try {
+            InputStream is = VLCApplication.getAppResources().getAssets().open(assetName);
+            BufferedReader r = new BufferedReader(new InputStreamReader(is, "UTF8"));
+            StringBuilder sb = new StringBuilder();
+            String line = r.readLine();
+            if(line != null) {
+                sb.append(line);
+                line = r.readLine();
+                while(line != null) {
+                    sb.append('\n');
+                    sb.append(line);
+                    line = r.readLine();
+                }
+            }
+            return sb.toString();
+        } catch (IOException e) {
+            return defaultS;
+        }
+    }
+
+    /**
+     * Convert time to a string
+     * @param millis e.g.time/length from file
+     * @return formated string (hh:)mm:ss
+     */
+    public static String millisToString(long millis)
+    {
+        return millisToString(millis, false);
+    }
+
+    /**
+     * Convert time to a string
+     * @param millis e.g.time/length from file
+     * @return formated string "[hh]h[mm]min" / "[mm]min[s]s"
+     */
+    public static String millisToText(long millis)
+    {
+        return millisToString(millis, true);
+    }
+
+    private static String millisToString(long millis, boolean text) {
+        boolean negative = millis < 0;
+        millis = Math.abs(millis);
+
+        millis /= 1000;
+        int sec = (int) (millis % 60);
+        millis /= 60;
+        int min = (int) (millis % 60);
+        millis /= 60;
+        int hours = (int) millis;
+
+        String time;
+        DecimalFormat format = (DecimalFormat)NumberFormat.getInstance(Locale.US);
+        format.applyPattern("00");
+        if (text) {
+            if (millis > 0)
+                time = (negative ? "-" : "") + hours + "h" + format.format(min) + "min";
+            else if (min > 0)
+                time = (negative ? "-" : "") + min + "min";
+            else
+                time = (negative ? "-" : "") + sec + "s";
+        }
+        else {
+            if (millis > 0)
+                time = (negative ? "-" : "") + hours + ":" + format.format(min) + ":" + format.format(sec);
+            else
+                time = (negative ? "-" : "") + min + ":" + format.format(sec);
+        }
+        return time;
+    }
+
+    public static Bitmap scaleDownBitmap(Context context, Bitmap bitmap, int width) {
+        /*
+         * This method can lead to OutOfMemoryError!
+         * If the source size is more than twice the target size use
+         * the optimized version available in AudioUtil::readCoverBitmap
+         */
+        if (bitmap != null) {
+            final float densityMultiplier = context.getResources().getDisplayMetrics().density;
+            int w = (int) (width * densityMultiplier);
+            int h = (int) (w * bitmap.getHeight() / ((double) bitmap.getWidth()));
+            bitmap = Bitmap.createScaledBitmap(bitmap, w, h, true);
+        }
+        return bitmap;
+    }
+
+    public static Bitmap cropBorders(Bitmap bitmap, int width, int height)
+    {
+        int top = 0;
+        for (int i = 0; i < height / 2; i++) {
+            int pixel1 = bitmap.getPixel(width / 2, i);
+            int pixel2 = bitmap.getPixel(width / 2, height - i - 1);
+            if ((pixel1 == 0 || pixel1 == -16777216) &&
+                    (pixel2 == 0 || pixel2 == -16777216)) {
+                top = i;
+            } else {
+                break;
+            }
+        }
+
+        int left = 0;
+        for (int i = 0; i < width / 2; i++) {
+            int pixel1 = bitmap.getPixel(i, height / 2);
+            int pixel2 = bitmap.getPixel(width - i - 1, height / 2);
+            if ((pixel1 == 0 || pixel1 == -16777216) &&
+                    (pixel2 == 0 || pixel2 == -16777216)) {
+                left = i;
+            } else {
+                break;
+            }
+        }
+
+        if (left >= width / 2 - 10 || top >= height / 2 - 10)
+            return bitmap;
+
+        // Cut off the transparency on the borders
+        return Bitmap.createBitmap(bitmap, left, top,
+                (width - (2 * left)), (height - (2 * top)));
+    }
+
+    public static String getValue(String string, int defaultId)
+    {
+        return (string != null && string.length() > 0) ?
+                string : VLCApplication.getAppContext().getString(defaultId);
+    }
+
+    public static int convertPxToDp(int px) {
+        WindowManager wm = (WindowManager)VLCApplication.getAppContext().
+                getSystemService(Context.WINDOW_SERVICE);
+        Display display = wm.getDefaultDisplay();
+        DisplayMetrics metrics = new DisplayMetrics();
+        display.getMetrics(metrics);
+        float logicalDensity = metrics.density;
+        int dp = Math.round(px / logicalDensity);
+        return dp;
+    }
+
+    public static int convertDpToPx(int dp) {
+        return Math.round(
+                TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp,
+                        VLCApplication.getAppResources().getDisplayMetrics())
+        );
+    }
+
+    public static boolean isFroyoOrLater()
+    {
+        return android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.FROYO;
+    }
+
+    public static boolean isGingerbreadOrLater()
+    {
+        return android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.GINGERBREAD;
+    }
+
+    public static boolean isHoneycombOrLater()
+    {
+        return android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.HONEYCOMB;
+    }
+
+    public static boolean isICSOrLater()
+    {
+        return android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH;
+    }
+
+    public static boolean isJellyBeanOrLater()
+    {
+        return android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN;
+    }
+
+    public static boolean hasExternalStorage() {
+        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
+    }
+
+    public static boolean hasNavBar()
+    {
+        return hasNavBar;
+    }
+
+    /** hasCombBar test if device has Combined Bar : only for tablet with Honeycomb or ICS */
+    public static boolean hasCombBar() {
+        return (!isPhone()
+                && ((android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.HONEYCOMB) &&
+                (android.os.Build.VERSION.SDK_INT <= android.os.Build.VERSION_CODES.JELLY_BEAN)));
+    }
+
+    public static boolean isPhone(){
+        TelephonyManager manager = (TelephonyManager)VLCApplication.getAppContext().getSystemService(Context.TELEPHONY_SERVICE);
+        if(manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE){
+            return false;
+        }else{
+            return true;
+        }
+    }
+
+    public static String[] getStorageDirectories()
+    {
+        String[] dirs = null;
+        BufferedReader bufReader = null;
+        try {
+            bufReader = new BufferedReader(new FileReader("/proc/mounts"));
+            ArrayList<String> list = new ArrayList<String>();
+            list.add(Environment.getExternalStorageDirectory().getPath());
+            String line;
+            while((line = bufReader.readLine()) != null) {
+                if(line.contains("vfat") || line.contains("exfat") ||
+                        line.contains("/mnt") || line.contains("/Removable")) {
+                    StringTokenizer tokens = new StringTokenizer(line, " ");
+                    String s = tokens.nextToken();
+                    s = tokens.nextToken(); // Take the second token, i.e. mount point
+
+                    if (list.contains(s))
+                        continue;
+
+                    if (line.contains("/dev/block/vold")) {
+                        if (!line.startsWith("tmpfs") &&
+                                !line.startsWith("/dev/mapper") &&
+                                !s.startsWith("/mnt/secure") &&
+                                !s.startsWith("/mnt/shell") &&
+                                !s.startsWith("/mnt/asec") &&
+                                !s.startsWith("/mnt/obb")
+                                ) {
+                            list.add(s);
+                        }
+                    }
+                }
+            }
+
+            dirs = new String[list.size()];
+            for (int i = 0; i < list.size(); i++) {
+                dirs[i] = list.get(i);
+            }
+        }
+        catch (FileNotFoundException e) {}
+        catch (IOException e) {}
+        finally {
+            if (bufReader != null) {
+                try {
+                    bufReader.close();
+                }
+                catch (IOException e) {}
+            }
+        }
+        return dirs;
+    }
+
+    public static String[] getCustomDirectories() {
+        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(VLCApplication.getAppContext());
+        final String custom_paths = preferences.getString("custom_paths", "");
+        if(custom_paths.equals(""))
+            return new String[0];
+        else
+            return custom_paths.split(":");
+    }
+
+    public static String[] getMediaDirectories() {
+        ArrayList<String> list = new ArrayList<String>();
+        list.addAll(Arrays.asList(Util.getStorageDirectories()));
+        list.addAll(Arrays.asList(Util.getCustomDirectories()));
+        return list.toArray(new String[list.size()]);
+    }
+
+    public static void addCustomDirectory(String path) {
+        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(VLCApplication.getAppContext());
+
+        ArrayList<String> dirs = new ArrayList<String>(
+                Arrays.asList(getCustomDirectories()));
+        dirs.add(path);
+        StringBuilder builder = new StringBuilder();
+        builder.append(dirs.remove(0));
+        for(String s : dirs) {
+            builder.append(":");
+            builder.append(s);
+        }
+        Editor editor = preferences.edit();
+        editor.putString("custom_paths", builder.toString());
+        editor.commit();
+    }
+
+    public static void removeCustomDirectory(String path) {
+        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(VLCApplication.getAppContext());
+        if(!preferences.getString("custom_paths", "").contains(path))
+            return;
+        ArrayList<String> dirs = new ArrayList<String>(
+                Arrays.asList(preferences.getString("custom_paths", "").split(
+                        ":")));
+        dirs.remove(path);
+        String custom_path;
+        if(dirs.size() > 0) {
+            StringBuilder builder = new StringBuilder();
+            builder.append(dirs.remove(0));
+            for(String s : dirs) {
+                builder.append(":");
+                builder.append(s);
+            }
+            custom_path = builder.toString();
+        } else { // don't do unneeded extra work
+            custom_path = "";
+        }
+        Editor editor = preferences.edit();
+        editor.putString("custom_paths", custom_path);
+        editor.commit();
+    }
+
+    /**
+     * Get the formatted current playback speed in the form of 1.00x
+     */
+    public static String formatRateString(float rate) {
+        return String.format(Locale.US, "%.2fx", rate);
+    }
+
+    /**
+     * equals() with two strings where either could be null
+     */
+    public static boolean nullEquals(String s1, String s2) {
+        return (s1 == null ? s2 == null : s1.equals(s2));
+    }
+}

collect-library/src/main/java/org/videolan/vlc/VlcCrashHandler.java

@@ -0,0 +1,125 @@
+/*****************************************************************************
+ * VlcCrashHandler.java
+ *****************************************************************************
+ * Copyright © 2012 VLC authors and VideoLAN
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+package org.videolan.vlc;
+
+import android.os.Environment;
+import android.text.format.DateFormat;
+import android.util.Log;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.lang.Thread.UncaughtExceptionHandler;
+
+public class VlcCrashHandler implements UncaughtExceptionHandler {
+
+    private static final String TAG = "VLC/VlcCrashHandler";
+
+    private UncaughtExceptionHandler defaultUEH;
+
+    public VlcCrashHandler() {
+        this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler();
+    }
+
+    @Override
+    public void uncaughtException(Thread thread, Throwable ex) {
+
+        final Writer result = new StringWriter();
+        final PrintWriter printWriter = new PrintWriter(result);
+
+        // Inject some info about android version and the device, since google can't provide them in the developer console
+        StackTraceElement[] trace = ex.getStackTrace();
+        StackTraceElement[] trace2 = new StackTraceElement[trace.length+3];
+        System.arraycopy(trace, 0, trace2, 0, trace.length);
+        trace2[trace.length+0] = new StackTraceElement("Android", "MODEL", android.os.Build.MODEL, -1);
+        trace2[trace.length+1] = new StackTraceElement("Android", "VERSION", android.os.Build.VERSION.RELEASE, -1);
+        trace2[trace.length+2] = new StackTraceElement("Android", "FINGERPRINT", android.os.Build.FINGERPRINT, -1);
+        ex.setStackTrace(trace2);
+
+        ex.printStackTrace(printWriter);
+        String stacktrace = result.toString();
+        printWriter.close();
+        Log.e(TAG, stacktrace);
+
+        // Save the log on SD card if available
+        if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
+            String sdcardPath = Environment.getExternalStorageDirectory().getPath();
+            writeLog(stacktrace, sdcardPath + "/vlc_crash");
+            writeLogcat(sdcardPath + "/vlc_logcat");
+        }
+
+        defaultUEH.uncaughtException(thread, ex);
+    }
+
+    private void writeLog(String log, String name) {
+        CharSequence timestamp = DateFormat.format("yyyyMMdd_kkmmss", System.currentTimeMillis());
+        String filename = name + "_" + timestamp + ".log";
+
+        try {
+            FileOutputStream stream = new FileOutputStream(filename);
+            OutputStreamWriter output = new OutputStreamWriter(stream);
+            BufferedWriter bw = new BufferedWriter(output);
+
+            bw.write(log);
+            bw.newLine();
+
+            bw.close();
+            output.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void writeLogcat(String name) {
+        CharSequence timestamp = DateFormat.format("yyyyMMdd_kkmmss", System.currentTimeMillis());
+        String filename = name + "_" + timestamp + ".log";
+        String[] args = { "logcat", "-v", "time", "-d" };
+
+        try {
+            Process process = Runtime.getRuntime().exec(args);
+            InputStreamReader input = new InputStreamReader(
+                    process.getInputStream());
+            OutputStreamWriter output = new OutputStreamWriter(
+                    new FileOutputStream(filename));
+            BufferedReader br = new BufferedReader(input);
+            BufferedWriter bw = new BufferedWriter(output);
+            String line;
+
+            while ((line = br.readLine()) != null) {
+                bw.write(line);
+                bw.newLine();
+            }
+
+            bw.close();
+            output.close();
+            br.close();
+            input.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

collect-library/src/main/java/org/videolan/vlc/VlcRunnable.java

@@ -0,0 +1,39 @@
+/*****************************************************************************
+ * VlcRunnable.java
+ *****************************************************************************
+ * Copyright © 2012 VLC authors and VideoLAN
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+package org.videolan.vlc;
+
+public abstract class VlcRunnable implements Runnable {
+    private final Object user;
+
+    public VlcRunnable() {
+        this.user = null;
+    }
+
+    public VlcRunnable(Object o) {
+        this.user = o;
+    }
+
+    public abstract void run(Object o);
+
+    @Override
+    public void run() {
+        run(user);
+    }
+}

collect-library/src/main/java/org/videolan/vlc/WeakHandler.java

@@ -0,0 +1,37 @@
+/*****************************************************************************
+ * WeakHandler.java
+ *****************************************************************************
+ * Copyright © 2012 VLC authors and VideoLAN
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+package org.videolan.vlc;
+
+import android.os.Handler;
+
+import java.lang.ref.WeakReference;
+
+public abstract class WeakHandler<T> extends Handler {
+    private WeakReference<T> mOwner;
+
+    public WeakHandler(T owner) {
+        mOwner = new WeakReference<T>(owner);
+    }
+
+    public T getOwner() {
+        return mOwner.get();
+    }
+}