diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 53f1c12266..d415492c83 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -30,6 +30,13 @@
+
+
+
+
+
+
-
+
+
+
+
+
+
@@ -158,6 +174,14 @@
+
+
+
+
+
+
+
+
diff --git a/assets/whisper.store b/assets/whisper.store
new file mode 100644
index 0000000000..664ca9563c
Binary files /dev/null and b/assets/whisper.store differ
diff --git a/libs/gcm.jar b/libs/gcm.jar
new file mode 100644
index 0000000000..ac109a830e
Binary files /dev/null and b/libs/gcm.jar differ
diff --git a/libs/libphonenumber-5.3.jar b/libs/libphonenumber-5.3.jar
new file mode 100644
index 0000000000..7be725cc63
Binary files /dev/null and b/libs/libphonenumber-5.3.jar differ
diff --git a/libs/thoughtcrimegson-2.1.jar b/libs/thoughtcrimegson-2.1.jar
new file mode 100644
index 0000000000..8406d51d03
Binary files /dev/null and b/libs/thoughtcrimegson-2.1.jar differ
diff --git a/res/drawable-hdpi/alert.png b/res/drawable-hdpi/alert.png
new file mode 100644
index 0000000000..05012c9741
Binary files /dev/null and b/res/drawable-hdpi/alert.png differ
diff --git a/res/drawable-hdpi/check.png b/res/drawable-hdpi/check.png
new file mode 100644
index 0000000000..58bf972171
Binary files /dev/null and b/res/drawable-hdpi/check.png differ
diff --git a/res/drawable-hdpi/ic_menu_search_holo_light.png b/res/drawable-hdpi/ic_menu_search_holo_light.png
new file mode 100644
index 0000000000..1cb61faf49
Binary files /dev/null and b/res/drawable-hdpi/ic_menu_search_holo_light.png differ
diff --git a/res/drawable-mdpi/alert.png b/res/drawable-mdpi/alert.png
new file mode 100644
index 0000000000..dd647adda8
Binary files /dev/null and b/res/drawable-mdpi/alert.png differ
diff --git a/res/drawable-mdpi/check.png b/res/drawable-mdpi/check.png
new file mode 100644
index 0000000000..cf5fab3adf
Binary files /dev/null and b/res/drawable-mdpi/check.png differ
diff --git a/res/drawable-mdpi/ic_menu_search_holo_light.png b/res/drawable-mdpi/ic_menu_search_holo_light.png
new file mode 100644
index 0000000000..2369d03f33
Binary files /dev/null and b/res/drawable-mdpi/ic_menu_search_holo_light.png differ
diff --git a/res/drawable-xhdpi/alert.png b/res/drawable-xhdpi/alert.png
new file mode 100644
index 0000000000..7e8f1ee27d
Binary files /dev/null and b/res/drawable-xhdpi/alert.png differ
diff --git a/res/drawable-xhdpi/check.png b/res/drawable-xhdpi/check.png
new file mode 100644
index 0000000000..b8915716e0
Binary files /dev/null and b/res/drawable-xhdpi/check.png differ
diff --git a/res/drawable-xhdpi/ic_menu_search_holo_light.png b/res/drawable-xhdpi/ic_menu_search_holo_light.png
new file mode 100644
index 0000000000..578cb24eb0
Binary files /dev/null and b/res/drawable-xhdpi/ic_menu_search_holo_light.png differ
diff --git a/res/drawable/background_pane.9.png b/res/drawable/background_pane.9.png
new file mode 100644
index 0000000000..218ebaada9
Binary files /dev/null and b/res/drawable/background_pane.9.png differ
diff --git a/res/layout/country_list_item.xml b/res/layout/country_list_item.xml
new file mode 100644
index 0000000000..d4ed941c1d
--- /dev/null
+++ b/res/layout/country_list_item.xml
@@ -0,0 +1,28 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/res/layout/country_selection.xml b/res/layout/country_selection.xml
new file mode 100644
index 0000000000..212333686d
--- /dev/null
+++ b/res/layout/country_selection.xml
@@ -0,0 +1,10 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/res/layout/country_selection_fragment.xml b/res/layout/country_selection_fragment.xml
new file mode 100644
index 0000000000..998d36ed99
--- /dev/null
+++ b/res/layout/country_selection_fragment.xml
@@ -0,0 +1,29 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/res/layout/registration_activity.xml b/res/layout/registration_activity.xml
new file mode 100644
index 0000000000..466b710842
--- /dev/null
+++ b/res/layout/registration_activity.xml
@@ -0,0 +1,83 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/res/layout/registration_progress_activity.xml b/res/layout/registration_progress_activity.xml
new file mode 100644
index 0000000000..3cf4797711
--- /dev/null
+++ b/res/layout/registration_progress_activity.xml
@@ -0,0 +1,517 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/org/thoughtcrime/securesms/ApplicationPreferencesActivity.java b/src/org/thoughtcrime/securesms/ApplicationPreferencesActivity.java
index 2b224043d3..9e8d25f0f4 100644
--- a/src/org/thoughtcrime/securesms/ApplicationPreferencesActivity.java
+++ b/src/org/thoughtcrime/securesms/ApplicationPreferencesActivity.java
@@ -90,6 +90,11 @@ public class ApplicationPreferencesActivity extends PassphraseRequiredSherlockPr
public static final String THREAD_TRIM_LENGTH = "pref_trim_length";
public static final String THREAD_TRIM_NOW = "pref_trim_now";
+ public static final String LOCAL_NUMBER_PREF = "pref_local_number";
+ public static final String VERIFYING_STATE_PREF = "pref_verifying";
+ public static final String REGISTERED_GCM_PREF = "pref_gcm_registered";
+ public static final String GCM_PASSWORD_PREF = "pref_gcm_password";
+
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
diff --git a/src/org/thoughtcrime/securesms/CountrySelectionActivity.java b/src/org/thoughtcrime/securesms/CountrySelectionActivity.java
new file mode 100644
index 0000000000..30b945e3a0
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/CountrySelectionActivity.java
@@ -0,0 +1,29 @@
+package org.thoughtcrime.securesms;
+
+
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.actionbarsherlock.app.SherlockFragmentActivity;
+
+public class CountrySelectionActivity extends SherlockFragmentActivity
+ implements CountrySelectionFragment.CountrySelectedListener
+
+{
+
+ @Override
+ public void onCreate(Bundle bundle) {
+ super.onCreate(bundle);
+ this.setContentView(R.layout.country_selection);
+ }
+
+ @Override
+ public void countrySelected(String countryName, int countryCode) {
+ Intent result = getIntent();
+ result.putExtra("country_name", countryName);
+ result.putExtra("country_code", countryCode);
+
+ this.setResult(RESULT_OK, result);
+ this.finish();
+ }
+}
diff --git a/src/org/thoughtcrime/securesms/CountrySelectionFragment.java b/src/org/thoughtcrime/securesms/CountrySelectionFragment.java
new file mode 100644
index 0000000000..87d2441de5
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/CountrySelectionFragment.java
@@ -0,0 +1,100 @@
+package org.thoughtcrime.securesms;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.support.v4.app.LoaderManager;
+import android.support.v4.content.Loader;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.SimpleAdapter;
+
+import com.actionbarsherlock.app.SherlockListFragment;
+
+import org.thoughtcrime.securesms.database.loaders.CountryListLoader;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+public class CountrySelectionFragment extends SherlockListFragment implements LoaderManager.LoaderCallbacks>> {
+
+ private EditText countryFilter;
+ private CountrySelectedListener listener;
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle bundle) {
+ return inflater.inflate(R.layout.country_selection_fragment, container, false);
+ }
+
+ @Override
+ public void onActivityCreated(Bundle bundle) {
+ super.onActivityCreated(bundle);
+ this.countryFilter = (EditText)getView().findViewById(R.id.country_search);
+ this.countryFilter.addTextChangedListener(new FilterWatcher());
+ getLoaderManager().initLoader(0, null, this).forceLoad();
+ }
+
+ @Override
+ public void onAttach(Activity activity) {
+ super.onAttach(activity);
+ this.listener = (CountrySelectedListener)activity;
+ }
+
+ @Override
+ public void onListItemClick(ListView listView, View view, int position, long id) {
+ Map item = (Map)this.getListAdapter().getItem(position);
+ if (this.listener != null) {
+ this.listener.countrySelected(item.get("country_name"),
+ Integer.parseInt(item.get("country_code").substring(1)));
+ }
+ }
+
+ @Override
+ public Loader>> onCreateLoader(int arg0, Bundle arg1) {
+ return new CountryListLoader(getActivity());
+ }
+
+ @Override
+ public void onLoadFinished(Loader>> loader,
+ ArrayList> results)
+ {
+ String[] from = {"country_name", "country_code"};
+ int[] to = {R.id.country_name, R.id.country_code};
+ this.setListAdapter(new SimpleAdapter(getActivity(), results, R.layout.country_list_item, from, to));
+
+ if (this.countryFilter != null && this.countryFilter.getText().length() != 0) {
+ ((SimpleAdapter)getListAdapter()).getFilter().filter(this.countryFilter.getText().toString());
+ }
+ }
+
+ @Override
+ public void onLoaderReset(Loader>> arg0) {
+ this.setListAdapter(null);
+ }
+
+ public interface CountrySelectedListener {
+ public void countrySelected(String countryName, int countryCode);
+ }
+
+ private class FilterWatcher implements TextWatcher {
+
+ @Override
+ public void afterTextChanged(Editable s) {
+ if (getListAdapter() != null) {
+ ((SimpleAdapter)getListAdapter()).getFilter().filter(s.toString());
+ }
+ }
+
+ @Override
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+ }
+
+ @Override
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ }
+ }
+}
diff --git a/src/org/thoughtcrime/securesms/RegistrationActivity.java b/src/org/thoughtcrime/securesms/RegistrationActivity.java
new file mode 100644
index 0000000000..da22ef45c4
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/RegistrationActivity.java
@@ -0,0 +1,257 @@
+package org.thoughtcrime.securesms;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.telephony.TelephonyManager;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.Spinner;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.actionbarsherlock.app.ActionBar;
+import com.actionbarsherlock.app.SherlockActivity;
+import com.google.android.gcm.GCMRegistrar;
+import com.google.i18n.phonenumbers.AsYouTypeFormatter;
+import com.google.i18n.phonenumbers.NumberParseException;
+import com.google.i18n.phonenumbers.PhoneNumberUtil;
+import com.google.i18n.phonenumbers.Phonenumber;
+import org.thoughtcrime.securesms.util.PhoneNumberFormatter;
+import org.thoughtcrime.securesms.util.Util;
+
+/**
+ * The create account activity. Kicks off an account creation event, then waits
+ * the server to respond with a challenge via SMS, receives the challenge, and
+ * verifies it with the server.
+ *
+ * @author Moxie Marlinspike
+ *
+ */
+
+public class RegistrationActivity extends SherlockActivity {
+
+ private static final int PICK_COUNTRY = 1;
+
+ private AsYouTypeFormatter countryFormatter;
+ private ArrayAdapter countrySpinnerAdapter;
+ private Spinner countrySpinner;
+ private TextView countryCode;
+ private TextView number;
+ private Button createButton;
+
+
+ @Override
+ public void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+ setContentView(R.layout.registration_activity);
+
+ ActionBar actionBar = this.getSupportActionBar();
+ actionBar.setTitle("Connect With TextSecure");
+
+ initializeResources();
+ initializeNumber();
+ }
+
+ @Override
+ protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (requestCode == PICK_COUNTRY && resultCode == RESULT_OK && data != null) {
+ this.countryCode.setText(data.getIntExtra("country_code", 1)+"");
+ setCountryDisplay(data.getStringExtra("country_name"));
+ setCountryFormatter(data.getIntExtra("country_code", 1));
+ }
+ }
+
+ private void initializeResources() {
+ this.countrySpinner = (Spinner)findViewById(R.id.country_spinner);
+ this.countryCode = (TextView)findViewById(R.id.country_code);
+ this.number = (TextView)findViewById(R.id.number);
+ this.createButton = (Button)findViewById(R.id.registerButton);
+
+ this.countrySpinnerAdapter = new ArrayAdapter(this, android.R.layout.simple_spinner_item);
+ this.countrySpinnerAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+ setCountryDisplay("Select Your Country");
+
+ this.countrySpinner.setAdapter(this.countrySpinnerAdapter);
+ this.countrySpinner.setOnTouchListener(new View.OnTouchListener() {
+ @Override
+ public boolean onTouch(View v, MotionEvent event) {
+ if (event.getAction() == MotionEvent.ACTION_UP) {
+ Intent intent = new Intent(RegistrationActivity.this, CountrySelectionActivity.class);
+ startActivityForResult(intent, PICK_COUNTRY);
+ }
+ return true;
+ }
+ });
+
+ this.countryCode.addTextChangedListener(new CountryCodeChangedListener());
+ this.number.addTextChangedListener(new NumberChangedListener());
+ this.createButton.setOnClickListener(new CreateButtonListener());
+ }
+
+
+ private void initializeNumber() {
+ String localNumber = ((TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE))
+ .getLine1Number();
+
+ if (!Util.isEmpty(localNumber) && !localNumber.startsWith("+")) {
+ if (localNumber.length() == 10) localNumber = "+1" + localNumber;
+ else localNumber = "+" + localNumber;
+ }
+
+ try {
+ if (!Util.isEmpty(localNumber)) {
+ PhoneNumberUtil numberUtil = PhoneNumberUtil.getInstance();
+ Phonenumber.PhoneNumber localNumberObject = numberUtil.parse(localNumber, null);
+
+ if (localNumberObject != null) {
+ this.countryCode.setText(localNumberObject.getCountryCode()+"");
+ this.number.setText(localNumberObject.getNationalNumber()+"");
+ }
+ }
+ } catch (NumberParseException npe) {
+ Log.w("CreateAccountActivity", npe);
+ }
+ }
+
+ private void setCountryDisplay(String value) {
+ this.countrySpinnerAdapter.clear();
+ this.countrySpinnerAdapter.add(value);
+ }
+
+ private void setCountryFormatter(int countryCode) {
+ PhoneNumberUtil util = PhoneNumberUtil.getInstance();
+ String regionCode = util.getRegionCodeForCountryCode(countryCode);
+
+ if (regionCode == null) {
+ this.countryFormatter = null;
+ } else {
+ this.countryFormatter = util.getAsYouTypeFormatter(regionCode);
+ }
+ }
+
+ private String getConfiguredE164Number() {
+ return PhoneNumberFormatter.formatE164(countryCode.getText().toString(),
+ number.getText().toString());
+ }
+
+ private class CreateButtonListener implements View.OnClickListener {
+ @Override
+ public void onClick(View v) {
+ final RegistrationActivity self = RegistrationActivity.this;
+
+ if (Util.isEmpty(countryCode.getText())) {
+ Toast.makeText(self, "You must specify your country code",
+ Toast.LENGTH_LONG).show();
+ return;
+ }
+
+ if (Util.isEmpty(number.getText())) {
+ Toast.makeText(self, "You must specify your phone number",
+ Toast.LENGTH_LONG).show();
+ return;
+ }
+
+ final String e164number = getConfiguredE164Number();
+
+ if (!PhoneNumberFormatter.isValidNumber(e164number)) {
+ Util.showAlertDialog(self,
+ "Invalid number",
+ String.format("The number you specified (%s) is invalid.", e164number));
+ return;
+ }
+
+ try {
+ GCMRegistrar.checkDevice(self);
+ } catch (UnsupportedOperationException uoe) {
+ Util.showAlertDialog(self, "Unsupported", "Sorry, this device is not supported for data messaging. Devices running versions of Android older than 4.0 must have a registered Google Account. Devices running Android 4.0 or newer do not require a Google Account, but must have the Play Store app installed.");
+ return;
+ }
+
+ AlertDialog.Builder dialog = new AlertDialog.Builder(self);
+ dialog.setMessage(String.format("We will now verify that the following number is associated with this device:\n\n%s\n\nIs this number correct, or would you like to edit it before continuing?",
+ PhoneNumberFormatter.getInternationalFormatFromE164(e164number)));
+ dialog.setPositiveButton("Continue",
+ new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ Intent intent = new Intent(self, RegistrationProgressActivity.class);
+ intent.putExtra("e164number", e164number);
+ startActivity(intent);
+ finish();
+ }
+ });
+ dialog.setNegativeButton("Edit", null);
+ dialog.show();
+ }
+ }
+
+ private class CountryCodeChangedListener implements TextWatcher {
+ @Override
+ public void afterTextChanged(Editable s) {
+ if (Util.isEmpty(s)) {
+ setCountryDisplay("Select your country");
+ countryFormatter = null;
+ return;
+ }
+
+ int countryCode = Integer.parseInt(s.toString());
+ String regionCode = PhoneNumberUtil.getInstance().getRegionCodeForCountryCode(countryCode);
+ setCountryFormatter(countryCode);
+ setCountryDisplay(PhoneNumberFormatter.getRegionDisplayName(regionCode));
+
+ if (!Util.isEmpty(regionCode) && !regionCode.equals("ZZ")) {
+ number.requestFocus();
+ }
+ }
+
+ @Override
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+ }
+
+ @Override
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ }
+ }
+
+ private class NumberChangedListener implements TextWatcher {
+
+ @Override
+ public void afterTextChanged(Editable s) {
+ if (countryFormatter == null)
+ return;
+
+ if (Util.isEmpty(s))
+ return;
+
+ countryFormatter.clear();
+
+ String number = s.toString().replaceAll("[^\\d.]", "");
+ String formattedNumber = null;
+
+ for (int i=0;i>> {
+
+ public CountryListLoader(Context context) {
+ super(context);
+ }
+
+ @Override
+ public ArrayList> loadInBackground() {
+ Set regions = PhoneNumberUtil.getInstance().getSupportedRegions();
+ ArrayList> results = new ArrayList>(regions.size());
+
+ for (String region : regions) {
+ Map data = new HashMap(2);
+ data.put("country_name", PhoneNumberFormatter.getRegionDisplayName(region));
+ data.put("country_code", "+" +PhoneNumberUtil.getInstance().getCountryCodeForRegion(region));
+ results.add(data);
+ }
+
+ Collections.sort(results, new RegionComparator());
+
+ return results;
+ }
+
+ private class RegionComparator implements Comparator> {
+ @Override
+ public int compare(Map lhs, Map rhs) {
+ return lhs.get("country_name").compareTo(rhs.get("country_name"));
+ }
+ }
+}
diff --git a/src/org/thoughtcrime/securesms/gcm/GcmBroadcastReceiver.java b/src/org/thoughtcrime/securesms/gcm/GcmBroadcastReceiver.java
new file mode 100644
index 0000000000..2602b1d223
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/gcm/GcmBroadcastReceiver.java
@@ -0,0 +1,12 @@
+package org.thoughtcrime.securesms.gcm;
+
+import android.content.Context;
+
+public class GcmBroadcastReceiver extends com.google.android.gcm.GCMBroadcastReceiver {
+
+ @Override
+ protected String getGCMIntentServiceClassName(Context context) {
+ return "org.thoughtcrime.securesms.gcm.GcmIntentService";
+ }
+
+}
\ No newline at end of file
diff --git a/src/org/thoughtcrime/securesms/gcm/GcmIntentService.java b/src/org/thoughtcrime/securesms/gcm/GcmIntentService.java
new file mode 100644
index 0000000000..0cf01e64f9
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/gcm/GcmIntentService.java
@@ -0,0 +1,45 @@
+package org.thoughtcrime.securesms.gcm;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+
+import com.google.android.gcm.GCMBaseIntentService;
+import org.thoughtcrime.securesms.ApplicationPreferencesActivity;
+import org.thoughtcrime.securesms.service.RegistrationService;
+
+public class GcmIntentService extends GCMBaseIntentService {
+
+ public static final String GCM_SENDER_ID = "312334754206";
+
+ @Override
+ protected void onRegistered(Context context, String registrationId) {
+ SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
+ if (!preferences.getBoolean(ApplicationPreferencesActivity.REGISTERED_GCM_PREF, false)) {
+ Intent intent = new Intent(RegistrationService.GCM_REGISTRATION_EVENT);
+ intent.putExtra(RegistrationService.GCM_REGISTRATION_ID, registrationId);
+ sendBroadcast(intent);
+ } else {
+//
+// // Talk to the server directly.
+//
+ }
+ }
+
+ @Override
+ protected void onMessage(Context context, Intent intent) {
+ //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ @Override
+ protected void onError(Context context, String s) {
+ //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+
+ @Override
+ protected void onUnregistered(Context context, String s) {
+ //To change body of implemented methods use File | Settings | File Templates.
+ }
+}
diff --git a/src/org/thoughtcrime/securesms/gcm/GcmRegistrationTimeoutException.java b/src/org/thoughtcrime/securesms/gcm/GcmRegistrationTimeoutException.java
new file mode 100644
index 0000000000..7b2e895aad
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/gcm/GcmRegistrationTimeoutException.java
@@ -0,0 +1,18 @@
+package org.thoughtcrime.securesms.gcm;
+
+public class GcmRegistrationTimeoutException extends Exception {
+ public GcmRegistrationTimeoutException() {
+ }
+
+ public GcmRegistrationTimeoutException(String detailMessage) {
+ super(detailMessage);
+ }
+
+ public GcmRegistrationTimeoutException(String detailMessage, Throwable throwable) {
+ super(detailMessage, throwable);
+ }
+
+ public GcmRegistrationTimeoutException(Throwable throwable) {
+ super(throwable);
+ }
+}
diff --git a/src/org/thoughtcrime/securesms/gcm/GcmSender.java b/src/org/thoughtcrime/securesms/gcm/GcmSender.java
new file mode 100644
index 0000000000..0bf37ea063
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/gcm/GcmSender.java
@@ -0,0 +1,20 @@
+package org.thoughtcrime.securesms.gcm;
+
+import android.app.PendingIntent;
+
+public class GcmSender {
+
+ private static final GcmSender instance = new GcmSender();
+
+ public static GcmSender getDefault() {
+ return instance;
+ }
+
+ public void sendTextMessage(String recipient, String text,
+ PendingIntent sentIntent,
+ PendingIntent deliveredIntent)
+ {
+
+ }
+
+}
diff --git a/src/org/thoughtcrime/securesms/gcm/RegistrationSocket.java b/src/org/thoughtcrime/securesms/gcm/RegistrationSocket.java
new file mode 100644
index 0000000000..6235abe999
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/gcm/RegistrationSocket.java
@@ -0,0 +1,154 @@
+package org.thoughtcrime.securesms.gcm;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.util.Base64;
+
+import com.google.thoughtcrimegson.Gson;
+import org.thoughtcrime.securesms.util.Util;
+
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManagerFactory;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.CertificateException;
+
+public class RegistrationSocket {
+
+ private static final String CREATE_ACCOUNT_PATH = "/v1/accounts/%s";
+ private static final String VERIFY_ACCOUNT_PATH = "/v1/accounts/%s";
+ private static final String REGISTER_GCM_PATH = "/v1/accounts/gcm/%s";
+
+ private final String localNumber;
+ private final String password;
+ private final TrustManagerFactory trustManagerFactory;
+
+ public RegistrationSocket(Context context, String localNumber, String password) {
+ this.localNumber = localNumber;
+ this.password = password;
+ this.trustManagerFactory = initializeTrustManagerFactory(context);
+ }
+
+ public void createAccount() throws IOException {
+ makeRequest(String.format(CREATE_ACCOUNT_PATH, localNumber), "POST", null);
+ }
+
+ public void verifyAccount(String verificationCode, String password)
+ throws IOException
+ {
+ Verification verification = new Verification(verificationCode, password);
+ makeRequest(String.format(VERIFY_ACCOUNT_PATH, localNumber), "PUT", new Gson().toJson(verification));
+ }
+
+ public void registerGcmId(String gcmRegistrationId) throws IOException {
+ GcmRegistrationId registration = new GcmRegistrationId(gcmRegistrationId);
+ makeRequest(String.format(REGISTER_GCM_PATH, localNumber), "PUT", new Gson().toJson(registration));
+ }
+
+ private TrustManagerFactory initializeTrustManagerFactory(Context context) {
+ try {
+ AssetManager assetManager = context.getAssets();
+ InputStream keyStoreInputStream = assetManager.open("whisper.store");
+ KeyStore trustStore = KeyStore.getInstance("BKS");
+
+ trustStore.load(keyStoreInputStream, "whisper".toCharArray());
+
+ TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("X509");
+ trustManagerFactory.init(trustStore);
+
+ return trustManagerFactory;
+ } catch (KeyStoreException kse) {
+ throw new AssertionError(kse);
+ } catch (CertificateException e) {
+ throw new AssertionError(e);
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ } catch (IOException ioe) {
+ throw new AssertionError(ioe);
+ }
+ }
+
+ private String makeRequest(String urlFragment, String method, String body) throws IOException {
+ try {
+ SSLContext context = SSLContext.getInstance("TLS");
+ context.init(null, trustManagerFactory.getTrustManagers(), null);
+
+ URL url = new URL(String.format("https://gcm.textsecure.whispersystems.org/%s", urlFragment));
+ HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
+ connection.setSSLSocketFactory(context.getSocketFactory());
+ connection.setRequestMethod(method);
+ connection.setRequestProperty("Content-Type", "application/json");
+
+ if (password != null) {
+ connection.setRequestProperty("Authorization", getAuthorizationHeader());
+ }
+
+ if (body != null) {
+ connection.setDoOutput(true);
+ }
+
+ connection.connect();
+
+ if (body != null) {
+ OutputStream out = connection.getOutputStream();
+ out.write(body.getBytes());
+ out.close();
+ }
+
+ if (connection.getResponseCode() != 200) {
+ throw new IOException("Bad response: " + connection.getResponseCode());
+ }
+
+ return Util.readFully(connection.getInputStream());
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ } catch (KeyManagementException e) {
+ throw new AssertionError(e);
+ } catch (MalformedURLException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ private String getAuthorizationHeader() {
+ try {
+ return "Basic " + new String(Base64.encode((localNumber + ":" + password).getBytes("UTF-8"), Base64.NO_WRAP));
+ } catch (UnsupportedEncodingException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ private class Verification {
+
+ private String verificationCode;
+ private String authenticationToken;
+
+ public Verification() {}
+
+ public Verification(String verificationCode,
+ String authenticationToken)
+ {
+ this.verificationCode = verificationCode;
+ this.authenticationToken = authenticationToken;
+ }
+ }
+
+ private class GcmRegistrationId {
+ private String gcmRegistrationId;
+
+ public GcmRegistrationId() {}
+
+ public GcmRegistrationId(String gcmRegistrationId) {
+ this.gcmRegistrationId = gcmRegistrationId;
+ }
+ }
+
+}
diff --git a/src/org/thoughtcrime/securesms/service/AccountVerificationTimeoutException.java b/src/org/thoughtcrime/securesms/service/AccountVerificationTimeoutException.java
new file mode 100644
index 0000000000..4a38a3c7b7
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/service/AccountVerificationTimeoutException.java
@@ -0,0 +1,18 @@
+package org.thoughtcrime.securesms.service;
+
+public class AccountVerificationTimeoutException extends Exception {
+ public AccountVerificationTimeoutException() {
+ }
+
+ public AccountVerificationTimeoutException(String detailMessage) {
+ super(detailMessage);
+ }
+
+ public AccountVerificationTimeoutException(String detailMessage, Throwable throwable) {
+ super(detailMessage, throwable);
+ }
+
+ public AccountVerificationTimeoutException(Throwable throwable) {
+ super(throwable);
+ }
+}
diff --git a/src/org/thoughtcrime/securesms/service/RegistrationService.java b/src/org/thoughtcrime/securesms/service/RegistrationService.java
new file mode 100644
index 0000000000..8e463ba52f
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/service/RegistrationService.java
@@ -0,0 +1,330 @@
+package org.thoughtcrime.securesms.service;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.os.Binder;
+import android.os.Handler;
+import android.os.IBinder;
+import android.preference.PreferenceManager;
+import android.util.Log;
+
+import com.google.android.gcm.GCMRegistrar;
+import org.thoughtcrime.securesms.ApplicationPreferencesActivity;
+import org.thoughtcrime.securesms.gcm.GcmIntentService;
+import org.thoughtcrime.securesms.gcm.GcmRegistrationTimeoutException;
+import org.thoughtcrime.securesms.gcm.RegistrationSocket;
+import org.thoughtcrime.securesms.util.Util;
+
+import java.io.IOException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * The RegisterationService handles the actual process of registration. If it receives an
+ * intent with a REGISTER_NUMBER_ACTION, it does the following through an executor:
+ *
+ * 1) Generate secrets.
+ * 2) Register the specified number and those secrets with the server.
+ * 3) Wait for a challenge SMS.
+ * 4) Verify the challenge with the server.
+ * 5) Start the GCM registration process.
+ * 6) Retrieve the current directory.
+ *
+ * The RegistrationService broadcasts its state throughout this process, and also makes its
+ * state available through service binding. This enables a View to display progress.
+ *
+ * @author Moxie Marlinspike
+ *
+ */
+
+public class RegistrationService extends Service {
+
+ public static final String NOTIFICATION_TITLE = "org.thoughtcrime.securesms.NOTIFICATION_TITLE";
+ public static final String NOTIFICATION_TEXT = "org.thoughtcrime.securesms.NOTIFICATION_TEXT";
+ public static final String REGISTER_NUMBER_ACTION = "org.thoughtcrime.securesms.RegistrationService.REGISTER_NUMBER";
+ public static final String CHALLENGE_EVENT = "org.thoughtcrime.securesms.CHALLENGE_EVENT";
+ public static final String REGISTRATION_EVENT = "org.thoughtcrime.securesms.REGISTRATION_EVENT";
+ public static final String GCM_REGISTRATION_EVENT = "org.thoughtcrime.securesms.GCM_REGISTRATION_EVENT";
+
+ public static final String CHALLENGE_EXTRA = "CAAChallenge";
+ public static final String GCM_REGISTRATION_ID = "GCMRegistrationId";
+
+ private static final long REGISTRATION_TIMEOUT_MILLIS = 120000;
+
+ private final ExecutorService executor = Executors.newSingleThreadExecutor();
+ private final Binder binder = new RegistrationServiceBinder();
+
+ private volatile RegistrationState registrationState = new RegistrationState(RegistrationState.STATE_IDLE);
+
+ private volatile Handler registrationStateHandler;
+ private volatile ChallengeReceiver challengeReceiver;
+ private volatile GcmRegistrationReceiver gcmRegistrationReceiver;
+ private String challenge;
+ private String gcmRegistrationId;
+ private long verificationStartTime;
+
+ @Override
+ public int onStartCommand(final Intent intent, int flags, int startId) {
+ if (intent != null && intent.getAction().equals(REGISTER_NUMBER_ACTION)) {
+ executor.execute(new Runnable() {
+ @Override
+ public void run() {
+ handleRegistrationIntent(intent);
+ }
+ });
+ }
+
+ return START_NOT_STICKY;
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ executor.shutdown();
+ shutdown();
+ }
+
+ @Override
+ public IBinder onBind(Intent intent) {
+ return binder;
+ }
+
+ public void shutdown() {
+ shutdownChallengeListener();
+ markAsVerifying(false);
+ registrationState = new RegistrationState(RegistrationState.STATE_IDLE);
+ }
+
+ public synchronized int getSecondsRemaining() {
+ long millisPassed;
+
+ if (verificationStartTime == 0) millisPassed = 0;
+ else millisPassed = System.currentTimeMillis() - verificationStartTime;
+
+ return Math.max((int)(REGISTRATION_TIMEOUT_MILLIS - millisPassed) / 1000, 0);
+ }
+
+ public RegistrationState getRegistrationState() {
+ return registrationState;
+ }
+
+ private void initializeChallengeListener() {
+ this.challenge = null;
+ challengeReceiver = new ChallengeReceiver();
+ IntentFilter filter = new IntentFilter(CHALLENGE_EVENT);
+ registerReceiver(challengeReceiver, filter);
+ }
+
+ private void initializeGcmRegistrationListener() {
+ this.gcmRegistrationId = null;
+ gcmRegistrationReceiver = new GcmRegistrationReceiver();
+ IntentFilter filter = new IntentFilter(GCM_REGISTRATION_EVENT);
+ registerReceiver(gcmRegistrationReceiver, filter);
+ }
+
+ private void shutdownChallengeListener() {
+ if (challengeReceiver != null) {
+ unregisterReceiver(challengeReceiver);
+ challengeReceiver = null;
+ }
+ }
+
+ private void shutdownGcmRegistrationListener() {
+ if (gcmRegistrationReceiver != null) {
+ unregisterReceiver(gcmRegistrationReceiver);
+ gcmRegistrationReceiver = null;
+ }
+ }
+
+ private void handleRegistrationIntent(Intent intent) {
+ markAsVerifying(true);
+
+ RegistrationSocket socket;
+ String number = intent.getStringExtra("e164number");
+
+ try {
+ String password = Util.getSecret(18);
+ initializeChallengeListener();
+ initializeGcmRegistrationListener();
+
+ setState(new RegistrationState(RegistrationState.STATE_CONNECTING, number));
+ socket = new RegistrationSocket(this, number, password);
+ socket.createAccount();
+
+ setState(new RegistrationState(RegistrationState.STATE_VERIFYING, number));
+ String challenge = waitForChallenge();
+ socket.verifyAccount(challenge, password);
+
+ setState(new RegistrationState(RegistrationState.STATE_GCM_REGISTERING, number));
+ GCMRegistrar.register(this, GcmIntentService.GCM_SENDER_ID);
+ String gcmRegistrationId = waitForGcmRegistrationId();
+ socket.registerGcmId(gcmRegistrationId);
+
+ markAsVerified(number, password);
+
+ setState(new RegistrationState(RegistrationState.STATE_COMPLETE, number));
+ broadcastComplete(true);
+ } catch (UnsupportedOperationException uoe) {
+ Log.w("RegistrationService", uoe);
+ setState(new RegistrationState(RegistrationState.STATE_GCM_UNSUPPORTED, number));
+ broadcastComplete(false);
+ } catch (AccountVerificationTimeoutException avte) {
+ Log.w("RegistrationService", avte);
+ setState(new RegistrationState(RegistrationState.STATE_TIMEOUT, number));
+ broadcastComplete(false);
+ } catch (IOException e) {
+ Log.w("RegistrationService", e);
+ setState(new RegistrationState(RegistrationState.STATE_NETWORK_ERROR, number));
+ broadcastComplete(false);
+ } catch (GcmRegistrationTimeoutException e) {
+ Log.w("RegistrationService", e);
+ setState(new RegistrationState(RegistrationState.STATE_GCM_TIMEOUT));
+ broadcastComplete(false);
+ } finally {
+ shutdownChallengeListener();
+ shutdownGcmRegistrationListener();
+ }
+ }
+
+ private synchronized String waitForChallenge() throws AccountVerificationTimeoutException {
+ this.verificationStartTime = System.currentTimeMillis();
+
+ if (this.challenge == null) {
+ try {
+ wait(REGISTRATION_TIMEOUT_MILLIS);
+ } catch (InterruptedException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ if (this.challenge == null)
+ throw new AccountVerificationTimeoutException();
+
+ return this.challenge;
+ }
+
+ private synchronized String waitForGcmRegistrationId() throws GcmRegistrationTimeoutException {
+ if (this.gcmRegistrationId == null) {
+ try {
+ wait(10 * 60 * 1000);
+ } catch (InterruptedException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ if (this.gcmRegistrationId == null)
+ throw new GcmRegistrationTimeoutException();
+
+ return this.gcmRegistrationId;
+ }
+
+ private synchronized void challengeReceived(String challenge) {
+ this.challenge = challenge;
+ notifyAll();
+ }
+
+ private synchronized void gcmRegistrationReceived(String gcmRegistrationId) {
+ this.gcmRegistrationId = gcmRegistrationId;
+ notifyAll();
+ }
+
+ private void markAsVerifying(boolean verifying) {
+ SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
+ Editor editor = preferences.edit();
+
+ editor.putBoolean(ApplicationPreferencesActivity.VERIFYING_STATE_PREF, verifying);
+ editor.putBoolean(ApplicationPreferencesActivity.REGISTERED_GCM_PREF, false);
+ editor.commit();
+ }
+
+ private void markAsVerified(String number, String password) {
+ SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
+ Editor editor = preferences.edit();
+
+ editor.putBoolean(ApplicationPreferencesActivity.VERIFYING_STATE_PREF, false);
+ editor.putBoolean(ApplicationPreferencesActivity.REGISTERED_GCM_PREF, true);
+ editor.putString(ApplicationPreferencesActivity.LOCAL_NUMBER_PREF, number);
+ editor.putString(ApplicationPreferencesActivity.GCM_PASSWORD_PREF, password);
+ editor.commit();
+ }
+
+ private void setState(RegistrationState state) {
+ this.registrationState = state;
+
+ if (registrationStateHandler != null) {
+ registrationStateHandler.obtainMessage(state.state, state.number).sendToTarget();
+ }
+ }
+
+ private void broadcastComplete(boolean success) {
+ Intent intent = new Intent();
+ intent.setAction(REGISTRATION_EVENT);
+
+ if (success) {
+ intent.putExtra(NOTIFICATION_TITLE, "Registration Complete");
+ intent.putExtra(NOTIFICATION_TEXT, "TextSecure registration has successfully completed.");
+ } else {
+ intent.putExtra(NOTIFICATION_TITLE, "Registration Error");
+ intent.putExtra(NOTIFICATION_TEXT, "TextSecure registration has encountered a problem.");
+ }
+
+ this.sendOrderedBroadcast(intent, null);
+ }
+
+ public void setRegistrationStateHandler(Handler registrationStateHandler) {
+ this.registrationStateHandler = registrationStateHandler;
+ }
+
+ public class RegistrationServiceBinder extends Binder {
+ public RegistrationService getService() {
+ return RegistrationService.this;
+ }
+ }
+
+ private class GcmRegistrationReceiver extends BroadcastReceiver {
+ public void onReceive(Context context, Intent intent) {
+ Log.w("RegistrationService", "Got gcm registration broadcast...");
+ gcmRegistrationReceived(intent.getStringExtra(GCM_REGISTRATION_ID));
+ }
+ }
+
+ private class ChallengeReceiver extends BroadcastReceiver {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ Log.w("RegistrationService", "Got a challenge broadcast...");
+ challengeReceived(intent.getStringExtra(CHALLENGE_EXTRA));
+ }
+ }
+
+ public static class RegistrationState {
+
+ public static final int STATE_IDLE = 0;
+ public static final int STATE_CONNECTING = 1;
+ public static final int STATE_VERIFYING = 2;
+ public static final int STATE_TIMER = 3;
+ public static final int STATE_COMPLETE = 4;
+ public static final int STATE_TIMEOUT = 5;
+ public static final int STATE_NETWORK_ERROR = 6;
+
+ public static final int STATE_GCM_UNSUPPORTED = 8;
+ public static final int STATE_GCM_REGISTERING = 9;
+ public static final int STATE_GCM_TIMEOUT = 10;
+
+ public final int state;
+ public final String number;
+
+ public RegistrationState(int state) {
+ this(state, null);
+ }
+
+ public RegistrationState(int state, String number) {
+ this.state = state;
+ this.number = number;
+ }
+ }
+}
diff --git a/src/org/thoughtcrime/securesms/service/SmsListener.java b/src/org/thoughtcrime/securesms/service/SmsListener.java
index 67387a1c45..2648d3a1e7 100644
--- a/src/org/thoughtcrime/securesms/service/SmsListener.java
+++ b/src/org/thoughtcrime/securesms/service/SmsListener.java
@@ -19,11 +19,13 @@ package org.thoughtcrime.securesms.service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
+import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.telephony.SmsMessage;
import android.util.Log;
+import org.thoughtcrime.securesms.ApplicationPreferencesActivity;
import org.thoughtcrime.securesms.protocol.WirePrefix;
public class SmsListener extends BroadcastReceiver {
@@ -91,11 +93,44 @@ public class SmsListener extends BroadcastReceiver {
return WirePrefix.isEncryptedMessage(messageBody) || WirePrefix.isKeyExchange(messageBody);
}
+ private boolean isChallenge(Context context, Intent intent) {
+ SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+ String messageBody = getSmsMessageBodyFromIntent(intent);
+
+ Log.w("SmsListener", "Checking challenge: " + messageBody);
+
+ if (messageBody == null)
+ return false;
+
+ if (messageBody.matches("Your TextSecure verification code: [0-9]{3,4}-[0-9]{3,4}") &&
+ preferences.getBoolean(ApplicationPreferencesActivity.VERIFYING_STATE_PREF, false))
+ {
+ return true;
+ }
+
+ return false;
+ }
+
+ private String parseChallenge(Context context, Intent intent) {
+ String messageBody = getSmsMessageBodyFromIntent(intent);
+ String[] messageParts = messageBody.split(":");
+ String[] codeParts = messageParts[1].trim().split("-");
+
+ return codeParts[0] + codeParts[1];
+ }
+
@Override
public void onReceive(Context context, Intent intent) {
Log.w("SMSListener", "Got SMS broadcast...");
- if (intent.getAction().equals(SMS_RECEIVED_ACTION) && isRelevant(context, intent)) {
+ if (intent.getAction().equals(SMS_RECEIVED_ACTION) && isChallenge(context, intent)) {
+ Log.w("SmsListener", "Got challenge!");
+ Intent challengeIntent = new Intent(RegistrationService.CHALLENGE_EVENT);
+ challengeIntent.putExtra(RegistrationService.CHALLENGE_EXTRA, parseChallenge(context, intent));
+ context.sendBroadcast(challengeIntent);
+
+ abortBroadcast();
+ } else if (intent.getAction().equals(SMS_RECEIVED_ACTION) && isRelevant(context, intent)) {
intent.setAction(SendReceiveService.RECEIVE_SMS_ACTION);
intent.putExtra("ResultCode", this.getResultCode());
intent.setClass(context, SendReceiveService.class);
diff --git a/src/org/thoughtcrime/securesms/util/PhoneNumberFormatter.java b/src/org/thoughtcrime/securesms/util/PhoneNumberFormatter.java
new file mode 100644
index 0000000000..0dede0538f
--- /dev/null
+++ b/src/org/thoughtcrime/securesms/util/PhoneNumberFormatter.java
@@ -0,0 +1,116 @@
+package org.thoughtcrime.securesms.util;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+import android.util.Log;
+
+import com.google.i18n.phonenumbers.NumberParseException;
+import com.google.i18n.phonenumbers.PhoneNumberUtil;
+import com.google.i18n.phonenumbers.PhoneNumberUtil.PhoneNumberFormat;
+import com.google.i18n.phonenumbers.Phonenumber.PhoneNumber;
+
+import org.thoughtcrime.securesms.ApplicationPreferencesActivity;
+
+import java.util.Locale;
+
+/**
+ * Phone number formats are a pain.
+ *
+ * @author Moxie Marlinspike
+ *
+ */
+public class PhoneNumberFormatter {
+
+ public static boolean isValidNumber(String number) {
+ return number.matches("^\\+[0-9]{10,}");
+ }
+
+ private static String impreciseFormatNumber(String number, String localNumber) {
+ number = number.replaceAll("[^0-9+]", "");
+
+ if (number.charAt(0) == '+')
+ return number;
+
+ if (localNumber.charAt(0) == '+')
+ localNumber = localNumber.substring(1);
+
+ if (localNumber.length() == number.length() || number.length() > localNumber.length())
+ return "+" + number;
+
+ int difference = localNumber.length() - number.length();
+
+ return "+" + localNumber.substring(0, difference) + number;
+ }
+
+ public static String formatNumberInternational(String number) {
+ try {
+ PhoneNumberUtil util = PhoneNumberUtil.getInstance();
+ PhoneNumber parsedNumber = util.parse(number, null);
+ return util.format(parsedNumber, PhoneNumberFormat.INTERNATIONAL);
+ } catch (NumberParseException e) {
+ Log.w("PhoneNumberFormatter", e);
+ return number;
+ }
+ }
+
+ public static String formatNumber(Context context, String number) {
+ SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
+ String localNumber = preferences.getString(ApplicationPreferencesActivity.LOCAL_NUMBER_PREF, "No Stored Number");
+ number = number.replaceAll("[^0-9+]", "");
+
+ if (number.charAt(0) == '+')
+ return number;
+
+ try {
+ PhoneNumberUtil util = PhoneNumberUtil.getInstance();
+ PhoneNumber localNumberObject = util.parse(localNumber, null);
+
+ String localCountryCode = util.getRegionCodeForNumber(localNumberObject);
+ Log.w("PhoneNumberFormatter", "Got local CC: " + localCountryCode);
+
+ PhoneNumber numberObject = util.parse(number, localCountryCode);
+ return util.format(numberObject, PhoneNumberFormat.E164);
+ } catch (NumberParseException e) {
+ Log.w("PhoneNumberFormatter", e);
+ return impreciseFormatNumber(number, localNumber);
+ }
+ }
+
+ public static String getRegionDisplayName(String regionCode) {
+ return (regionCode == null || regionCode.equals("ZZ") || regionCode.equals(PhoneNumberUtil.REGION_CODE_FOR_NON_GEO_ENTITY))
+ ? "Unknown country" : new Locale("", regionCode).getDisplayCountry(Locale.getDefault());
+ }
+
+ public static String formatE164(String countryCode, String number) {
+ try {
+ PhoneNumberUtil util = PhoneNumberUtil.getInstance();
+ int parsedCountryCode = Integer.parseInt(countryCode);
+ PhoneNumber parsedNumber = util.parse(number,
+ util.getRegionCodeForCountryCode(parsedCountryCode));
+
+ return util.format(parsedNumber, PhoneNumberUtil.PhoneNumberFormat.E164);
+ } catch (NumberParseException npe) {
+ Log.w("CreateAccountActivity", npe);
+ } catch (NumberFormatException nfe) {
+ Log.w("CreateAccountActivity", nfe);
+ }
+
+ return "+" +
+ countryCode.replaceAll("[^0-9]", "").replaceAll("^0*", "") +
+ number.replaceAll("[^0-9]", "");
+ }
+
+ public static String getInternationalFormatFromE164(String e164number) {
+ try {
+ PhoneNumberUtil util = PhoneNumberUtil.getInstance();
+ PhoneNumber parsedNumber = util.parse(e164number, null);
+ return util.format(parsedNumber, PhoneNumberFormat.INTERNATIONAL);
+ } catch (NumberParseException e) {
+ Log.w("PhoneNumberFormatter", e);
+ return e164number;
+ }
+ }
+
+
+}
diff --git a/src/org/thoughtcrime/securesms/util/Util.java b/src/org/thoughtcrime/securesms/util/Util.java
index 5729d329d3..f480625a08 100644
--- a/src/org/thoughtcrime/securesms/util/Util.java
+++ b/src/org/thoughtcrime/securesms/util/Util.java
@@ -16,12 +16,19 @@
*/
package org.thoughtcrime.securesms.util;
+import android.app.AlertDialog;
+import android.content.Context;
import android.graphics.Typeface;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.style.StyleSpan;
import android.widget.EditText;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
@@ -94,6 +101,10 @@ public class Util {
return value == null || value.getText() == null || isEmpty(value.getText().toString());
}
+ public static boolean isEmpty(CharSequence value) {
+ return value == null || value.length() == 0;
+ }
+
public static CharSequence getBoldedString(String value) {
SpannableString spanned = new SpannableString(value);
spanned.setSpan(new StyleSpan(Typeface.BOLD), 0,
@@ -112,6 +123,39 @@ public class Util {
return spanned;
}
+ public static void showAlertDialog(Context context, String title, String message) {
+ AlertDialog.Builder dialog = new AlertDialog.Builder(context);
+ dialog.setTitle(title);
+ dialog.setMessage(message);
+ dialog.setIcon(android.R.drawable.ic_dialog_alert);
+ dialog.setPositiveButton(android.R.string.ok, null);
+ dialog.show();
+ }
+
+ public static String getSecret(int size) {
+ try {
+ byte[] secret = new byte[size];
+ SecureRandom.getInstance("SHA1PRNG").nextBytes(secret);
+ return Base64.encodeBytes(secret);
+ } catch (NoSuchAlgorithmException nsae) {
+ throw new AssertionError(nsae);
+ }
+ }
+
+ 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) {
+ bout.write(buffer, 0, read);
+ }
+
+ in.close();
+
+ return new String(bout.toByteArray());
+ }
+
// public static Bitmap loadScaledBitmap(InputStream src, int targetWidth, int targetHeight) {
// return BitmapFactory.decodeStream(src);
//// BitmapFactory.Options options = new BitmapFactory.Options();