Android Tutorial - Development

1.  I18N
2. Exception
3. Regular Expression
4. Resource
5. Unicode
6. UncaughtExceptionHandler
7. XmlPullParser
8. Zip

Contains ISO 639-3 language codes.

    
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * Contains ISO 639-3 language codes.
 * @author Martin Vysny
 */
public class Iso6393Codes {

    private static final Map<String, String> CODES = new HashMap<String, String>();

    public static final String LANG_CODE_ENGLISH = "eng";

    static {
        final String[] packedCodes = {"acm", "Mesopotamian Arabic", "afr", "Afrikaans", "ara", "Arabic", "arz", "Egyptian Arabic", "bel", "Belarusian", "ben", "Bengali", "bos", "Bosnian", "bre", "Breton", "bul", "Bulgarian", "cat", "Catalan", "ces", "Czech", "cha", "Chamorro", "cmn", "Mandarin Chinese", "dan", "Danish", "deu", "German", "ell", "Modern Greek (1453-)", "eng", "English", "epo", "Esperanto", "est", "Estonian", "eus", "Basque", "fao", "Faroese", "fin", "Finnish", "fra", "French", "fry", "Western Frisian", "gle", "Irish", "glg", "Galician", "heb", "Hebrew", "hin", "Hindi", "hrv", "Croatian", "hun", "Hungarian", "hye", "Armenian", "ina", "Interlingua (International Auxiliary Language Association)", "ind", "Indonesian", "isl", "Icelandic", "ita", "Italian", "jbo", "Lojban", "kat", "Georgian", "kaz", "Kazakh", "kor", "Korean", "lat", "Latin", "lit", "Lithuanian", "lvs", "Standard Latvian", "lzh", "Literary Chinese", "mal", "Malayalam", "mon", "Mongolian", "nan", "Min Nan Chinese", "nds", "Low German", "nld", "Dutch", "nob", "Norwegian Bokml", "non", "Old Norse", "orv", "Old Russian", "oss", "Ossetian", "pes", "Iranian Persian", "pol", "Polish", "por", "Portuguese", "que", "Quechua", "roh", "Romansh", "ron", "Romanian", "rus", "Russian", "scn", "Sicilian", "slk", "Slovak", "slv", "Slovenian", "spa", "Spanish", "sqi", "Albanian", "srp", "Serbian", "swe", "Swedish", "swh", "Swahili (individual language)", "tat", "Tatar", "tgl", "Tagalog", "tha", "Thai", "tlh", "Klingon", "tur", "Turkish", "uig", "Uighur", "ukr", "Ukrainian", "urd", "Urdu", "uzb", "Uzbek", "vie", "Vietnamese", "vol", "Volapk", "wuu", "Wu Chinese", "yid", "Yiddish", "yue", "Yue Chinese", "zsm", "Standard Malay"};
        for (int i = 0; i < packedCodes.length / 2; i++) {
            CODES.put(packedCodes[i * 2], packedCodes[i * 2 + 1]);
        }
    }

    public static Set<String> getAllCodes() {
        return Collections.unmodifiableSet(CODES.keySet());
    }

    public static String getLanguageName(String code) {
    
        final String result = CODES.get(code);
        if (result == null) {
            throw new RuntimeException("Unknown ISO 639-3 language code: " + code);
        }
        return result;
    }

    public static SortedMap<String, String> getSortedLangNames() {
        final SortedMap<String, String> result= new TreeMap<String, String>();
        for(final Map.Entry<String, String> e:CODES.entrySet()){
            result.put(e.getValue(), e.getKey());
        }
        return result;
    }
}

Deal with Endian

    
//package org.bouncycastle.crypto.util;

 abstract class Pack
{
    public static int bigEndianToInt(byte[] bs, int off)
    {
        int n = bs[  off] << 24;
        n |= (bs[++off] & 0xff) << 16;
        n |= (bs[++off] & 0xff) << 8;
        n |= (bs[++off] & 0xff);
        return n;
    }

    public static void intToBigEndian(int n, byte[] bs, int off)
    {
        bs[  off] = (byte)(n >>> 24);
        bs[++off] = (byte)(n >>> 16);
        bs[++off] = (byte)(n >>>  8);
        bs[++off] = (byte)(n       );
    }

    public static long bigEndianToLong(byte[] bs, int off)
    {
        int hi = bigEndianToInt(bs, off);
        int lo = bigEndianToInt(bs, off + 4);
        return ((long)(hi & 0xffffffffL) << 32) | (long)(lo & 0xffffffffL);
    }

    public static void longToBigEndian(long n, byte[] bs, int off)
    {
        intToBigEndian((int)(n >>> 32), bs, off);
        intToBigEndian((int)(n & 0xffffffffL), bs, off + 4);
    }

    public static int littleEndianToInt(byte[] bs, int off)
    {
        int n = bs[  off];
        n |= (bs[++off] & 0xff) << 8;
        n |= (bs[++off] & 0xff) << 16;
        n |= (bs[++off] & 0xff) << 24;
        return n;
    }

    public static void intToLittleEndian(int n, byte[] bs, int off)
    {
        bs[  off] = (byte)(n       );
        bs[++off] = (byte)(n >>>  8);
        bs[++off] = (byte)(n >>> 16);
        bs[++off] = (byte)(n >>> 24);
    }

    public static long littleEndianToLong(byte[] bs, int off)
    {
        int lo = littleEndianToInt(bs, off);
        int hi = littleEndianToInt(bs, off + 4);
        return ((long)(hi & 0xffffffffL) << 32) | (long)(lo & 0xffffffffL);
    }

    public static void longToLittleEndian(long n, byte[] bs, int off)
    {
        intToLittleEndian((int)(n & 0xffffffffL), bs, off);
        intToLittleEndian((int)(n >>> 32), bs, off + 4);
    }
}

dig Message out of Throwable

    
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;

class Main {

    public static String digMessage(Throwable e) {
        String msg = e.getMessage();
        if (msg == null && e.getCause() != null) {
            return digMessage(e.getCause());
        }
        return msg;
    }
}

serialize Throwable

    
//package crowdedroom.hop4droid;

import static java.text.MessageFormat.format;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * The Class Util.
 */
public class Util {

  /**
   * Serialize throwable.
   * @param throwable the throwable
   * @return the string
   */
  public static String serializeThrowable(final Throwable throwable) {
    final StringBuilder builder = new StringBuilder();
    builder.append("<?xml version=\"1.0\"?>");
    builder.append("<error>");
    builder.append("<class>"
      + throwable.getClass().getName()
      + "</class>");
    builder.append("<message>"
      + throwable.getMessage()
      + "</message>");
    builder.append("<backtrace>");
    for (final StackTraceElement element : throwable.getStackTrace()) {
      builder.append(format(
        "<line method=\"{0}.{1}\" file=\"{2}\" number=\"{3}\"/>",
        element.getClassName(),
        element.getFileName(),
        element.getLineNumber(),
        element.getMethodName()));
    }
    builder.append("</backtrace>");
    builder.append("</error>");
    builder
      .append("<server-environment><project-root>/root</project-root><environment-name>env</environment-name></server-environment>");
    builder.append("</notice>");
    return builder.toString();
  }
}

Parse out a charset from a content type header.

   

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Main {
    private static final Pattern charsetPattern = Pattern.compile("(?i)\\bcharset=\\s*\"?([^\\s;\"]*)");

  static String getCharsetFromContentType(String contentType) {
    if (contentType == null)
      return null;

    Matcher m = charsetPattern.matcher(contentType);
    if (m.find()) {
      return m.group(1).trim().toUpperCase();
    }
    return null;
  }
}

A character queue with parsing helpers.

   


public class TokenQueue {
    private String queue;
    private int pos = 0;
    
    private static final char ESC = '\\'; // escape char for chomp balanced.

   ]
    public TokenQueue(String data) {
        queue = data;
    }


    public boolean isEmpty() {
        return remainingLength() == 0;
    }
    
    private int remainingLength() {
        return queue.length() - pos;
    }


    public char peek() {
        return isEmpty() ? 0 : queue.charAt(pos);
    }


    public void addFirst(Character c) {
        addFirst(c.toString());
    }

    
    public void addFirst(String seq) {
        // not very performant, but an edge case
        queue = seq + queue.substring(pos);
        pos = 0;
    }


    public boolean matches(String seq) {
        return queue.regionMatches(true, pos, seq, 0, seq.length());
    }


    public boolean matchesCS(String seq) {
        return queue.startsWith(seq, pos);
    }
    

  
    public boolean matchesAny(String... seq) {
        for (String s : seq) {
            if (matches(s))
                return true;
        }
        return false;
    }

    public boolean matchesAny(char... seq) {
        if (isEmpty())
            return false;

        for (char c: seq) {
            if (queue.charAt(pos) == c)
                return true;
        }
        return false;
    }

    public boolean matchesStartTag() {
        // micro opt for matching "<x"
        return (remainingLength() >= 2 && queue.charAt(pos) == '<' && Character.isLetter(queue.charAt(pos+1)));
    }

 
    public boolean matchChomp(String seq) {
        if (matches(seq)) {
            pos += seq.length();
            return true;
        } else {
            return false;
        }
    }


    public boolean matchesWhitespace() {
        return !isEmpty() && Character.isWhitespace(queue.charAt(pos));
    }

  
    public boolean matchesWord() {
        return !isEmpty() && Character.isLetterOrDigit(queue.charAt(pos));
    }


    public void advance() {
        if (!isEmpty()) pos++;
    }

    public char consume() {
        return queue.charAt(pos++);
    }


    public void consume(String seq) {
        if (!matches(seq))
            throw new IllegalStateException("Queue did not match expected sequence");
        int len = seq.length();
        if (len > remainingLength())
            throw new IllegalStateException("Queue not long enough to consume sequence");
        
        pos += len;
    }

    public String consumeTo(String seq) {
        int offset = queue.indexOf(seq, pos);
        if (offset != -1) {
            String consumed = queue.substring(pos, offset);
            pos += consumed.length();
            return consumed;
        } else {
            return remainder();
        }
    }
    
    public String consumeToIgnoreCase(String seq) {
        int start = pos;
        String first = seq.substring(0, 1);
        boolean canScan = first.toLowerCase().equals(first.toUpperCase()); // if first is not cased, use index of
        while (!isEmpty()) {
            if (matches(seq))
                break;
            
            if (canScan) {
                int skip = queue.indexOf(first, pos) - pos;
                if (skip == 0) // this char is the skip char, but not match, so force advance of pos
                    pos++;
                else if (skip < 0) // no chance of finding, grab to end
                    pos = queue.length();
                else
                    pos += skip;
            }
            else
                pos++;
        }

        String data = queue.substring(start, pos); 
        return data; 
    }

    public String consumeToAny(String... seq) {
        int start = pos;
        while (!isEmpty() && !matchesAny(seq)) {
            pos++;
        }

        String data = queue.substring(start, pos); 
        return data; 
    }


    public String chompTo(String seq) {
        String data = consumeTo(seq);
        matchChomp(seq);
        return data;
    }
    
    public String chompToIgnoreCase(String seq) {
        String data = consumeToIgnoreCase(seq); // case insensitive scan
        matchChomp(seq);
        return data;
    }


    public String chompBalanced(char open, char close) {
        StringBuilder accum = new StringBuilder();
        int depth = 0;
        char last = 0;

        do {
            if (isEmpty()) break;
            Character c = consume();
            if (last == 0 || last != ESC) {
                if (c.equals(open))
                    depth++;
                else if (c.equals(close))
                    depth--;
            }

            if (depth > 0 && last != 0)
                accum.append(c); // don't include the outer match pair in the return
            last = c;
        } while (depth > 0);
        return accum.toString();
    }
    
 
    public static String unescape(String in) {
        StringBuilder out = new StringBuilder();
        char last = 0;
        for (char c : in.toCharArray()) {
            if (c == ESC) {
                if (last != 0 && last == ESC)
                    out.append(c);
            }
            else 
                out.append(c);
            last = c;
        }
        return out.toString();
    }

 
    public boolean consumeWhitespace() {
        boolean seen = false;
        while (matchesWhitespace()) {
            pos++;
            seen = true;
        }
        return seen;
    }

    public String consumeWord() {
        int start = pos;
        while (matchesWord())
            pos++;
        return queue.substring(start, pos);
    }
    
 
    public String consumeTagName() {
        int start = pos;
        while (!isEmpty() && (matchesWord() || matchesAny(':', '_', '-')))
            pos++;
        
        return queue.substring(start, pos);
    }
    
 
    public String consumeElementSelector() {
        int start = pos;
        while (!isEmpty() && (matchesWord() || matchesAny('|', '_', '-')))
            pos++;
        
        return queue.substring(start, pos);
    }


    public String consumeCssIdentifier() {
        int start = pos;
        while (!isEmpty() && (matchesWord() || matchesAny('-', '_')))
            pos++;

        return queue.substring(start, pos);
    }

    public String consumeAttributeKey() {
        int start = pos;
        while (!isEmpty() && (matchesWord() || matchesAny('-', '_', ':')))
            pos++;
        
        return queue.substring(start, pos);
    }

 
    public String remainder() {
        StringBuilder accum = new StringBuilder();
        while (!isEmpty()) {
            accum.append(consume());
        }
        return accum.toString();
    }
    
    public String toString() {
        return queue.substring(pos);
    }
}

Link resource with @

 

//File:main.xml for layout

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/directions"
    />
</LinearLayout>

//strings.xml for text value


<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="directions">Hello World, appTest!</string>
    <string name="app_name">app.Test</string>
</resources>

Unicode Chart

package app.test;

import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Picture;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.Window;

public class Test extends GraphicsActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    requestWindowFeature(Window.FEATURE_NO_TITLE);

    setContentView(new SampleView(this));
  }

  private static class SampleView extends View {
    private Paint mBigCharPaint;
    private Paint mLabelPaint;
    private final char[] mChars = new char[256];
    private final float[] mPos = new float[512];

    private int mBase;

    private static final int XMUL = 20;
    private static final int YMUL = 28;
    private static final int YBASE = 18;

    public SampleView(Context context) {
      super(context);
      setFocusable(true);
      setFocusableInTouchMode(true);

      mBigCharPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
      mBigCharPaint.setTextSize(15);
      mBigCharPaint.setTextAlign(Paint.Align.CENTER);

      mLabelPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
      mLabelPaint.setTextSize(8);
      mLabelPaint.setTextAlign(Paint.Align.CENTER);

      // the position array is the same for all charts
      float[] pos = mPos;
      int index = 0;
      for (int col = 0; col < 16; col++) {
        final float x = col * XMUL + 10;
        for (int row = 0; row < 16; row++) {
          pos[index++] = x;
          pos[index++] = row * YMUL + YBASE;
        }
      }
    }

    private float computeX(int index) {
      return (index >> 4) * XMUL + 10;
    }

    private float computeY(int index) {
      return (index & 0xF) * YMUL + YMUL;
    }

    private void drawChart(Canvas canvas, int base) {
      char[] chars = mChars;
      for (int i = 0; i < 256; i++) {
        int unichar = base + i;
        chars[i] = (char) unichar;

        canvas.drawText(Integer.toHexString(unichar), computeX(i),
            computeY(i), mLabelPaint);
      }
      canvas.drawPosText(chars, 0, 256, mPos, mBigCharPaint);
    }

    @Override
    protected void onDraw(Canvas canvas) {
      canvas.drawColor(Color.WHITE);

      canvas.translate(0, 1);
      drawChart(canvas, mBase * 256);
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
      switch (keyCode) {
      case KeyEvent.KEYCODE_DPAD_LEFT:
        if (mBase > 0) {
          mBase -= 1;
          invalidate();
        }
        return true;
      case KeyEvent.KEYCODE_DPAD_RIGHT:
        mBase += 1;
        invalidate();
        return true;
      default:
        break;
      }
      return super.onKeyDown(keyCode, event);
    }
  }
}

class GraphicsActivity extends Activity {
  // set to true to test Picture
  private static final boolean TEST_PICTURE = false;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
  }

  @Override
  public void setContentView(View view) {
    if (TEST_PICTURE) {
      ViewGroup vg = new PictureLayout(this);
      vg.addView(view);
      view = vg;
    }

    super.setContentView(view);
  }
}

class PictureLayout extends ViewGroup {
  private final Picture mPicture = new Picture();

  public PictureLayout(Context context) {
    super(context);
  }

  public PictureLayout(Context context, AttributeSet attrs) {
    super(context, attrs);
  }

  @Override
  public void addView(View child) {
    if (getChildCount() > 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child);
  }

  @Override
  public void addView(View child, int index) {
    if (getChildCount() > 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child, index);
  }

  @Override
  public void addView(View child, LayoutParams params) {
    if (getChildCount() > 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child, params);
  }

  @Override
  public void addView(View child, int index, LayoutParams params) {
    if (getChildCount() > 1) {
      throw new IllegalStateException(
          "PictureLayout can host only one direct child");
    }

    super.addView(child, index, params);
  }

  @Override
  protected LayoutParams generateDefaultLayoutParams() {
    return new LayoutParams(LayoutParams.MATCH_PARENT,
        LayoutParams.MATCH_PARENT);
  }

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    final int count = getChildCount();

    int maxHeight = 0;
    int maxWidth = 0;

    for (int i = 0; i < count; i++) {
      final View child = getChildAt(i);
      if (child.getVisibility() != GONE) {
        measureChild(child, widthMeasureSpec, heightMeasureSpec);
      }
    }

    maxWidth += getPaddingLeft() + getPaddingRight();
    maxHeight += getPaddingTop() + getPaddingBottom();

    Drawable drawable = getBackground();
    if (drawable != null) {
      maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
      maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
    }

    setMeasuredDimension(resolveSize(maxWidth, widthMeasureSpec),
        resolveSize(maxHeight, heightMeasureSpec));
  }

  private void drawPict(Canvas canvas, int x, int y, int w, int h, float sx,
      float sy) {
    canvas.save();
    canvas.translate(x, y);
    canvas.clipRect(0, 0, w, h);
    canvas.scale(0.5f, 0.5f);
    canvas.scale(sx, sy, w, h);
    canvas.drawPicture(mPicture);
    canvas.restore();
  }

  @Override
  protected void dispatchDraw(Canvas canvas) {
    super.dispatchDraw(mPicture.beginRecording(getWidth(), getHeight()));
    mPicture.endRecording();

    int x = getWidth() / 2;
    int y = getHeight() / 2;

    if (false) {
      canvas.drawPicture(mPicture);
    } else {
      drawPict(canvas, 0, 0, x, y, 1, 1);
      drawPict(canvas, x, 0, x, y, -1, 1);
      drawPict(canvas, 0, y, x, y, 1, -1);
      drawPict(canvas, x, y, x, y, -1, -1);
    }
  }

  @Override
  public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
    location[0] = getLeft();
    location[1] = getTop();
    dirty.set(0, 0, getWidth(), getHeight());
    return getParent();
  }

  @Override
  protected void onLayout(boolean changed, int l, int t, int r, int b) {
    final int count = super.getChildCount();

    for (int i = 0; i < count; i++) {
      final View child = getChildAt(i);
      if (child.getVisibility() != GONE) {
        final int childLeft = getPaddingLeft();
        final int childTop = getPaddingTop();
        child.layout(childLeft, childTop,
            childLeft + child.getMeasuredWidth(),
            childTop + child.getMeasuredHeight());

      }
    }
  }
}

Unicode Char To String

class Main {
  public static String UnicodeCharToString(char[] Char) {
    String strTemp = "";

    for (int i = 1; i < Char.length; i += 2) {
      String s1 = Integer.toHexString((int) Char[i]);
      String s2 = Integer.toHexString((int) Char[i - 1]);

      // ????????
      if (s1.length() == 1)
        s1 = "0" + s1;

      if (s2.length() == 1)
        s2 = "0" + s2;

      strTemp += s1 + s2;
    }

    return UnicodeToString(strTemp).trim();
  }

  public static String UnicodeToString(String Hex) {
    String enUnicode = null;
    String deUnicode = null;

    for (int i = 0; i < Hex.length(); i++) {
      if (enUnicode == null)
        enUnicode = String.valueOf(Hex.charAt(i));
      else
        enUnicode = enUnicode + Hex.charAt(i);

      if (i % 4 == 3) {
        if (enUnicode != null) {
          if (deUnicode == null)
            deUnicode = String.valueOf((char) Integer.valueOf(
                enUnicode, 16).intValue());
          else
            deUnicode = deUnicode
                + String.valueOf((char) Integer.valueOf(
                    enUnicode, 16).intValue());
        }

        enUnicode = null;
      }
    }

    return deUnicode;
  }
}

Convert to Unicode

import java.math.BigInteger;


class Util {

   // Constants and variables
   // -------------------------------------------------------------------------

   // Hex charset
   private static final char[] HEX_DIGITS = "0123456789ABCDEF".toCharArray();

   // Base-64 charset
   private static final String BASE64_CHARS =
      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz./";
   private static final char[] BASE64_CHARSET = BASE64_CHARS.toCharArray();

----------------------------------------------------------------------


   private Util() {
      super();
   }
------------------------------------------------------------------------


   public static String toString(byte[] ba) {
      return toString(ba, 0, ba.length);
   }

   public static final String toString(byte[] ba, int offset, int length) {
      char[] buf = new char[length * 2];
      for (int i = 0, j = 0, k; i < length; ) {
         k = ba[offset + i++];
         buf[j++] = HEX_DIGITS[(k >>> 4) & 0x0F];
         buf[j++] = HEX_DIGITS[ k        & 0x0F];
      }
      return new String(buf);
   }


   public static String toReversedString(byte[] ba) {
      return toReversedString(ba, 0, ba.length);
   }

   public static final String
   toReversedString(byte[] ba, int offset, int length) {
      char[] buf = new char[length * 2];
      for (int i = offset+length-1, j = 0, k; i >= offset; ) {
         k = ba[offset + i--];
         buf[j++] = HEX_DIGITS[(k >>> 4) & 0x0F];
         buf[j++] = HEX_DIGITS[ k        & 0x0F];
      }
      return new String(buf);
   }

   public static byte[] toBytesFromString(String s) {
      int limit = s.length();
      byte[] result = new byte[((limit + 1) / 2)];
      int i = 0, j = 0;
      if ((limit % 2) == 1) {
         result[j++] = (byte) fromDigit(s.charAt(i++));
      }
      while (i < limit) {
         result[j  ]  = (byte) (fromDigit(s.charAt(i++)) << 4);
         result[j++] |= (byte)  fromDigit(s.charAt(i++));
      }
      return result;
   }


   public static byte[] toReversedBytesFromString(String s) {
      int limit = s.length();
      byte[] result = new byte[((limit + 1) / 2)];
      int i = 0;
      if ((limit % 2) == 1) {
         result[i++] = (byte) fromDigit(s.charAt(--limit));
      }
      while (limit > 0) {
         result[i  ]  = (byte)  fromDigit(s.charAt(--limit));
         result[i++] |= (byte) (fromDigit(s.charAt(--limit)) << 4);
      }
      return result;
   }


   public static int fromDigit(char c) {
      if (c >= '0' && c <= '9') {
         return c - '0';
      } else if (c >= 'A' && c <= 'F') {
         return c - 'A' + 10;
      } else if (c >= 'a' && c <= 'f') {
         return c - 'a' + 10;
      } else
         throw new IllegalArgumentException("Invalid hexadecimal digit: " + c);
   }


   public static String toString(int n) {
      char[] buf = new char[8];
      for (int i = 7; i >= 0; i--) {
         buf[i] = HEX_DIGITS[n & 0x0F];
         n >>>= 4;
      }
      return new String(buf);
   }

 
   public static String toString(int[] ia) {
      int length = ia.length;
      char[] buf = new char[length * 8];
      for (int i = 0, j = 0, k; i < length; i++) {
         k = ia[i];
         buf[j++] = HEX_DIGITS[(k >>> 28) & 0x0F];
         buf[j++] = HEX_DIGITS[(k >>> 24) & 0x0F];
         buf[j++] = HEX_DIGITS[(k >>> 20) & 0x0F];
         buf[j++] = HEX_DIGITS[(k >>> 16) & 0x0F];
         buf[j++] = HEX_DIGITS[(k >>> 12) & 0x0F];
         buf[j++] = HEX_DIGITS[(k >>>  8) & 0x0F];
         buf[j++] = HEX_DIGITS[(k >>>  4) & 0x0F];
         buf[j++] = HEX_DIGITS[ k         & 0x0F];
      }
      return new String(buf);
   }


   public static String toString(long n) {
      char[] b = new char[16];
      for (int i = 15; i >= 0; i--) {
         b[i] = HEX_DIGITS[(int)(n & 0x0FL)];
         n >>>= 4;
      }
      return new String(b);
   }


   public static String toUnicodeString(byte[] ba) {
      return toUnicodeString(ba, 0, ba.length);
   }


   public static final String
   toUnicodeString(byte[] ba, int offset, int length) {
      StringBuffer sb = new StringBuffer();
      int i = 0;
      int j = 0;
      int k;
      sb.append('\n').append("\"");
      while (i < length) {
         sb.append("\\u");

         k = ba[offset + i++];
         sb.append(HEX_DIGITS[(k >>> 4) & 0x0F]);
         sb.append(HEX_DIGITS[ k        & 0x0F]);

         k = ba[offset + i++];
         sb.append(HEX_DIGITS[(k >>> 4) & 0x0F]);
         sb.append(HEX_DIGITS[ k        & 0x0F]);

         if ((++j % 8) == 0) {
            sb.append("\"+").append('\n').append("\"");
         }
      }
      sb.append("\"").append('\n');
      return sb.toString();
   }

 
   public static String toUnicodeString(int[] ia) {
      StringBuffer sb = new StringBuffer();
      int i = 0;
      int j = 0;
      int k;
      sb.append('\n').append("\"");
      while (i < ia.length) {
         k = ia[i++];
         sb.append("\\u");
         sb.append(HEX_DIGITS[(k >>> 28) & 0x0F]);
         sb.append(HEX_DIGITS[(k >>> 24) & 0x0F]);
         sb.append(HEX_DIGITS[(k >>> 20) & 0x0F]);
         sb.append(HEX_DIGITS[(k >>> 16) & 0x0F]);
         sb.append("\\u");
         sb.append(HEX_DIGITS[(k >>> 12) & 0x0F]);
         sb.append(HEX_DIGITS[(k >>>  8) & 0x0F]);
         sb.append(HEX_DIGITS[(k >>>  4) & 0x0F]);
         sb.append(HEX_DIGITS[ k         & 0x0F]);

         if ((++j % 4) == 0) {
            sb.append("\"+").append('\n').append("\"");
         }
      }
      sb.append("\"").append('\n');
      return sb.toString();
   }

   public static byte[] toBytesFromUnicode(String s) {
      int limit = s.length() * 2;
      byte[] result = new byte[limit];
      char c;
      for (int i = 0; i < limit; i++) {
         c = s.charAt(i >>> 1);
         result[i] = (byte)(((i & 1) == 0) ? c >>> 8 : c);
      }
      return result;
   }


   public static String dumpString(byte[] data, int offset, int length, String m) {
      if (data == null) {
         return m + "null\n";
      }
      StringBuffer sb = new StringBuffer(length * 3);
      if (length > 32) {
         sb.append(m).append("Hexadecimal dump of ").append(length).append(" bytes...\n");
      }
      // each line will list 32 bytes in 4 groups of 8 each
      int end = offset + length;
      String s;
      int l = Integer.toString(length).length();
      if (l < 4) {
         l = 4;
      }
      for ( ; offset < end; offset += 32) {
         if (length > 32) {
            s = "         " + offset;
            sb.append(m).append(s.substring(s.length()-l)).append(": ");
         }
         int i = 0;
         for ( ; i < 32 && offset + i + 7 < end; i += 8) {
            sb.append(toString(data, offset + i, 8)).append(' ');
         }
         if (i < 32) {
            for ( ; i < 32 && offset + i < end; i++) {
               sb.append(byteToString(data[offset + i]));
            }
         }
         sb.append('\n');
      }
      return sb.toString();
   }

   public static String dumpString(byte[] data) {
      return (data == null) ? "null\n" : dumpString(data, 0, data.length, "");
   }

   public static String dumpString(byte[] data, String m) {
      return (data == null) ? "null\n" : dumpString(data, 0, data.length, m);
   }

   public static String dumpString(byte[] data, int offset, int length) {
      return dumpString(data, offset, length, "");
   }


   public static String byteToString(int n) {
      char[] buf = { HEX_DIGITS[(n >>> 4) & 0x0F], HEX_DIGITS[n & 0x0F] };
      return new String(buf);
   }

   public static final String toBase64(byte[] buffer) {
      int len = buffer.length, pos = len % 3;
      byte b0 = 0, b1 = 0, b2 = 0;
      switch (pos) {
      case 1:
         b2 = buffer[0];
         break;
      case 2:
         b1 = buffer[0];
         b2 = buffer[1];
         break;
      }
      StringBuffer sb = new StringBuffer();
      int c;
      boolean notleading = false;
      do {
         c = (b0 & 0xFC) >>> 2;
         if (notleading || c != 0) {
           sb.append(BASE64_CHARSET[c]);
           notleading = true;
         }
         c = ((b0 & 0x03) << 4) | ((b1 & 0xF0) >>> 4);
         if (notleading || c != 0) {
           sb.append(BASE64_CHARSET[c]);
           notleading = true;
         }
         c = ((b1 & 0x0F) << 2) | ((b2 & 0xC0) >>> 6);
         if (notleading || c != 0) {
           sb.append(BASE64_CHARSET[c]);
           notleading = true;
         }
         c = b2 & 0x3F;
         if (notleading || c != 0) {
           sb.append(BASE64_CHARSET[c]);
           notleading = true;
         }
         if (pos >= len) {
           break;
         } else {
           try {
             b0 = buffer[pos++];
             b1 = buffer[pos++];
             b2 = buffer[pos++];
           } catch (ArrayIndexOutOfBoundsException x) {
             break;
           }
         }
      } while (true);

      if (notleading) {
        return sb.toString();
      }
      return "0";
   }

   public static final byte[] fromBase64(String str) {
      int len = str.length();
      if (len == 0) {
         throw new NumberFormatException("Empty string");
      }
      byte[] a = new byte[len + 1];
      int i, j;
      for (i = 0; i < len; i++) {
         try {
            a[i] = (byte) BASE64_CHARS.indexOf(str.charAt(i));
         } catch (ArrayIndexOutOfBoundsException x) {
            throw new NumberFormatException("Illegal character at #"+i);
         }
      }
      i = len - 1;
      j = len;
      try {
         while (true) {
            a[j] = a[i];
            if (--i < 0) {
               break;
            }
            a[j] |= (a[i] & 0x03) << 6;
            j--;
            a[j] = (byte)((a[i] & 0x3C) >>> 2);
            if (--i < 0) {
               break;
            }
            a[j] |= (a[i] & 0x0F) << 4;
            j--;
            a[j] = (byte)((a[i] & 0x30) >>> 4);
            if (--i < 0) {
               break;
            }
            a[j] |= (a[i] << 2);
            j--;
            a[j] = 0;
            if (--i < 0) {
               break;
            }
         }
      } catch (Exception ignored) {
      }

      try { // ignore leading 0-bytes
         while(a[j] == 0) {
            j++;
         }
      } catch (Exception x) {
         return new byte[1]; // one 0-byte
      }
      byte[] result = new byte[len - j + 1];
      System.arraycopy(a, j, result, 0, len - j + 1);
      return result;
   }

   public static final byte[] trim(BigInteger n) {
      byte[] in = n.toByteArray();
      if (in.length == 0 || in[0] != 0) {
         return in;
      }
      int len = in.length;
      int i = 1;
      while (in[i] == 0 && i < len) {
         ++i;
      }
      byte[] result = new byte[len - i];
      System.arraycopy(in, i, result, 0, len - i);
      return result;
   }

   public static final String dump(BigInteger x) {
      return dumpString(trim(x));
   }
}

implements UncaughtExceptionHandler

//package ch.dissem.android.utils;

import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.Date;
import java.util.Locale;

import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Environment;
import android.os.StatFs;
import android.util.Log;


public class CustomExceptionHandler implements UncaughtExceptionHandler {
  private static final String RECIPIENT = "chrigu.meyer@gmail.com";

  private Thread.UncaughtExceptionHandler previousHandler;
  private Context context;

  public CustomExceptionHandler(Context ctx, UncaughtExceptionHandler previous) {
    previousHandler = previous;
    context = ctx;
  }

  private StatFs getStatFs() {
    File path = Environment.getDataDirectory();
    return new StatFs(path.getPath());
  }

  private long getAvailableInternalMemorySize(StatFs stat) {
    long blockSize = stat.getBlockSize();
    long availableBlocks = stat.getAvailableBlocks();
    return availableBlocks * blockSize;
  }

  private long getTotalInternalMemorySize(StatFs stat) {
    long blockSize = stat.getBlockSize();
    long totalBlocks = stat.getBlockCount();
    return totalBlocks * blockSize;
  }

  private void addInformation(StringBuilder message) {
    message.append("Locale: ").append(Locale.getDefault()).append('\n');
    try {
      PackageManager pm = context.getPackageManager();
      PackageInfo pi;
      pi = pm.getPackageInfo(context.getPackageName(), 0);
      message.append("Version: ").append(pi.versionName).append('\n');
      message.append("Package: ").append(pi.packageName).append('\n');
    } catch (Exception e) {
      Log.e("CustomExceptionHandler", "Error", e);
      message.append("Could not get Version information for ").append(
          context.getPackageName());
    }
    message.append("Phone Model: ").append(android.os.Build.MODEL).append(
        '\n');
    message.append("Android Version: ").append(
        android.os.Build.VERSION.RELEASE).append('\n');
    message.append("Board: ").append(android.os.Build.BOARD).append('\n');
    message.append("Brand: ").append(android.os.Build.BRAND).append('\n');
    message.append("Device: ").append(android.os.Build.DEVICE).append('\n');
    message.append("Host: ").append(android.os.Build.HOST).append('\n');
    message.append("ID: ").append(android.os.Build.ID).append('\n');
    message.append("Model: ").append(android.os.Build.MODEL).append('\n');
    message.append("Product: ").append(android.os.Build.PRODUCT).append(
        '\n');
    message.append("Type: ").append(android.os.Build.TYPE).append('\n');
    StatFs stat = getStatFs();
    message.append("Total Internal memory: ").append(
        getTotalInternalMemorySize(stat)).append('\n');
    message.append("Available Internal memory: ").append(
        getAvailableInternalMemorySize(stat)).append('\n');
  }

  public void uncaughtException(Thread t, Throwable e) {
    try {
      StringBuilder report = new StringBuilder();
      Date curDate = new Date();
      report.append("Error Report collected on : ").append(
          curDate.toString()).append('\n').append('\n');

      report.append("Informations :").append('\n');

      addInformation(report);

      report.append('\n').append('\n');
      report.append("Stack:\n");
      final Writer result = new StringWriter();
      final PrintWriter printWriter = new PrintWriter(result);
      e.printStackTrace(printWriter);
      report.append(result.toString());
      printWriter.close();
      report.append('\n');
      report.append("****  End of current Report ***");
      sendErrorMail(report);
    } catch (Throwable ignore) {
      Log.e(CustomExceptionHandler.class.getName(),
          "Error while sending error e-mail", ignore);
    }
    previousHandler.uncaughtException(t, e);
  }

  private void sendErrorMail(StringBuilder errorContent) {
    Intent sendIntent = new Intent(Intent.ACTION_SEND);
    String subject = "app_name crashed! Fix it!";
    StringBuilder body = new StringBuilder("app_name");
    body.append('\n').append('\n');
    body.append(errorContent).append('\n').append('\n');
    sendIntent.putExtra(Intent.EXTRA_EMAIL, new String[] { RECIPIENT });
    sendIntent.putExtra(Intent.EXTRA_TEXT, body.toString());
    sendIntent.putExtra(Intent.EXTRA_SUBJECT, subject);
    sendIntent.setType("message/rfc822");
    context.startActivity(Intent.createChooser(sendIntent, "Error Report"));
  }
}

Error Reporter

//package com.brewzor.utils;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Date;
import java.util.Random;

import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Environment;
import android.os.StatFs;

// based on code from http://androidblogger.blogspot.com/2009/12/how-to-improve-your-application-crash.html
class ErrorReporter implements Thread.UncaughtExceptionHandler {

  static private final String EOL = "\n";
  
  String VersionName;
  String PackageName;
  String FilePath;
  String PhoneModel;
  String AndroidVersion;
  String Board;
  String Brand;
  String Device;
  String Display;
  String FingerPrint;
  String Host; 
  String ID;
  String Manufacturer;
  String Model;
  String Product;
  String Tags;
  long Time;
  String Type;
  String User; 

  private Thread.UncaughtExceptionHandler PreviousHandler;
  private static ErrorReporter S_mInstance;
  private Context CurContext;

  public void Init(Context context) {
    PreviousHandler = Thread.getDefaultUncaughtExceptionHandler();
    Thread.setDefaultUncaughtExceptionHandler(this);  
    getEnvironmentInfo(context);
    CurContext = context;
  }

  public long getAvailableInternalMemorySize() { 
    File path = Environment.getDataDirectory(); 
    StatFs stat = new StatFs(path.getPath()); 
    long blockSize = stat.getBlockSize(); 
    long availableBlocks = stat.getAvailableBlocks(); 
    return availableBlocks * blockSize; 
  } 

  public long getTotalInternalMemorySize() { 
    File path = Environment.getDataDirectory(); 
    StatFs stat = new StatFs(path.getPath()); 
    long blockSize = stat.getBlockSize(); 
    long totalBlocks = stat.getBlockCount(); 
    return totalBlocks * blockSize; 
  } 

  void getEnvironmentInfo(Context context)
  {
    PackageManager pm = context.getPackageManager();
    try
    {
      PackageInfo pi;

      // populate environment info variables
      pi = pm.getPackageInfo(context.getPackageName(), 0);
      VersionName = pi.versionName;
      PackageName = pi.packageName;
      FilePath = context.getFilesDir().getAbsolutePath();
      PhoneModel = android.os.Build.MODEL;
      AndroidVersion = android.os.Build.VERSION.RELEASE;
      Board = android.os.Build.BOARD;      
      Brand  = android.os.Build.BRAND;
      Device  = android.os.Build.DEVICE;
      Display = android.os.Build.DISPLAY;
      FingerPrint = android.os.Build.FINGERPRINT;
      Host = android.os.Build.HOST;
      ID = android.os.Build.ID;
      Model = android.os.Build.MODEL;
      Product = android.os.Build.PRODUCT;
      Tags = android.os.Build.TAGS;
      Time = android.os.Build.TIME;
      Type = android.os.Build.TYPE;
      User = android.os.Build.USER;

    }
    catch (NameNotFoundException e)
    {
      e.printStackTrace();
    }
  }

  public String CreateInformationString()
  {
    String ReturnVal = "";
    ReturnVal += "Version : " + VersionName + EOL;
    ReturnVal += "Package : " + PackageName + EOL;
    ReturnVal += "FilePath : " + FilePath + EOL;
    ReturnVal += "Phone Model" + PhoneModel + EOL;
    ReturnVal += "Android Version : " + AndroidVersion + EOL;
    ReturnVal += "Board : " + Board + EOL;
    ReturnVal += "Brand : " + Brand + EOL;
    ReturnVal += "Device : " + Device + EOL;
    ReturnVal += "Display : " + Display + EOL;
    ReturnVal += "Finger Print : " + FingerPrint + EOL;
    ReturnVal += "Host : " + Host + EOL;
    ReturnVal += "ID : " + ID + EOL;
    ReturnVal += "Model : " + Model + EOL;
    ReturnVal += "Product : " + Product + EOL;
    ReturnVal += "Tags : " + Tags + EOL;
    ReturnVal += "Time : " + Time + EOL;
    ReturnVal += "Type : " + Type + EOL;
    ReturnVal += "User : " + User + EOL;
    ReturnVal += "Total Internal memory : " + getTotalInternalMemorySize() + EOL;
    ReturnVal += "Available Internal memory : " + getAvailableInternalMemorySize() + EOL;

    return ReturnVal;
  }

  public void uncaughtException(Thread t, Throwable e)
  {
    String Report = "";
    Date CurDate = new Date();
    Report += "Error Report collected on : " + CurDate.toString() + EOL + EOL;
    Report += "Information :" + EOL;
    Report += "" + EOL + EOL;
    Report += CreateInformationString() + EOL + EOL;
    Report += "Stack :" + EOL;
    Report += "" + EOL;
    
    final Writer result = new StringWriter();
    final PrintWriter printWriter = new PrintWriter(result);
    e.printStackTrace(printWriter);
    String stacktrace = result.toString();
    Report += stacktrace + EOL;

    // If the exception was thrown in a background thread inside
    // AsyncTask, then the actual exception can be found with getCause
    Throwable cause = e.getCause();
    if (cause != null) {
      Report += "Cause :" + EOL;
      Report += "" + EOL;
      while (cause != null)
      {
        cause.printStackTrace(printWriter);
        Report += result.toString();
        cause = cause.getCause();
      }
    }
    printWriter.close();
    Report += "****  End of current Report ***" + EOL;
    SaveAsFile(Report);
    PreviousHandler.uncaughtException(t, e);
  }

  public void deleteAllReports() {
    String[] ErrorFileList = GetErrorFileList();
    for (String curString : ErrorFileList) {
      File curFile = new File(FilePath + "/" + curString);
      curFile.delete();
    }
  }
  
  public static ErrorReporter getInstance()
  {
    if (S_mInstance == null)
      S_mInstance = new ErrorReporter();
    return S_mInstance;
  }

  private void SendErrorMail(Context _context, String ErrorContent)
  {
    Intent sendIntent = new Intent(Intent.ACTION_SEND);
    String subject =  "crash_report_mail_subject";
    String body = "crash_report_mail_body" + EOL + EOL +
    ErrorContent +
    EOL + EOL;
    sendIntent.putExtra(Intent.EXTRA_EMAIL, new String[] {"james@brewzor.com"});
    sendIntent.putExtra(Intent.EXTRA_TEXT, body);
    sendIntent.putExtra(Intent.EXTRA_SUBJECT, subject);
    sendIntent.setType("message/rfc822");
    _context.startActivity(Intent.createChooser(sendIntent, "Send Email Via:"));
  }
  
  private void SaveAsFile(String ErrorContent)
  {
    try
    {
      Random generator = new Random();
      int random = generator.nextInt(99999);
      String FileName = "stack-" + random + ".stacktrace";
      FileOutputStream trace = CurContext.openFileOutput( FileName, Context.MODE_PRIVATE);
      trace.write(ErrorContent.getBytes());
      trace.close();
    }
    catch(IOException ioe) {
      // ...
    }
  }

  private String[] GetErrorFileList()
  {
    File dir = new File(FilePath + "/");
    // Try to create the files folder if it doesn't exist
    dir.mkdir();
    // Filter for ".stacktrace" files
    FilenameFilter filter = new FilenameFilter() {
      public boolean accept(File dir, String name) {
        return name.endsWith(".stacktrace");
      }
    };
    return dir.list(filter);
  }
  
  public boolean bIsThereAnyErrorFile()
  {
    return GetErrorFileList().length > 0;
  }
  
  public void CheckErrorAndSendMail(Context _context)
  {
    try
    {
      if (bIsThereAnyErrorFile())
      {
        String WholeErrorText = "";
        String[] ErrorFileList = GetErrorFileList();
        int curIndex = 0;
        // We limit the number of crash reports to send ( in order not to be too slow )
        final int MaxSendMail = 2;
        for (String curString : ErrorFileList)
        {
          if (curIndex++ <= MaxSendMail)
          {
            WholeErrorText+="New Trace collected :" + EOL;
            WholeErrorText+="" + EOL;
            String filePath = FilePath + "/" + curString;
            BufferedReader input =  new BufferedReader(new FileReader(filePath));
            String line;
            while ((line = input.readLine()) != null)
            {
              WholeErrorText += line + EOL;
            }
            input.close();
          }

          // DELETE FILES !!!!
          File curFile = new File( FilePath + "/" + curString);
          curFile.delete();
        }

        SendErrorMail(_context , WholeErrorText);
      
        if (bIsThereAnyErrorFile())
        {
          // clear up any remaining reports
          deleteAllReports();
        }      

      }

    }
    catch(Exception e)
    {
      e.printStackTrace();
    }
  }
}

CustomExceptionHandler implements UncaughtExceptionHandler

    
//package com.jleorz.common;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;

import android.content.Context;

public class CustomExceptionHandler implements UncaughtExceptionHandler {

  private UncaughtExceptionHandler defaultUEH;

  private String localPath;

  private String url;

  private String appName;

  private Context activity;


  public static final String VERSION = "VERSION";
  public static final String LOCALPATH = "LOCALPATH";
  public static final String SENDERRORURL = "URL";
  public static final String ERROREEQUESR = "ERROREEQUESR";
  public static final String APP_NAME = "APP_NAME";

  public CustomExceptionHandler(Context activity) {
    this.localPath = LOCALPATH;
    this.url = SENDERRORURL;
    this.appName = APP_NAME;
    this.activity = activity;
    this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler();
  }

  public void uncaughtException(Thread t, Throwable e) {
    final Writer result = new StringWriter();
    final PrintWriter printWriter = new PrintWriter(result);
    e.printStackTrace(printWriter);
    String stacktrace = result.toString();
    printWriter.close();
    String filename = new Date().getTime() + ".stacktrace";

    if (localPath != null) {
      File file = new File(localPath);
      if (!file.exists())
        try {
          file.createNewFile();
        } catch (IOException e1) {

        }
      writeToFile(stacktrace, filename);
    }

    if (url != null) {
      sendToServer(stacktrace, filename);
    }

    defaultUEH.uncaughtException(t, e);
  }

  private void writeToFile(String stacktrace, String filename) {
    try {
      BufferedWriter bos = new BufferedWriter(new FileWriter(localPath
          + "/" + filename));
      bos.write(stacktrace);
      bos.flush();
      bos.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  private void sendToServer(String stacktrace, String filename) {
    DefaultHttpClient httpClient = new DefaultHttpClient();
    HttpPost httpPost = new HttpPost(url);
    List<NameValuePair> nvps = new ArrayList<NameValuePair>();
    nvps.add(new BasicNameValuePair("filename", filename));
    nvps.add(new BasicNameValuePair("appName", appName));
    nvps.add(new BasicNameValuePair("stacktrace", stacktrace));
    nvps.add(new BasicNameValuePair("deviceInfo", android.os.Build.MODEL
        + "," + android.os.Build.VERSION.SDK + ","
        + android.os.Build.VERSION.RELEASE));
    nvps.add(new BasicNameValuePair("versionCode", "1"));

    try {
      httpPost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
      httpClient.execute(httpPost);
    } catch (IOException e) {
      //
    }
  }
}

Move To Next Sibling XmlPullParser

  
//package org.pulloid;

import java.io.IOException;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

class ParserUtil {
  
  
  static boolean moveToNextSibling(XmlPullParser parser) throws XmlPullParserException, IOException {
    String currentTag = parser.getName();
    int currentLevel = parser.getDepth();
    do {
      if(parser.getEventType() != XmlPullParser.END_DOCUMENT)
        parser.next();
      else
        return false;
    } while(!(currentLevel == parser.getDepth() && parser.getEventType() == XmlPullParser.END_TAG && currentTag.equals(parser.getName())));
    parser.nextTag(); // Next sibling's start tag or parent's end tag
    return true;
  }
  

  static boolean isStartTag(XmlPullParser parser) throws XmlPullParserException {
    return parser.getEventType() == XmlPullParser.START_TAG;
  }
  
  static boolean isEndTag(XmlPullParser parser) throws XmlPullParserException {
    return parser.getEventType() == XmlPullParser.END_TAG;
  }

  static boolean isStartDocument(XmlPullParser parser) throws XmlPullParserException {
    return parser.getEventType() == XmlPullParser.START_DOCUMENT;
  }
  
  static boolean isEndDocument(XmlPullParser parser) throws XmlPullParserException {
    return parser.getEventType() == XmlPullParser.END_DOCUMENT;
  }

}

XmlPullParser Util

//package com.google.code.linkedinapi.schema.xpp;

import java.io.IOException;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlSerializer;

/**
 * The Class DomUtils.
 * 
 * @author    Nabeel Mukhtar
 * @version   1.0
 */
public class XppUtils {

    /**
     * Sets the element value to node.
     * 
     * @param node the node
     * @param elementName the element name
     * @param elementValue the element value
     */
    public static void setElementValueToNode(XmlSerializer serializer, String elementName, Object elementValue) throws IOException {
      if (elementValue != null) {
        serializer.startTag(null, elementName).text(elementValue.toString()).endTag(null, elementName);
      }
    }

    /**
     * Sets the element value.
     * 
     * @param node the node
     * @param elementValue the element value
     */
    public static void setElementValue(XmlSerializer serializer, Object elementValue) throws IOException {
      if (elementValue != null) {
        serializer.text(elementValue.toString());
      }
    }
    
    /**
     * Sets the attribute value to node.
     * 
     * @param node the node
     * @param attributeName the attribute name
     * @param attributeValue the attribute value
     */
    public static void setAttributeValueToNode(XmlSerializer serializer, String attributeName, Object attributeValue) throws IOException {
      if (attributeValue != null) {
        serializer.attribute(null, attributeName, String.valueOf(attributeValue));
      }
    }
    

    public static String getElementValueFromNode(XmlPullParser node) throws XmlPullParserException, IOException {
      return node.nextText();
    }

    public static Long getElementValueAsLongFromNode(XmlPullParser node) throws IOException, XmlPullParserException {
      String value = node.nextText();
      if (isNullOrEmpty(value)) {
        return null;
      } else {
            return Long.valueOf(value);
      }
    }
    

    /**
     * Gets the attribute value from node.
     * 
     * @param node the node
     * @param attributeName the attribute name
     * 
     * @return the attribute value from node
     */
    public static String getAttributeValueFromNode(XmlPullParser node, String attributeName) {
        return node.getAttributeValue(null, attributeName);
    }


    public static Long getAttributeValueAsLongFromNode(XmlPullParser node, String attributeName) {
      String attribute = node.getAttributeValue(null, attributeName);
      if (isNullOrEmpty(attribute)) {
        return null;
      } else {
        return Long.valueOf(attribute);
      }
    }
    
    public static void skipSubTree(XmlPullParser parser) throws XmlPullParserException, IOException {
        parser.require(XmlPullParser.START_TAG, null, null);
        int level = 1;
        while (level > 0) {
            int eventType = parser.next();
            if (eventType == XmlPullParser.END_TAG) {
                --level;
            } else if (eventType == XmlPullParser.START_TAG) {
                ++level;
            }
        }
    }

    private static boolean isNullOrEmpty(String string) {
      return (string == null || string.length() == 0);
    }
}

read setting name list from resource with XmlPullParser

  
import java.io.IOException;
import java.util.ArrayList;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import android.content.Context;
import android.content.res.XmlResourceParser;
import android.util.Log;

class Main {
    private static final String TAG = "Utility";

    public static final String ATTR_NAME = "name";

    public static final String TAG_NAME = "settings";
  /**
   * read setting name list from resource
   * 
   * @return list of setting name
   */
  public static ArrayList<String> getSettingNameList(int resource,
      Context context) {
    XmlResourceParser parser = context.getResources().getXml(resource);
    ArrayList<String> settingNameList = new ArrayList<String>();

    try {
      while (parser.next() != XmlPullParser.END_DOCUMENT) {
        if (parser.getEventType() == XmlPullParser.START_TAG
            && TAG_NAME.equals(parser.getName())) {
          String settingName = parser.getAttributeValue(null,
              ATTR_NAME);
          if (settingName != null) {
            Log.i(TAG, settingName);
            settingNameList.add(settingName);
          }
        }
      }
    } catch (XmlPullParserException e) {
      Log.e(TAG, "Parser Exception : ", e);
    } catch (IOException e) {
      Log.e(TAG, "IOException : ", e);
    }

    parser.close();

    return settingNameList;
  }

}

Zip Util

 
//package com.softright.tools;

import android.util.Log;

public class XZip {

  public XZip(){

  }
  

  public static java.util.List<java.io.File> GetFileList(String zipFileString, boolean bContainFolder, boolean bContainFile)throws Exception {
    
    android.util.Log.v("XZip", "GetFileList(String)");
    
    java.util.List<java.io.File> fileList = new java.util.ArrayList<java.io.File>();
    java.util.zip.ZipInputStream inZip = new java.util.zip.ZipInputStream(new java.io.FileInputStream(zipFileString));
    java.util.zip.ZipEntry zipEntry;
    String szName = "";
    
    while ((zipEntry = inZip.getNextEntry()) != null) {
      szName = zipEntry.getName();
    
      if (zipEntry.isDirectory()) {
    
        // get the folder name of the widget
        szName = szName.substring(0, szName.length() - 1);
        java.io.File folder = new java.io.File(szName);
        if (bContainFolder) {
          fileList.add(folder);
        }
    
      } else {
        java.io.File file = new java.io.File(szName);
        if (bContainFile) {
          fileList.add(file);
        }
      }
    }//end of while
    
    inZip.close();
    
    return fileList;
  }

  public static java.io.InputStream UpZip(String zipFileString, String fileString)throws Exception {
    android.util.Log.v("XZip", "UpZip(String, String)");
    java.util.zip.ZipFile zipFile = new java.util.zip.ZipFile(zipFileString);
    java.util.zip.ZipEntry zipEntry = zipFile.getEntry(fileString);
    
    return zipFile.getInputStream(zipEntry);

  }
  
  

  public static boolean UnZipFolder(String zipFileString, String outPathString)throws Exception {
    android.util.Log.v("XZip", "UnZipFolder(String, String)");
    java.util.zip.ZipInputStream inZip = new java.util.zip.ZipInputStream(new java.io.FileInputStream(zipFileString));
    java.util.zip.ZipEntry zipEntry;
    String szName = "";
    while ((zipEntry = inZip.getNextEntry()) != null) {
      szName = zipEntry.getName();
      if (zipEntry.isDirectory()) {
        szName = szName.substring(0, szName.length() - 1);
        java.io.File folder = new java.io.File(outPathString + java.io.File.separator + szName);
        folder.mkdirs();
      } else {
        try{
        java.io.File file = new java.io.File(outPathString + java.io.File.separator + szName);
        file.createNewFile();
        java.io.FileOutputStream out = new java.io.FileOutputStream(file);
        int len;
        byte[] buffer = new byte[1024];
        while ((len = inZip.read(buffer)) != -1) {
          out.write(buffer, 0, len);
          out.flush();
        }
        out.close();
        }catch(Exception e){
          Log.d("UI","unzip error!");
        }
      }
    }    
    inZip.close();
    return true;
  }
  
  


  public static void ZipFolder(String srcFileString, String zipFileString)throws Exception {
    android.util.Log.v("XZip", "ZipFolder(String, String)");

    java.util.zip.ZipOutputStream outZip = new java.util.zip.ZipOutputStream(new java.io.FileOutputStream(zipFileString));
   
    java.io.File file = new java.io.File(srcFileString);


    ZipFiles(file.getParent()+java.io.File.separator, file.getName(), outZip);
 
    outZip.finish();
    outZip.close();
  
  }//end of func
  

  private static void ZipFiles(String folderString, String fileString, java.util.zip.ZipOutputStream zipOutputSteam)throws Exception{
    android.util.Log.v("XZip", "ZipFiles(String, String, ZipOutputStream)");
    
    if(zipOutputSteam == null)
      return;
    
    java.io.File file = new java.io.File(folderString+fileString);
    
    //???????
    if (file.isFile()) {

      java.util.zip.ZipEntry zipEntry =  new java.util.zip.ZipEntry(fileString);
      java.io.FileInputStream inputStream = new java.io.FileInputStream(file);
      zipOutputSteam.putNextEntry(zipEntry);
      
      int len;
      byte[] buffer = new byte[4096];
      
      while((len=inputStream.read(buffer)) != -1)
      {
        zipOutputSteam.write(buffer, 0, len);
      }
      
      zipOutputSteam.closeEntry();
    }
    else {
      
      //??????,??????????
      String fileList[] = file.list();
      
      //???????, ???????
      if (fileList.length <= 0) {
        java.util.zip.ZipEntry zipEntry =  new java.util.zip.ZipEntry(fileString+java.io.File.separator);
        zipOutputSteam.putNextEntry(zipEntry);
        zipOutputSteam.closeEntry();        
      }
      
    
      for (int i = 0; i < fileList.length; i++) {
        ZipFiles(folderString, fileString+java.io.File.separator+fileList[i], zipOutputSteam);
      }//end of for
  
    }//end of if
    
  }//end of func
  
  public void finalize() throws Throwable {
    
  }

}   

Zip Reader

 

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

class ZipReader {
  private static final File file = new File("/sdcard/a.zip");
  
  public static Bitmap getBitmap(String name) throws IOException {
    Bitmap result = null;
    ZipFile zip = null;
    try {
      zip = new ZipFile(file, ZipFile.OPEN_READ);
    
      ZipEntry entry = zip.getEntry(name);
      if (entry != null && !entry.isDirectory()) {
        InputStream is = null;
        try {
          is = zip.getInputStream(entry);
          result = BitmapFactory.decodeStream(is);
        } finally {
          if (is != null) {
            is.close();
          }
        }
        
      }
    } finally {
      if (zip != null) {
        zip.close();
      }
    }
    return result;
  }

}

unzip

//package org.ametro.util;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class ZipUtil {

  public static void unzip(File archive, File path) throws IOException{
    ZipInputStream zip = null;
    String fileName = null;
    try{
      if(!path.exists()){
        path.mkdirs();
      }
      zip = new ZipInputStream(new FileInputStream(archive));
      ZipEntry zipEntry; 
      while((zipEntry=zip.getNextEntry()) != null) { 
        fileName = zipEntry.getName();
        final File outputFile = new File(path, fileName); 
        writeToStream(new BufferedInputStream(zip), new FileOutputStream(outputFile), false);
        zip.closeEntry();
      }
      zip.close();
      zip = null;
    }finally{
      if(zip != null){
        try{ zip.close(); } catch(Exception e){}
      }
    }
  }
  public static void writeToStream(InputStream in , OutputStream out, boolean closeOnExit) throws IOException 
  {
    byte[] bytes = new byte[2048];
    for (int c = in.read(bytes); c != -1; c = in.read(bytes)) {
      out.write(bytes,0, c);
    }
    if(closeOnExit){
      in.close();
      out.close();
    }
  }
  public static String writeToString(InputStream stream) throws java.io.IOException{
        StringBuffer fileData = new StringBuffer(1000);
        BufferedReader reader = new BufferedReader(new InputStreamReader(stream,"utf-8"));
        char[] buf = new char[1024];
        int numRead=0;
        while((numRead=reader.read(buf)) != -1){
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[1024];
        }
        reader.close();
        return fileData.toString();
    }
}