Split out Util functions.

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

@@ -11,7 +11,7 @@ import org.thoughtcrime.securesms.push.TextSecureCommunicationFactory;
 import org.thoughtcrime.securesms.recipients.Recipients;
 import org.whispersystems.textsecure.api.TextSecureAccountManager;
 import org.whispersystems.textsecure.push.ContactTokenDetails;
-import org.whispersystems.textsecure.util.InvalidNumberException;
+import org.whispersystems.textsecure.api.util.InvalidNumberException;
 
 import java.util.List;
 import java.util.Map;

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

@@ -17,7 +17,6 @@
 package org.thoughtcrime.securesms.util;
 
 
-import org.whispersystems.textsecure.util.Base64;
 
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
@@ -30,7 +29,7 @@ public class DirectoryUtil {
   public static String getDirectoryServerToken(String e164number) {
     try {
       MessageDigest digest = MessageDigest.getInstance("SHA1");
-      byte[]        token  = org.whispersystems.textsecure.util.Util.trim(digest.digest(e164number.getBytes()), 10);
+      byte[]        token  = Util.trim(digest.digest(e164number.getBytes()), 10);
       return Base64.encodeBytesWithoutPadding(token);
     } catch (NoSuchAlgorithmException e) {
       throw new AssertionError(e);

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

@@ -2,14 +2,9 @@ package org.thoughtcrime.securesms.util;
 
 import android.util.Log;
 
-import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
 
-import org.whispersystems.textsecure.util.Base64;
-import org.whispersystems.textsecure.util.Hex;
-
 import java.io.IOException;
-import java.util.LinkedList;
 import java.util.List;
 
 import static org.whispersystems.textsecure.push.PushMessageProtos.PushMessageContent.GroupContext;
@@ -46,7 +41,7 @@ public class GroupUtil {
       String       title       = context.getName();
 
       if (!members.isEmpty()) {
-        description += org.whispersystems.textsecure.util.Util.join(members, ", ") + " joined the group.";
+        description += Util.join(members, ", ") + " joined the group.";
       }
 
       if (title != null && !title.trim().isEmpty()) {

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

@@ -0,0 +1,138 @@
+/**
+ * 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.io.IOException;
+
+/**
+ * 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 toStringCondensed(byte[] bytes) {
+    StringBuffer buf = new StringBuffer();
+    for (int i=0;i<bytes.length;i++) {
+      appendHexChar(buf, bytes[i]);
+    }
+    return buf.toString();
+  }
+
+  public static byte[] fromStringCondensed(String encoded) throws IOException {
+    final char[] data = encoded.toCharArray();
+    final int    len  = data.length;
+
+    if ((len & 0x01) != 0) {
+      throw new IOException("Odd number of characters.");
+    }
+
+    final byte[] out = new byte[len >> 1];
+
+    // two characters form the hex value.
+    for (int i = 0, j = 0; j < len; i++) {
+      int f = Character.digit(data[j], 16) << 4;
+      j++;
+      f = f | Character.digit(data[j], 16);
+      j++;
+      out[i] = (byte) (f & 0xFF);
+    }
+
+    return out;
+  }
+
+  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/SaveAttachmentTask.java

@@ -63,7 +63,7 @@ public class SaveAttachmentTask extends ProgressDialogAsyncTask<SaveAttachmentTa
       InputStream inputStream   = DatabaseFactory.getEncryptingPartDatabase(context, masterSecret).getPartStream(ContentUris.parseId(attachment.uri));
       OutputStream outputStream = new FileOutputStream(mediaFile);
 
-      org.whispersystems.textsecure.util.Util.copy(inputStream, outputStream);
+      Util.copy(inputStream, outputStream);
 
       MediaScannerConnection.scanFile(context, new String[]{mediaFile.getAbsolutePath()},
                                       new String[]{attachment.contentType}, null);

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

@@ -19,21 +19,33 @@ package org.thoughtcrime.securesms.util;
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.pm.PackageManager;
+import android.graphics.Shader;
 import android.graphics.Typeface;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.provider.Telephony;
+import android.telephony.TelephonyManager;
 import android.text.Spannable;
 import android.text.SpannableString;
+import android.text.TextUtils;
 import android.text.style.StyleSpan;
-import android.util.Log;
+import android.widget.EditText;
 
-import org.whispersystems.textsecure.util.InvalidNumberException;
-import org.whispersystems.textsecure.util.PhoneNumberFormatter;
+import org.whispersystems.textsecure.api.util.PhoneNumberFormatter;
+import org.whispersystems.textsecure.api.util.InvalidNumberException;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
@@ -43,20 +55,18 @@ import ws.com.google.android.mms.pdu.EncodedStringValue;
 
 public class Util {
 
-  public static String[] splitString(String string, int maxLength) {
-    int count = string.length() / maxLength;
+  public static String join(Collection<String> list, String delimiter) {
+    StringBuilder result = new StringBuilder();
+    int i=0;
 
-    if (string.length() % maxLength > 0)
-      count++;
+    for (String item : list) {
+      result.append(item);
 
-    String[] splitString = new String[count];
+      if (++i < list.size())
+        result.append(delimiter);
+    }
 
-    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;
+    return result.toString();
   }
 
   public static ExecutorService newSingleThreadedLifoExecutor() {
@@ -77,6 +87,10 @@ public class Util {
     return value == null || value.length == 0;
   }
 
+  public static boolean isEmpty(EditText value) {
+    return value == null || value.getText() == null || TextUtils.isEmpty(value.getText().toString());
+  }
+
   public static CharSequence getBoldedString(String value) {
     SpannableString spanned = new SpannableString(value);
     spanned.setSpan(new StyleSpan(Typeface.BOLD), 0,
@@ -86,15 +100,6 @@ public class Util {
     return spanned;
   }
 
-  public static CharSequence getItalicizedString(String value) {
-    SpannableString spanned = new SpannableString(value);
-    spanned.setSpan(new StyleSpan(Typeface.ITALIC), 0,
-                    spanned.length(),
-                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
-
-    return spanned;
-  }
-
   public static String toIsoString(byte[] bytes) {
     try {
       return new String(bytes, CharacterSets.MIMENAME_ISO_8859_1);
@@ -141,18 +146,91 @@ public class Util {
     else                                  return canonicalizeNumber(context, number);
   }
 
-  public static byte[] readFully(InputStream in) throws IOException {
-    ByteArrayOutputStream baos   = new ByteArrayOutputStream();
-    byte[]                buffer = new byte[4069];
-
+  public static String readFully(InputStream in) throws IOException {
+    ByteArrayOutputStream bout = new ByteArrayOutputStream();
+    byte[] buffer              = new byte[4096];
     int read;
 
     while ((read = in.read(buffer)) != -1) {
-      baos.write(buffer, 0, read);
+      bout.write(buffer, 0, read);
     }
 
     in.close();
-    return baos.toByteArray();
+
+    return new String(bout.toByteArray());
+  }
+
+  public static void copy(InputStream in, OutputStream out) throws IOException {
+    byte[] buffer = new byte[4096];
+    int read;
+
+    while ((read = in.read(buffer)) != -1) {
+      out.write(buffer, 0, read);
+    }
+
+    in.close();
+    out.close();
+  }
+
+  public static String getDeviceE164Number(Context context) {
+    String localNumber = ((TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE))
+        .getLine1Number();
+
+    if (!TextUtils.isEmpty(localNumber) && !localNumber.startsWith("+"))
+    {
+      if (localNumber.length() == 10) localNumber = "+1" + localNumber;
+      else                            localNumber = "+"  + localNumber;
+
+      return localNumber;
+    }
+
+    return null;
+  }
+
+  public static List<String> split(String source, String delimiter) {
+    List<String> results = new LinkedList<>();
+
+    if (TextUtils.isEmpty(source)) {
+      return results;
+    }
+
+    String[] elements = source.split(delimiter);
+    Collections.addAll(results, elements);
+
+    return results;
+  }
+
+  public static byte[][] split(byte[] input, int firstLength, int secondLength) {
+    byte[][] parts = new byte[2][];
+
+    parts[0] = new byte[firstLength];
+    System.arraycopy(input, 0, parts[0], 0, firstLength);
+
+    parts[1] = new byte[secondLength];
+    System.arraycopy(input, firstLength, parts[1], 0, secondLength);
+
+    return parts;
+  }
+
+  public static byte[] combine(byte[]... elements) {
+    try {
+      ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+      for (byte[] element : elements) {
+        baos.write(element);
+      }
+
+      return baos.toByteArray();
+    } catch (IOException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  public static byte[] trim(byte[] input, int length) {
+    byte[] result = new byte[length];
+    System.arraycopy(input, 0, result, 0, result.length);
+
+    return result;
   }
 
   @SuppressLint("NewApi")
@@ -168,4 +246,40 @@ public class Util {
       throw new AssertionError(e);
     }
   }
+
+  public static String getSecret(int size) {
+    byte[] secret = getSecretBytes(size);
+    return Base64.encodeBytes(secret);
+  }
+
+  public static byte[] getSecretBytes(int size) {
+    byte[] secret = new byte[size];
+    getSecureRandom().nextBytes(secret);
+    return secret;
+  }
+
+  public static SecureRandom getSecureRandom() {
+    try {
+      return SecureRandom.getInstance("SHA1PRNG");
+    } catch (NoSuchAlgorithmException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+
+  /*
+   * source: http://stackoverflow.com/a/9500334
+   */
+  public static void fixBackgroundRepeat(Drawable bg) {
+    if (bg != null) {
+      if (bg instanceof BitmapDrawable) {
+        BitmapDrawable bmp = (BitmapDrawable) bg;
+        bmp.mutate();
+        bmp.setTileModeXY(Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);
+      }
+    }
+  }
+
+
+
 }