Initial Project Import

src/org/thoughtcrime/securesms/util/CharacterCalculator.java

@@ -0,0 +1,55 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+import org.thoughtcrime.securesms.sms.SmsTransportDetails;
+
+public class CharacterCalculator {
+
+  public CharacterState calculateCharacters(int charactersSpent) {
+    int maxMessageSize;
+		
+    if (charactersSpent <= SmsTransportDetails.SMS_SIZE) {
+      maxMessageSize = SmsTransportDetails.SMS_SIZE;
+    } else {
+      maxMessageSize = SmsTransportDetails.MULTIPART_SMS_SIZE;
+    }
+
+    int messagesSpent = charactersSpent / maxMessageSize;
+		
+    if (((charactersSpent % maxMessageSize) > 0) || (messagesSpent == 0))
+      messagesSpent++;
+		
+    int charactersRemaining = (maxMessageSize * messagesSpent) - charactersSpent;
+
+    return new CharacterState(messagesSpent, charactersRemaining, maxMessageSize);
+  }
+	
+	
+  public class CharacterState {
+    public int charactersRemaining;
+    public int messagesSpent;
+    public int maxMessageSize;
+		
+    public CharacterState(int messagesSpent, int charactersRemaining, int maxMessageSize) {
+      this.messagesSpent       = messagesSpent;
+      this.charactersRemaining = charactersRemaining;
+      this.maxMessageSize      = maxMessageSize;
+    }
+  }
+}
+

src/org/thoughtcrime/securesms/util/Combiner.java

@@ -0,0 +1,45 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+public class Combiner {
+
+  public static byte[] combine(byte[] a, byte[] b) {
+    byte[] combined = new byte[a.length + b.length];
+    System.arraycopy(a, 0, combined, 0, a.length);
+    System.arraycopy(b, 0, combined, a.length, b.length);
+    return combined;
+  }
+
+  public static byte[] combine(byte[] a, byte[] b, byte[] c) {
+    byte[] combined = new byte[a.length + b.length + c.length];
+    System.arraycopy(a, 0, combined, 0, a.length);
+    System.arraycopy(b, 0, combined, a.length, b.length);
+    System.arraycopy(c, 0, combined, a.length + b.length, c.length);
+    return combined;
+  }
+	
+  public static byte[] combine(byte[] a, byte[] b, byte[] c, byte[] d) {
+    byte[] combined = new byte[a.length + b.length + c.length + d.length];
+    System.arraycopy(a, 0, combined, 0, a.length);
+    System.arraycopy(b, 0, combined, a.length, b.length);
+    System.arraycopy(c, 0, combined, a.length + b.length, c.length);
+    System.arraycopy(d, 0, combined, a.length + b.length + c.length, d.length);
+    return combined;
+  }
+	
+}

src/org/thoughtcrime/securesms/util/Conversions.java

@@ -0,0 +1,172 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+public class Conversions {
+
+  public static byte intsToByteHighAndLow(int highValue, int lowValue) {		
+    return (byte)((highValue << 4 | lowValue) & 0xFF);
+  }
+	
+  public static int highBitsToInt(byte value) {
+    return (value & 0xFF) >> 4;
+  }
+	
+  public static int lowBitsToInt(byte value) {
+    return (value & 0xF);
+  }
+	
+  public static int highBitsToMedium(int value) {
+    return (value >> 12);
+  }
+	
+  public static int lowBitsToMedium(int value) {
+    return (value & 0xFFF);
+  }
+	
+  public static byte[] shortToByteArray(int value) {
+    byte[] bytes = new byte[2];
+    shortToByteArray(bytes, 0, value);
+    return bytes;
+  }
+
+  public static int shortToByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset+1] = (byte)value;
+    bytes[offset]   = (byte)(value >> 8);
+    return 2;
+  }
+
+  public static int shortToLittleEndianByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset]   = (byte)value;
+    bytes[offset+1] = (byte)(value >> 8);
+    return 2;
+  }
+
+  public static byte[] mediumToByteArray(int value) {
+    byte[] bytes = new byte[3];
+    mediumToByteArray(bytes, 0, value);
+    return bytes;
+  }
+	  
+  public static int mediumToByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset + 2] = (byte)value;
+    bytes[offset + 1] = (byte)(value >> 8);
+    bytes[offset]     = (byte)(value >> 16);
+    return 3;
+  }
+
+  public static byte[] intToByteArray(int value) {
+    byte[] bytes = new byte[4];
+    intToByteArray(bytes, 0, value);
+    return bytes;
+  }
+
+  public static int intToByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset + 3] = (byte)value;
+    bytes[offset + 2] = (byte)(value >> 8);
+    bytes[offset + 1] = (byte)(value >> 16);
+    bytes[offset]     = (byte)(value >> 24);
+    return 4;
+  }
+
+  public static int intToLittleEndianByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset]   = (byte)value;
+    bytes[offset+1] = (byte)(value >> 8);
+    bytes[offset+2] = (byte)(value >> 16);
+    bytes[offset+3] = (byte)(value >> 24);
+    return 4;
+  }
+
+  public static byte[] longToByteArray(long l) {
+    byte[] bytes = new byte[8];
+    longToByteArray(bytes, 0, l);
+    return bytes;
+  }
+
+  public static int longToByteArray(byte[] bytes, int offset, long value) {
+    bytes[offset + 7] = (byte)value;
+    bytes[offset + 6] = (byte)(value >> 8);
+    bytes[offset + 5] = (byte)(value >> 16);
+    bytes[offset + 4] = (byte)(value >> 24);
+    bytes[offset + 3] = (byte)(value >> 32);
+    bytes[offset + 2] = (byte)(value >> 40);
+    bytes[offset + 1] = (byte)(value >> 48);
+    bytes[offset]     = (byte)(value >> 56);
+    return 8;
+  }
+	  
+  public static int longTo4ByteArray(byte[] bytes, int offset, long value) {
+    bytes[offset + 3] = (byte)value;
+    bytes[offset + 2] = (byte)(value >> 8);
+    bytes[offset + 1] = (byte)(value >> 16);
+    bytes[offset + 0] = (byte)(value >> 24);	   
+    return 4;
+  }
+
+  public static int byteArrayToShort(byte[] bytes) {
+    return byteArrayToShort(bytes, 0);
+  }
+
+  public static int byteArrayToShort(byte[] bytes, int offset) {
+    return
+      (bytes[offset] & 0xff) << 8 | (bytes[offset + 1] & 0xff);
+  }
+
+  // The SSL patented 3-byte Value.
+  public static int byteArrayToMedium(byte[] bytes, int offset) {
+    return
+      (bytes[offset]     & 0xff) << 16 |
+      (bytes[offset + 1] & 0xff) << 8  |
+      (bytes[offset + 2] & 0xff);
+  }
+
+  public static int byteArrayToInt(byte[] bytes) {
+    return byteArrayToInt(bytes, 0);
+  }
+
+  public static int byteArrayToInt(byte[] bytes, int offset)  {
+    return
+      (bytes[offset]     & 0xff) << 24 |
+      (bytes[offset + 1] & 0xff) << 16 |
+      (bytes[offset + 2] & 0xff) << 8  |
+      (bytes[offset + 3] & 0xff);
+  }
+	  
+  public static int byteArrayToIntLittleEndian(byte[] bytes, int offset) {
+    return
+      (bytes[offset + 3] & 0xff) << 24 |
+      (bytes[offset + 2] & 0xff) << 16 |
+      (bytes[offset + 1] & 0xff) << 8  |
+      (bytes[offset]     & 0xff);
+  }
+
+  public static long byteArrayToLong(byte[] bytes) {
+    return byteArrayToLong(bytes, 0);
+  }
+
+  public static long byteArrayToLong(byte[] bytes, int offset) {
+    return
+      ((bytes[offset]     & 0xffL) << 56) |
+      ((bytes[offset + 1] & 0xffL) << 48) |
+      ((bytes[offset + 2] & 0xffL) << 40) |
+      ((bytes[offset + 3] & 0xffL) << 32) |
+      ((bytes[offset + 4] & 0xffL) << 24) |
+      ((bytes[offset + 5] & 0xffL) << 16) |
+      ((bytes[offset + 6] & 0xffL) << 8)  |
+      ((bytes[offset + 7] & 0xffL));
+  }
+}

src/org/thoughtcrime/securesms/util/Dialogs.java

@@ -0,0 +1,32 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+import android.app.AlertDialog;
+import android.content.Context;
+
+public class Dialogs {
+
+  public static void displayAlert(Context context, String title, String message, int icon) {
+    AlertDialog.Builder alertDialog = new AlertDialog.Builder(context);
+    alertDialog.setTitle(title);
+    alertDialog.setMessage(message);
+    alertDialog.setIcon(icon);
+    alertDialog.setPositiveButton("Ok", null);
+    alertDialog.show();
+  }
+}

src/org/thoughtcrime/securesms/util/EncryptedCharacterCalculator.java

@@ -0,0 +1,63 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+import org.thoughtcrime.securesms.sms.SmsTransportDetails;
+
+import android.util.Log;
+
+public class EncryptedCharacterCalculator extends CharacterCalculator {
+
+  private CharacterState calculateSingleRecordCharacters(int charactersSpent) {
+    int charactersRemaining = SmsTransportDetails.ENCRYPTED_SINGLE_MESSAGE_BODY_MAX_SIZE - charactersSpent;
+
+    return new CharacterState(1, charactersRemaining, SmsTransportDetails.ENCRYPTED_SINGLE_MESSAGE_BODY_MAX_SIZE);
+  }
+	
+  private CharacterState calculateMultiRecordCharacters(int charactersSpent) {
+    int charactersInFirstRecord = SmsTransportDetails.ENCRYPTED_SINGLE_MESSAGE_BODY_MAX_SIZE;
+    int spillover               = charactersSpent - charactersInFirstRecord;		
+    Log.w("EncryptedCharacterCalculator", "Spillover: " + spillover);
+    //		int maxMultiMessageSize     = SessionCipher.getMaxBodySizePerMultiMessage(charactersSpent);
+    //		Log.w("EncryptedCharacterCalculator", "Maxmultimessagesize: " + maxMultiMessageSize);
+    //		int spilloverMessagesSpent  = spillover / maxMultiMessageSize;
+    int spilloverMessagesSpent  = spillover / SmsTransportDetails.MULTI_MESSAGE_MAX_BYTES;
+    Log.w("EncryptedCharacterCalculator", "Spillover messaegs spent: " + spilloverMessagesSpent);
+
+    //		if ((spillover % maxMultiMessageSize) > 0)
+    if ((spillover % SmsTransportDetails.MULTI_MESSAGE_MAX_BYTES) > 0)
+      spilloverMessagesSpent++;
+
+    Log.w("EncryptedCharacterCalculator", "Spillover messaegs spent: " + spilloverMessagesSpent);
+
+    //		int charactersRemaining = (maxMultiMessageSize * spilloverMessagesSpent) - spillover;
+    int charactersRemaining = (SmsTransportDetails.MULTI_MESSAGE_MAX_BYTES * spilloverMessagesSpent) - spillover;
+    Log.w("EncryptedCharacterCalculator", "charactersRemaining: " + charactersRemaining);
+		
+    //		return new CharacterState(spilloverMessagesSpent+1, charactersRemaining, maxMultiMessageSize);		
+    return new CharacterState(spilloverMessagesSpent+1, charactersRemaining, SmsTransportDetails.MULTI_MESSAGE_MAX_BYTES);
+  }
+	
+  @Override
+  public CharacterState calculateCharacters(int charactersSpent) {
+    if (charactersSpent <= SmsTransportDetails.ENCRYPTED_SINGLE_MESSAGE_BODY_MAX_SIZE){
+      return calculateSingleRecordCharacters(charactersSpent);
+    } else {
+      return calculateMultiRecordCharacters(charactersSpent);
+    }			
+  }
+}

src/org/thoughtcrime/securesms/util/Eula.java

@@ -0,0 +1,151 @@
+package org.thoughtcrime.securesms.util;
+
+
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.net.Uri;
+
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.InputStreamReader;
+
+import org.thoughtcrime.securesms.R;
+import org.thoughtcrime.securesms.SecureSMS;
+
+/**
+ * Displays an EULA ("End User License Agreement") that the user has to accept before
+ * using the application. Your application should call {@link Eula#showEula(android.app.Activity)}
+ * in the onCreate() method of the first activity. If the user accepts the EULA, it will never
+ * be shown again. If the user refuses, {@link android.app.Activity#finish()} is invoked
+ * on your activity.
+ */
+public class Eula {
+    private static final String PREFERENCE_EULA_ACCEPTED = "eula.accepted";
+    private static final String PREFERENCES_EULA = "eula";
+    
+    private static final String PREFERENCE_DISCLAIMER_ACCEPTED = "disclaimer.accepted";
+
+    public static boolean seenDisclaimer(final Activity activity) {
+    	return activity.getSharedPreferences(PREFERENCES_EULA, Activity.MODE_PRIVATE).getBoolean(PREFERENCE_DISCLAIMER_ACCEPTED, false);
+    }
+    
+    /**
+     * Displays the EULA if necessary. This method should be called from the onCreate()
+     * method of your main Activity.
+     *
+     * @param activity The Activity to finish if the user rejects the EULA.
+     */    
+    public static void showEula(final SecureSMS activity) {
+        final SharedPreferences preferences = activity.getSharedPreferences(PREFERENCES_EULA,
+                Activity.MODE_PRIVATE);
+        if (!preferences.getBoolean(PREFERENCE_EULA_ACCEPTED, false)) {
+            final AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+            builder.setTitle("End User License Agreement");
+            builder.setCancelable(true);
+            builder.setPositiveButton("Accept", new DialogInterface.OnClickListener() {
+                public void onClick(DialogInterface dialog, int which) {
+                    accept(activity);
+                }
+            });
+            builder.setNegativeButton("Refuse", new DialogInterface.OnClickListener() {
+                public void onClick(DialogInterface dialog, int which) {
+                    refuse(activity);
+                }
+            });
+            builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
+                public void onCancel(DialogInterface dialog) {
+                    refuse(activity);
+                }
+            });
+            builder.setMessage(readFile(activity, R.raw.eula));
+            builder.create().show();
+        } else {
+        	activity.eulaComplete();
+        }
+    }
+
+    private static void acceptDisclaimer(SecureSMS activity) {
+    	activity.getSharedPreferences(PREFERENCES_EULA, Activity.MODE_PRIVATE).edit().putBoolean(PREFERENCE_DISCLAIMER_ACCEPTED, true).commit();
+    	activity.eulaComplete();
+    }
+    
+    private static void accept(SecureSMS activity) {
+        activity.getSharedPreferences(PREFERENCES_EULA, Activity.MODE_PRIVATE).edit().putBoolean(PREFERENCE_EULA_ACCEPTED, true).commit();
+        showDisclaimer(activity);
+    }
+
+    private static void refuse(Activity activity) {
+    	Intent intent = new Intent(Intent.ACTION_DELETE, Uri.parse("package:org.thoughtcrime.securesms"));
+    	activity.startActivity(intent);
+        activity.finish();
+    }
+
+    public static void showDisclaimer(final SecureSMS activity) {
+    	if (!seenDisclaimer(activity)) {
+	        final AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+	        builder.setMessage(readFile(activity, R.raw.disclaimer));
+	        builder.setCancelable(true);
+	        builder.setTitle("Please Note");
+	        builder.setPositiveButton("I understand", new DialogInterface.OnClickListener() {				
+				public void onClick(DialogInterface dialog, int which) {
+					acceptDisclaimer(activity);
+				}
+			});
+	        builder.create().show();
+    	} else {
+    		activity.eulaComplete();
+    	}
+    }
+
+    private static CharSequence readFile(Activity activity, int id) {
+        BufferedReader in = null;
+        try {
+            in = new BufferedReader(new InputStreamReader(
+                    activity.getResources().openRawResource(id)));
+            String line;
+            StringBuilder buffer = new StringBuilder();
+            while ((line = in.readLine()) != null) buffer.append(line).append('\n');
+            return buffer;
+        } catch (IOException e) {
+            return "";
+        } finally {
+            closeStream(in);
+        }
+    }
+
+    /**
+     * Closes the specified stream.
+     *
+     * @param stream The stream to close.
+     */
+    private static void closeStream(Closeable stream) {
+        if (stream != null) {
+            try {
+                stream.close();
+            } catch (IOException e) {
+                // Ignore
+            }
+        }
+    }
+}
+

src/org/thoughtcrime/securesms/util/Hex.java

@@ -0,0 +1,106 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+/**
+ * Utility for generating hex dumps.
+ */
+public class Hex {
+
+  private final static int HEX_DIGITS_START = 10;
+  private final static int ASCII_TEXT_START = HEX_DIGITS_START + (16*2 + (16/2));
+
+  final static String EOL = System.getProperty("line.separator");
+
+  private final static char[] HEX_DIGITS = {
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+  };
+
+  public static String toString(byte[] bytes) {
+    return toString(bytes, 0, bytes.length);
+  }
+
+  public static String toString(byte[] bytes, int offset, int length) {
+    StringBuffer buf = new StringBuffer();
+    for (int i = 0; i < length; i++) {
+      appendHexChar(buf, bytes[offset + i]);
+      buf.append(' ');
+    }
+    return buf.toString();
+  }
+
+  public static String dump(byte[] bytes) {
+    return dump(bytes, 0, bytes.length);
+  }
+  
+  public static String dump(byte[] bytes, int offset, int length) {
+    StringBuffer buf = new StringBuffer();
+    int lines = ((length - 1) / 16) + 1;
+    int lineOffset;
+    int lineLength;
+
+    for (int i = 0; i < lines; i++) {
+      lineOffset = (i * 16) + offset;
+      lineLength = Math.min(16, (length - (i * 16)));
+      appendDumpLine(buf, i, bytes, lineOffset, lineLength);
+      buf.append(EOL);
+    }
+    
+    return buf.toString();
+  }
+
+  private static void appendDumpLine(StringBuffer buf, int line, byte[] bytes, int lineOffset, int lineLength) {
+    buf.append(HEX_DIGITS[(line >> 28) & 0xf]);
+    buf.append(HEX_DIGITS[(line >> 24) & 0xf]);
+    buf.append(HEX_DIGITS[(line >> 20) & 0xf]);
+    buf.append(HEX_DIGITS[(line >> 16) & 0xf]);
+    buf.append(HEX_DIGITS[(line >> 12) & 0xf]);
+    buf.append(HEX_DIGITS[(line >>  8) & 0xf]);
+    buf.append(HEX_DIGITS[(line >>  4) & 0xf]);
+    buf.append(HEX_DIGITS[(line      ) & 0xf]);
+    buf.append(": ");
+
+    for (int i = 0; i < 16; i++) {
+      int idx = i + lineOffset;
+      if (i < lineLength) {
+        int b = bytes[idx];
+	appendHexChar(buf, b);
+      } else {
+      	buf.append("  ");
+      }
+      if ((i % 2) == 1) {
+      	buf.append(' ');
+      }
+    }
+
+    for (int i = 0; i < 16 && i < lineLength; i++) {
+      int idx = i + lineOffset;
+      int b = bytes[idx];
+      if (b >= 0x20 && b <= 0x7e) {
+        buf.append((char)b);
+      } else {
+        buf.append('.');
+      }
+    }
+  }
+
+  private static void appendHexChar(StringBuffer buf, int b) {
+    buf.append(HEX_DIGITS[(b >> 4) & 0xf]);
+    buf.append(HEX_DIGITS[b & 0xf]);
+  }
+
+}

src/org/thoughtcrime/securesms/util/InvalidMessageException.java

@@ -0,0 +1,40 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+public class InvalidMessageException extends Exception {
+
+  public InvalidMessageException() {
+    // TODO Auto-generated constructor stub
+  }
+
+  public InvalidMessageException(String detailMessage) {
+    super(detailMessage);
+    // TODO Auto-generated constructor stub
+  }
+
+  public InvalidMessageException(Throwable throwable) {
+    super(throwable);
+    // TODO Auto-generated constructor stub
+  }
+
+  public InvalidMessageException(String detailMessage, Throwable throwable) {
+    super(detailMessage, throwable);
+    // TODO Auto-generated constructor stub
+  }
+
+}

src/org/thoughtcrime/securesms/util/MemoryCleaner.java

@@ -0,0 +1,76 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+
+import javax.crypto.spec.SecretKeySpec;
+
+import org.thoughtcrime.securesms.crypto.MasterSecret;
+
+import android.util.Log;
+
+/**
+ * This is not straightforward in Java, but this class makes
+ * a best-effort attempt to clean up memory in immutable objects.
+ * 
+ * @author Moxie Marlinspike
+ */
+
+public class MemoryCleaner {
+
+  public static void clean(MasterSecret masterSecret) {
+    try {
+      SecretKeySpec cipherKey = masterSecret.getEncryptionKey();
+      SecretKeySpec macKey    = masterSecret.getMacKey();
+      
+      Field keyField = SecretKeySpec.class.getDeclaredField("key");
+      keyField.setAccessible(true);
+      
+      byte[] cipherKeyField = (byte[]) keyField.get(cipherKey);
+      byte[] macKeyField    = (byte[]) keyField.get(macKey);
+      
+      Arrays.fill(cipherKeyField, (byte)0x00);
+      Arrays.fill(macKeyField, (byte)0x00);
+      
+    } catch (NoSuchFieldException nsfe) {
+      Log.w("MemoryCleaner", nsfe);
+    } catch (IllegalArgumentException e) {
+      Log.w("MemoryCleaner", e);
+    } catch (IllegalAccessException e) {
+      Log.w("MemoryCleaner", e);
+    }
+  }
+  
+  public static void clean(String string) {
+    try {
+      Field charArrayField = String.class.getDeclaredField("value");
+      charArrayField.setAccessible(true);
+      
+      char[] internalBuffer = (char[])charArrayField.get(string);
+      
+      Arrays.fill(internalBuffer, 'A');
+    } catch (NoSuchFieldException nsfe) {
+      Log.w("MemoryCleaner", nsfe);
+    } catch (IllegalArgumentException e) {
+      Log.w("MemoryCleaner", e);
+    } catch (IllegalAccessException e) {
+      Log.w("MemoryCleaner", e);
+    }
+  }
+}

src/org/thoughtcrime/securesms/util/NumberUtil.java

@@ -0,0 +1,54 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import android.telephony.PhoneNumberUtils;
+
+public class NumberUtil {
+	
+  private static final String emailExpression = "^[\\w\\-]([\\.\\w])+[\\w]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";  
+  private static final Pattern emailPattern   = Pattern.compile(emailExpression, Pattern.CASE_INSENSITIVE);  
+	
+  public static boolean isValidEmail(String number) {
+    Matcher matcher = emailPattern.matcher(number);
+    return matcher.matches();
+  }
+	
+  public static boolean isValidSmsOrEmail(String number) {
+    return PhoneNumberUtils.isWellFormedSmsAddress(number) || isValidEmail(number);
+  }
+	
+  public static String filterNumber(String number) {
+    if (number == null) return null;
+		
+    int length            = number.length();
+    StringBuilder builder = new StringBuilder(length);
+
+    for (int i = 0; i < length; i++) {
+      char character = number.charAt(i);
+
+      if (Character.isDigit(character) || character == '+')
+	builder.append(character);
+    }
+        
+    return builder.toString();
+  }
+	
+}

src/org/thoughtcrime/securesms/util/RedPhoneCallTypes.java

@@ -0,0 +1,23 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+public interface RedPhoneCallTypes {
+  public static final int INCOMING = 1023;
+  public static final int OUTGOING = 1024;
+  public static final int MISSED   = 1025;	
+}

src/org/thoughtcrime/securesms/util/Util.java

@@ -0,0 +1,89 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+public class Util {
+
+  public static byte[] combine(byte[] one, byte[] two) {
+    byte[] combined = new byte[one.length + two.length];
+    System.arraycopy(one, 0, combined, 0, one.length);
+    System.arraycopy(two, 0, combined, one.length, two.length);
+
+    return combined;
+  }
+	
+  public static byte[] combine(byte[] one, byte[] two, byte[] three) {
+    byte[] combined = new byte[one.length + two.length + three.length];
+    System.arraycopy(one, 0, combined, 0, one.length);
+    System.arraycopy(two, 0, combined, one.length, two.length);
+    System.arraycopy(three, 0, combined, one.length + two.length, three.length);
+		
+    return combined;
+  }
+	
+  public static byte[] combine(byte[] one, byte[] two, byte[] three, byte[] four) {
+    byte[] combined = new byte[one.length + two.length + three.length + four.length];
+    System.arraycopy(one, 0, combined, 0, one.length);
+    System.arraycopy(two, 0, combined, one.length, two.length);
+    System.arraycopy(three, 0, combined, one.length + two.length, three.length);
+    System.arraycopy(four, 0, combined, one.length + two.length + three.length, four.length);
+		
+    return combined;
+		
+  }
+	
+  public static String[] splitString(String string, int maxLength) {
+    int count = string.length() / maxLength;
+		
+    if (string.length() % maxLength > 0)
+      count++;
+		
+    String[] splitString = new String[count];
+		
+    for (int i=0;i<count-1;i++)
+      splitString[i] = string.substring(i*maxLength, (i*maxLength) + maxLength);
+		
+    splitString[count-1] = string.substring((count-1) * maxLength);
+		
+    return splitString;
+  }
+	
+  //	public static Bitmap loadScaledBitmap(InputStream src, int targetWidth, int targetHeight) {
+  //		return BitmapFactory.decodeStream(src);
+  ////		BitmapFactory.Options options = new BitmapFactory.Options();
+  ////		options.inJustDecodeBounds    = true;
+  ////		BitmapFactory.decodeStream(src, null, options);
+  ////
+  ////		Log.w("Util", "Bitmap Origin Width: " + options.outWidth);
+  ////		Log.w("Util", "Bitmap Origin Height: " + options.outHeight);
+  ////		
+  ////		boolean scaleByHeight = 
+  ////			Math.abs(options.outHeight - targetHeight) >= 
+  ////			Math.abs(options.outWidth - targetWidth);
+  ////
+  ////		if (options.outHeight * options.outWidth >= targetWidth * targetHeight * 2) {
+  ////			double sampleSize = scaleByHeight ? (double)options.outHeight / (double)targetHeight : (double)options.outWidth / (double)targetWidth;
+  //////			options.inSampleSize = (int)Math.pow(2d, Math.floor(Math.log(sampleSize) / Math.log(2d)));
+  ////			Log.w("Util", "Sampling by: " + options.inSampleSize);
+  ////		}
+  ////
+  ////		 options.inJustDecodeBounds = false;
+  ////		 
+  ////		 return BitmapFactory.decodeStream(src, null, options);
+  //	}
+
+}

src/org/thoughtcrime/securesms/util/WorkerThread.java

@@ -0,0 +1,47 @@
+/** 
+ * Copyright (C) 2011 Whisper Systems
+ * 
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.util;
+
+import java.util.List;
+
+public class WorkerThread extends Thread {
+	
+  private final List<Runnable> workQueue;
+	
+  public WorkerThread(List<Runnable> workQueue, String name) {
+    super(name);
+    this.workQueue = workQueue;
+  }
+	
+  private Runnable getWork() {
+    synchronized (workQueue) {
+      try {
+	while (workQueue.isEmpty())
+	  workQueue.wait();
+				
+	return workQueue.remove(0);
+      } catch (InterruptedException ie) {
+	throw new AssertionError(ie);
+      }
+    }
+  }
+	
+  public void run() {
+    for (;;)
+      getWork().run();
+  }
+}