summaryrefslogtreecommitdiff
path: root/src/org
diff options
context:
space:
mode:
Diffstat (limited to 'src/org')
-rw-r--r--src/org/xapek/andiodine/FragmentList.java207
-rw-r--r--src/org/xapek/andiodine/FragmentStatus.java107
-rw-r--r--src/org/xapek/andiodine/IodineClient.java54
-rw-r--r--src/org/xapek/andiodine/IodineMain.java102
-rw-r--r--src/org/xapek/andiodine/IodinePref.java112
-rw-r--r--src/org/xapek/andiodine/IodineVpnService.java328
-rw-r--r--src/org/xapek/andiodine/config/ConfigDatabase.java126
-rw-r--r--src/org/xapek/andiodine/config/IodineConfiguration.java127
-rw-r--r--src/org/xapek/andiodine/preferences/AbstractPreference.java49
-rw-r--r--src/org/xapek/andiodine/preferences/BooleanPreference.java33
-rw-r--r--src/org/xapek/andiodine/preferences/PreferenceActivity.java104
-rw-r--r--src/org/xapek/andiodine/preferences/SpinnerPreference.java47
-rw-r--r--src/org/xapek/andiodine/preferences/TextPreference.java35
13 files changed, 1431 insertions, 0 deletions
diff --git a/src/org/xapek/andiodine/FragmentList.java b/src/org/xapek/andiodine/FragmentList.java
new file mode 100644
index 0000000..e07aee4
--- /dev/null
+++ b/src/org/xapek/andiodine/FragmentList.java
@@ -0,0 +1,207 @@
+package org.xapek.andiodine;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Fragment;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.database.DataSetObserver;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageButton;
+import android.widget.LinearLayout;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import org.xapek.andiodine.config.ConfigDatabase;
+import org.xapek.andiodine.config.IodineConfiguration;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class FragmentList extends Fragment {
+ public static final String TAG = "FRAGMENT_LIST";
+
+ private ListView mListView;
+ private ConfigDatabase mConfigDatabase;
+ private IodineConfiguration mSelectedConfiguration;
+ private IodineConfigurationAdapter mAdapter;
+
+ private static final int INTENT_REQUEST_CODE_PREPARE = 0;
+
+ private class IodineConfigurationAdapter extends BaseAdapter {
+ private List<IodineConfiguration> configurations;
+ private final Set<DataSetObserver> observers = new HashSet<DataSetObserver>();
+
+ public IodineConfigurationAdapter() {
+ reload();
+ }
+
+ @Override
+ public int getCount() {
+ return configurations.size();
+ }
+
+ @Override
+ public IodineConfiguration getItem(int position) {
+ return configurations.get(position);
+ }
+
+ @Override
+ public long getItemId(int position) {
+ return 0;
+ }
+
+ @Override
+ public View getView(int position, View convertView, ViewGroup parent) {
+ final IodineConfiguration item = getItem(position);
+ View view = View.inflate(parent.getContext(), R.layout.configitem, null);
+ ((TextView) view.findViewById(R.id.configitem_text_name)).setText(item.getName());
+ ((TextView) view.findViewById(R.id.configitem_text_topdomain)).setText(item.getTopDomain());
+
+ view.findViewById(R.id.configitem_btn_manage)
+ .setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ FragmentList.this.vpnPreferences(item);
+ }
+ });
+
+ view.findViewById(R.id.configitem_layout_name)
+ .setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ FragmentList.this.vpnServiceConnect(item);
+ }
+ });
+
+ return view;
+ }
+
+ @Override
+ public void registerDataSetObserver(DataSetObserver observer) {
+ observers.add(observer);
+ }
+
+ private void reload() {
+ this.configurations = mConfigDatabase.selectAll();
+ triggerOnChanged();
+ }
+
+ public void triggerOnChanged() {
+ for (DataSetObserver observer : observers) {
+ observer.onChanged();
+ }
+ }
+
+ @Override
+ public void unregisterDataSetObserver(DataSetObserver observer) {
+ observers.remove(observer);
+ }
+ }
+
+ private final BroadcastReceiver broadcastReceiverConfigurationChanged = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ if (IodinePref.ACTION_CONFIGURATION_CHANGED.equals(intent.getAction())) {
+ // CONFIGURATION_CHANGED
+ mAdapter.reload();
+ }
+ }
+ };
+
+
+ @Override
+ public void onActivityCreated(Bundle savedInstanceState) {
+ super.onActivityCreated(savedInstanceState);
+ mConfigDatabase = new ConfigDatabase(getActivity());
+ mListView = (ListView) getActivity().findViewById(R.id.list_view);
+ mAdapter = new IodineConfigurationAdapter();
+ mListView.setAdapter(mAdapter);
+
+ IntentFilter intentFilterConfigurationChanged = new IntentFilter();
+ intentFilterConfigurationChanged.addAction(IodinePref.ACTION_CONFIGURATION_CHANGED);
+ getActivity().registerReceiver(broadcastReceiverConfigurationChanged, intentFilterConfigurationChanged);
+
+ setHasOptionsMenu(true); //activate onCreateOptionsMenu
+ }
+
+ @Override
+ public void onDestroy() {
+ getActivity().unregisterReceiver(broadcastReceiverConfigurationChanged);
+ mConfigDatabase.close();
+ super.onDestroy();
+ }
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+ return inflater.inflate(R.layout.fragment_list, null);
+ }
+
+ @Override
+ public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+ super.onCreateOptionsMenu(menu, inflater);
+ inflater.inflate(R.menu.fragment_list, menu);
+ }
+
+ private void vpnPreferences(IodineConfiguration item) {
+ Intent intent = new Intent(getActivity(), IodinePref.class);
+ intent.putExtra(IodinePref.EXTRA_CONFIGURATION_ID, item.getId());
+ startActivity(intent);
+ }
+
+ private void vpnServiceConnect(IodineConfiguration configuration) {
+ Intent intent = IodineVpnService.prepare(getActivity());
+ mSelectedConfiguration = configuration;
+ if (intent != null) {
+ // Ask for permission
+ intent.putExtra(IodineVpnService.EXTRA_CONFIGURATION_ID, configuration.getId());
+ startActivityForResult(intent, INTENT_REQUEST_CODE_PREPARE);
+ } else {
+ // Permission already granted
+ new AlertDialog.Builder(getActivity()) //
+ .setTitle(R.string.warning) //
+ .setCancelable(true) //
+ .setMessage(getString(R.string.main_create_tunnel, configuration.getName()))
+ .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ vpnServiceConnect2(mSelectedConfiguration);
+ }
+ }) //
+ .setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ dialog.dismiss();
+ }
+ }) //
+ .create() //
+ .show();
+
+ }
+ }
+
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (requestCode == INTENT_REQUEST_CODE_PREPARE && resultCode == Activity.RESULT_OK) {
+ vpnServiceConnect2(mSelectedConfiguration);
+ }
+ }
+
+ private void vpnServiceConnect2(IodineConfiguration configuration) {
+ Log.d(TAG, "Call VPN Service for configuration: " + configuration.getId());
+ Intent intent = new Intent(IodineVpnService.ACTION_CONTROL_CONNECT);
+ intent.putExtra(IodineVpnService.EXTRA_CONFIGURATION_ID, configuration.getId());
+ getActivity().sendBroadcast(intent);
+ }
+}
diff --git a/src/org/xapek/andiodine/FragmentStatus.java b/src/org/xapek/andiodine/FragmentStatus.java
new file mode 100644
index 0000000..aaa64fb
--- /dev/null
+++ b/src/org/xapek/andiodine/FragmentStatus.java
@@ -0,0 +1,107 @@
+package org.xapek.andiodine;
+
+import android.app.AlertDialog;
+import android.app.Fragment;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.ScrollView;
+import android.widget.TextView;
+
+public class FragmentStatus extends Fragment {
+ public static final String TAG = "FRAGMENT_STATUS";
+
+ private TextView mStatus;
+ private TextView mLogmessages;
+ private ScrollView mScrollview;
+ private Button mCancel;
+
+ private final BroadcastReceiver broadcastReceiverStatusUpdates = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ Log.d(TAG, "Got intent: " + intent);
+ if (IodineVpnService.ACTION_STATUS_ERROR.equals(intent.getAction())) {
+ new AlertDialog.Builder(FragmentStatus.this.getActivity())//
+ .setIcon(R.drawable.error) //
+ .setTitle(intent.getStringExtra(IodineVpnService.EXTRA_ERROR_MESSAGE)) //
+ .setMessage(mLogmessages.getText()) //
+ .create() //
+ .show();
+ } else if (IodineVpnService.ACTION_STATUS_CONNECT.equals(intent.getAction())) {
+ mStatus.setText("Connect");
+ } else if (IodineVpnService.ACTION_STATUS_CONNECTED.equals(intent.getAction())) {
+ mStatus.setText("Connected");
+ } else if (IodineVpnService.ACTION_STATUS_DISCONNECT.equals(intent.getAction())) {
+ mStatus.setText("Disconnect");
+ }
+ }
+ };
+
+ private final BroadcastReceiver broadcastReceiverLogMessages = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ if (IodineClient.ACTION_LOG_MESSAGE.equals(intent.getAction())) {
+ mLogmessages.append("\n");
+ mLogmessages.append(intent.getStringExtra(IodineClient.EXTRA_MESSAGE));
+ mScrollview.fullScroll(View.FOCUS_DOWN);
+ }
+ }
+ };
+
+ @Override
+ public void onActivityCreated(Bundle savedInstanceState) {
+ super.onActivityCreated(savedInstanceState);
+ mStatus = (TextView) getActivity().findViewById(R.id.status_message);
+ mLogmessages = (TextView) getActivity().findViewById(R.id.status_logmessages);
+ mScrollview = (ScrollView) getActivity().findViewById(R.id.status_scrollview);
+ mCancel = (Button) getActivity().findViewById(R.id.status_cancel);
+ mCancel.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view) {
+ requestDisconnect();
+ }
+ });
+ }
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ IntentFilter intentFilterStatusUpdates = new IntentFilter();
+ intentFilterStatusUpdates.addAction(IodineVpnService.ACTION_STATUS_CONNECT);
+ intentFilterStatusUpdates.addAction(IodineVpnService.ACTION_STATUS_CONNECTED);
+ intentFilterStatusUpdates.addAction(IodineVpnService.ACTION_STATUS_DISCONNECT);
+ intentFilterStatusUpdates.addAction(IodineVpnService.ACTION_STATUS_ERROR);
+ getActivity().registerReceiver(broadcastReceiverStatusUpdates, intentFilterStatusUpdates);
+
+ Intent intent = new Intent(IodineVpnService.ACTION_CONTROL_UPDATE);
+ getActivity().sendBroadcast(intent);
+
+ IntentFilter intentFilterLogMessages = new IntentFilter();
+ intentFilterLogMessages.addAction(IodineClient.ACTION_LOG_MESSAGE);
+ getActivity().registerReceiver(broadcastReceiverLogMessages, intentFilterLogMessages);
+ }
+
+ @Override
+ public void onDestroy() {
+ getActivity().unregisterReceiver(broadcastReceiverStatusUpdates);
+ getActivity().unregisterReceiver(broadcastReceiverLogMessages);
+ super.onDestroy();
+ }
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+ return inflater.inflate(R.layout.fragment_status, null);
+ }
+
+ private void requestDisconnect() {
+ Intent intent = new Intent(IodineVpnService.ACTION_CONTROL_DISCONNECT);
+ getActivity().sendBroadcast(intent);
+ }
+}
diff --git a/src/org/xapek/andiodine/IodineClient.java b/src/org/xapek/andiodine/IodineClient.java
new file mode 100644
index 0000000..e9383ec
--- /dev/null
+++ b/src/org/xapek/andiodine/IodineClient.java
@@ -0,0 +1,54 @@
+package org.xapek.andiodine;
+
+import android.content.Intent;
+import android.util.Log;
+
+public class IodineClient {
+ public static final String TAG = "NATIVE";
+
+ public static native int getDnsFd();
+
+ public static native int connect(String nameserv_addr, String topdomain, boolean raw_mode, boolean lazy_mode,
+ String password);
+
+ public static native String getIp();
+
+ public static native String getRemoteIp();
+
+ public static native int getNetbits();
+
+ public static native int getMtu();
+
+ public static native int tunnel(int fd);
+
+ public static native void tunnelInterrupt();
+
+ public static native String getPropertyNetDns1();
+
+ /**
+ * Intent to distribute logmessages from native code
+ * LOG_MESSAGE(EXTRA_MESSAGE)
+ */
+ public static final String ACTION_LOG_MESSAGE = "org.xapek.andiodine.IodineClient.ACTION_LOG_MESSAGE";
+
+ public static final String EXTRA_MESSAGE = "message";
+
+ @SuppressWarnings("UnusedDeclaration")
+ public static void log_callback(String message) {
+ Log.d(TAG, "Message: " + message);
+ Intent intent = new Intent(ACTION_LOG_MESSAGE);
+
+ intent.putExtra(EXTRA_MESSAGE, message);
+ if (IodineVpnService.instance != null) {
+ IodineVpnService.instance.sendBroadcast(intent);
+ } else {
+ Log.d(TAG, "No VPNService running, cannot broadcast native message");
+ }
+
+ }
+
+ static {
+ System.loadLibrary("iodine-client");
+ Log.d(TAG, "Native Library iodine-client loaded");
+ }
+} \ No newline at end of file
diff --git a/src/org/xapek/andiodine/IodineMain.java b/src/org/xapek/andiodine/IodineMain.java
new file mode 100644
index 0000000..b53ea10
--- /dev/null
+++ b/src/org/xapek/andiodine/IodineMain.java
@@ -0,0 +1,102 @@
+package org.xapek.andiodine;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.FragmentTransaction;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import org.xapek.andiodine.config.ConfigDatabase;
+
+import java.util.Scanner;
+
+public class IodineMain extends Activity {
+ private static final String TAG = "MAIN";
+ private ConfigDatabase mConfigDatabase;
+
+ private final FragmentList fragmentList = new FragmentList();
+ private final FragmentStatus fragmentStatus = new FragmentStatus();
+
+ private final BroadcastReceiver broadcastReceiverStatusUpdates = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ Log.d(TAG, "Got intent: " + intent);
+ if (IodineVpnService.ACTION_STATUS_ERROR.equals(intent.getAction())) {
+ // Switch to List of Configurations Fragment
+ FragmentTransaction ft = getFragmentManager().beginTransaction();
+ ft.replace(R.id.main_fragment_status, fragmentList);
+ ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
+ ft.commit();
+ } else if (IodineVpnService.ACTION_STATUS_IDLE.equals(intent.getAction())) {
+ // Switch to List of Configurations Fragment
+ FragmentTransaction ft = getFragmentManager().beginTransaction();
+ ft.replace(R.id.main_fragment_status, fragmentList);
+ ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
+ ft.commit();
+ } else if (IodineVpnService.ACTION_STATUS_CONNECT.equals(intent.getAction())) {
+ // Switch to Status Fragment
+ FragmentTransaction ft = getFragmentManager().beginTransaction();
+ ft.replace(R.id.main_fragment_status, fragmentStatus);
+ ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
+ ft.commit();
+ }
+ }
+ };
+
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.main);
+
+ mConfigDatabase = new ConfigDatabase(this);
+
+ IntentFilter intentFilterStatusUpdates = new IntentFilter();
+ intentFilterStatusUpdates.addAction(IodineVpnService.ACTION_STATUS_CONNECT);
+ intentFilterStatusUpdates.addAction(IodineVpnService.ACTION_STATUS_ERROR);
+ intentFilterStatusUpdates.addAction(IodineVpnService.ACTION_STATUS_IDLE);
+ registerReceiver(broadcastReceiverStatusUpdates, intentFilterStatusUpdates);
+
+ startService(new Intent(this, IodineVpnService.class));
+ }
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ getMenuInflater().inflate(R.menu.main, menu);
+ return true;
+ }
+
+ @Override
+ protected void onDestroy() {
+ unregisterReceiver(broadcastReceiverStatusUpdates);
+ mConfigDatabase.close();
+ super.onDestroy();
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ if (item.getItemId() == R.id.menu_main_about) {
+ Scanner scanner = new Scanner(getResources().openRawResource(R.raw.license));
+ scanner.useDelimiter("\\A");
+ new AlertDialog.Builder(IodineMain.this)//
+ .setMessage(scanner.next()) //
+ .setCancelable(true)//
+ .create() //
+ .show();
+ } else if (item.getItemId() == R.id.menu_main_add) {
+ startActivity(new Intent(this, IodinePref.class));
+ }
+ return super.onOptionsItemSelected(item);
+ }
+
+
+ private void vpnServiceDisconnect() {
+ sendBroadcast(new Intent(IodineVpnService.ACTION_CONTROL_DISCONNECT));
+ }
+}
diff --git a/src/org/xapek/andiodine/IodinePref.java b/src/org/xapek/andiodine/IodinePref.java
new file mode 100644
index 0000000..cc21b59
--- /dev/null
+++ b/src/org/xapek/andiodine/IodinePref.java
@@ -0,0 +1,112 @@
+package org.xapek.andiodine;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import org.xapek.andiodine.config.ConfigDatabase;
+import org.xapek.andiodine.config.IodineConfiguration;
+import org.xapek.andiodine.config.IodineConfiguration.NameserverMode;
+import org.xapek.andiodine.config.IodineConfiguration.RequestType;
+
+public class IodinePref extends org.xapek.andiodine.preferences.PreferenceActivity {
+ public static final String EXTRA_CONFIGURATION_ID = "uuid";
+ public static final String ACTION_CONFIGURATION_CHANGED = "org.xapek.andiodine.preferences.PreferenceActivity.CONFIGURATION_CHANGED";
+
+ private static final String TAG = "PREF";
+
+ private ConfigDatabase mConfigDatabase;
+
+ private IodineConfiguration mIodineConfiguration;
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ getActionBar().setDisplayHomeAsUpEnabled(true);
+
+ mConfigDatabase = new ConfigDatabase(this);
+ Long configurationId = getIntent().getLongExtra(EXTRA_CONFIGURATION_ID, -1);
+ if (configurationId == null || configurationId == -1) {
+ // Configuration ID is empty; create new configuration
+ mIodineConfiguration = new IodineConfiguration();
+ } else {
+ mIodineConfiguration = mConfigDatabase.selectById(configurationId);
+ if (mIodineConfiguration == null) {
+ Log.e(TAG, "No configuration with uuid: " + configurationId + " found");
+ finish();
+ }
+ }
+ setContentValues(mIodineConfiguration.getContentValues());
+
+ // Name
+ addPreference(ConfigDatabase.COLUMN_CONF_NAME, "Name", R.string.pref_help_name, "New Connection");
+ // Topdomain
+ addPreference(ConfigDatabase.COLUMN_CONF_TOP_DOMAIN, "Tunnel Topdomain", R.string.pref_help_topdomain,
+ "tun.example.com");
+ // Password
+ addPreference(ConfigDatabase.COLUMN_CONF_PASSWORD, "Password", R.string.pref_help_password, "");
+ // Tunnel Nameserver
+ addPreference(ConfigDatabase.COLUMN_CONF_TUNNEL_NAMESERVER, "Tunnel Nameserver (or empty)",
+ R.string.pref_help_tunnel_nameserver, "");
+ // Nameserver Mode
+ String[] nameserverModes = new String[NameserverMode.values().length];
+ for (int i = 0; i < NameserverMode.values().length; i++) {
+ nameserverModes[i] = NameserverMode.values()[i].name();
+ }
+ addPreference(ConfigDatabase.COLUMN_CONF_NAMESERVER_MODE, "Nameserver Mode",
+ R.string.pref_help_nameserver_mode, nameserverModes, NameserverMode.LEAVE_DEFAULT.name());
+ // Nameserver
+ addPreference(ConfigDatabase.COLUMN_CONF_NAMESERVER, "Nameserver", R.string.pref_help_nameserver, "");
+ // Request Type
+ String[] requestTypes = new String[RequestType.values().length];
+ for (int i = 0; i < RequestType.values().length; i++) {
+ requestTypes[i] = RequestType.values()[i].name();
+ }
+ addPreference(ConfigDatabase.COLUMN_CONF_REQUEST_TYPE, "Request Type", R.string.pref_help_request_type,
+ requestTypes, RequestType.AUTODETECT.name());
+ // Lazy Mode
+ addPreference(ConfigDatabase.COLUMN_CONF_LAZY_MODE, "Lazy mode", R.string.pref_help_lazy, true);
+ // Raw Mode
+ addPreference(ConfigDatabase.COLUMN_CONF_RAW_MODE, "Raw Mode", R.string.pref_help_raw, false);
+ // Default Route
+ addPreference(ConfigDatabase.COLUMN_CONF_DEFAULT_ROUTE, "Default Route", R.string.pref_help_default_route, true);
+ }
+
+ @Override
+ protected void onDestroy() {
+ mConfigDatabase.close();
+ super.onDestroy();
+ }
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ getMenuInflater().inflate(R.menu.pref, menu);
+ return super.onCreateOptionsMenu(menu);
+ }
+
+ @Override
+ protected void onStop() {
+ mConfigDatabase.insertOrUpdate(mIodineConfiguration.getContentValues());
+ Intent intent = new Intent(ACTION_CONFIGURATION_CHANGED);
+ intent.putExtra(EXTRA_CONFIGURATION_ID, mIodineConfiguration.getId());
+ sendBroadcast(intent);
+ super.onStop();
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ if (item.getItemId() == R.id.menu_pref_delete) {
+ // Delete current connection
+ if (mIodineConfiguration.getId() != null) {
+ mConfigDatabase.delete(mIodineConfiguration.getContentValues());
+ }
+ finish();
+ } else if (item.getItemId() == android.R.id.home) {
+ finish();
+ }
+ return super.onOptionsItemSelected(item);
+ }
+}
diff --git a/src/org/xapek/andiodine/IodineVpnService.java b/src/org/xapek/andiodine/IodineVpnService.java
new file mode 100644
index 0000000..f816aaa
--- /dev/null
+++ b/src/org/xapek/andiodine/IodineVpnService.java
@@ -0,0 +1,328 @@
+package org.xapek.andiodine;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.VpnService;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+
+import org.xapek.andiodine.config.ConfigDatabase;
+import org.xapek.andiodine.config.IodineConfiguration;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class IodineVpnService extends VpnService implements Runnable {
+ private class IodineVpnException extends Exception {
+ private static final long serialVersionUID = 32487871521160156L;
+
+ public IodineVpnException(String message, Throwable e) {
+ super(message, e);
+ }
+
+ public IodineVpnException(String message) {
+ super(message);
+ }
+ }
+
+ private static final String TAG = "VPN_SERVICE";
+
+ public static IodineVpnService instance = null;
+
+ /**
+ * long
+ */
+ public static final String EXTRA_CONFIGURATION_ID = "configuration_id";
+ /**
+ * String
+ */
+ public static final String EXTRA_ERROR_MESSAGE = "message";
+
+ /**
+ * Intent to connect to VPN Connection
+ * CONTROL_CONNECT(EXTRA_CONFIGURATION_ID)
+ */
+
+ public static final String ACTION_CONTROL_CONNECT = "org.xapek.andiodine.IodineVpnService.CONTROL_CONNECT";
+ /**
+ * Intent to close the vpn connection
+ */
+ public static final String ACTION_CONTROL_DISCONNECT = "org.xapek.andiodine.IodineVpnService.CONTROL_DISCONNECT";
+
+ /**
+ * Intent to request a new status update
+ */
+ public static final String ACTION_CONTROL_UPDATE = "org.xapek.andiodine.IodineVpnService.CONTROL_UPDATE";
+
+ /**
+ * Broadcast Action: The tunnel service is idle. This Action contains no
+ * extras.
+ */
+ public static final String ACTION_STATUS_IDLE = "org.xapek.andiodine.IodineVpnService.STATUS_IDLE";
+
+ /**
+ * Broadcast Action: The user sent CONTROL_CONNECT and the vpn service is
+ * trying to connect.
+ *
+ * @see #EXTRA_CONFIGURATION_ID
+ */
+ public static final String ACTION_STATUS_CONNECT = "org.xapek.andiodine.IodineVpnService.STATUS_CONNECT";
+ /**
+ * Broadcast Action: The tunnel is connected
+ *
+ * @see #EXTRA_CONFIGURATION_ID
+ */
+ public static final String ACTION_STATUS_CONNECTED = "org.xapek.andiodine.IodineVpnService.STATUS_CONNECTED";
+ /**
+ * Broadcast Action: The tunnel was disconnected
+ *
+ * @see #EXTRA_CONFIGURATION_ID
+ */
+ public static final String ACTION_STATUS_DISCONNECT = "org.xapek.andiodine.IodineVpnService.STATUS_DISCONNECT";
+ /**
+ * Broadcast Action: An error occured
+ *
+ * @see #EXTRA_CONFIGURATION_ID
+ * @see #EXTRA_ERROR_MESSAGE
+ */
+ public static final String ACTION_STATUS_ERROR = "org.xapek.andiodine.IodineVpnService.STATUS_ERROR";
+
+ private Thread mThread;
+ private ConfigDatabase configDatabase;
+ private IodineConfiguration mConfiguration;
+ private final BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ if (ACTION_CONTROL_DISCONNECT.equals(intent.getAction())) {
+ shutdown();
+ } else if (ACTION_CONTROL_UPDATE.equals(intent.getAction())) {
+ sendStatus();
+ } else if (ACTION_CONTROL_CONNECT.equals(intent.getAction())) {
+ if (mThread != null) {
+ setStatus(ACTION_STATUS_ERROR, -1L, getString(R.string.vpnservice_error_already_running));
+ return;
+ }
+
+ long configurationId = intent.getLongExtra(EXTRA_CONFIGURATION_ID, -1);
+ if (configurationId == -1L) {
+ setStatus(ACTION_STATUS_ERROR, -1L, getString(R.string.vpnservice_error_configuration_incomplete));
+ return;
+ }
+
+ mConfiguration = configDatabase.selectById(configurationId);
+ if (mConfiguration == null) {
+ setStatus(ACTION_STATUS_ERROR, mConfiguration.getId(),
+ getString(R.string.vpnservice_error_configuration_incomplete));
+ return;
+ }
+
+ mThread = new Thread(IodineVpnService.this, IodineVpnService.class.getName());
+ mThread.start();
+ }
+ }
+ };
+
+ private String currentActionStatus = ACTION_STATUS_IDLE;
+
+ private Long currentConfigurationId = null;
+
+ private String currentMessage = null;
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ instance = this;
+
+ configDatabase = new ConfigDatabase(this);
+
+ IntentFilter filterInterruptAction = new IntentFilter();
+ filterInterruptAction.addAction(ACTION_CONTROL_CONNECT);
+ filterInterruptAction.addAction(ACTION_CONTROL_DISCONNECT);
+ filterInterruptAction.addAction(ACTION_CONTROL_UPDATE);
+ registerReceiver(broadcastReceiver, filterInterruptAction);
+ }
+
+ @Override
+ public int onStartCommand(Intent intent, int flags, int startId) {
+ sendStatus();
+ return START_STICKY;
+ }
+
+ private void shutdown() {
+ setStatus(ACTION_STATUS_DISCONNECT, mConfiguration.getId(), null);
+
+ if (mThread != null) {
+ mThread.interrupt();
+ IodineClient.tunnelInterrupt();
+ }
+ }
+
+ @Override
+ public void onRevoke() {
+ shutdown();
+ }
+
+ @Override
+ public void onDestroy() {
+ if (mThread != null) {
+ mThread.interrupt();
+ IodineClient.tunnelInterrupt();
+ mThread = null;
+ }
+ instance = null;
+ configDatabase.close();
+ unregisterReceiver(broadcastReceiver);
+ }
+
+ private void setStatus(String ACTION_STATUS, Long configurationId, String message) {
+ currentActionStatus = ACTION_STATUS;
+ currentConfigurationId = configurationId;
+ currentMessage = message;
+ sendStatus();
+ }
+
+ private void sendStatus() {
+ if (currentActionStatus != null) {
+ Intent intent = new Intent(currentActionStatus);
+
+ if (currentConfigurationId != null) {
+ intent.putExtra(EXTRA_CONFIGURATION_ID, currentConfigurationId);
+ }
+ if (currentMessage != null) {
+ intent.putExtra(EXTRA_ERROR_MESSAGE, currentMessage);
+ }
+ Log.d(TAG, "Send: " + intent);
+ sendBroadcast(intent);
+ }
+ }
+
+ @Override
+ public void run() {
+ try {
+ Log.d(TAG, "VPN Thread enter");
+ setStatus(ACTION_STATUS_CONNECT, mConfiguration.getId(), null);
+
+ String tunnelNamesver = IodineClient.getPropertyNetDns1();
+ if (!"".equals(mConfiguration.getTunnelNameserver())) {
+ tunnelNamesver = mConfiguration.getTunnelNameserver();
+ }
+ String password = "";
+ if (!"".equals(mConfiguration.getPassword())) {
+ password = mConfiguration.getPassword();
+ }
+
+ int ret = IodineClient.connect(tunnelNamesver, mConfiguration.getTopDomain(), mConfiguration.getRawMode(),
+ mConfiguration.getLazyMode(), password);
+
+ String errorMessage = "";
+ switch (ret) {
+ case 0:
+ Log.d(TAG, "Handshake successful");
+ setStatus(ACTION_STATUS_CONNECTED, currentConfigurationId, null);
+ runTunnel();
+ setStatus(ACTION_STATUS_IDLE, null, null);
+ break;
+ case 1:
+ if (errorMessage.equals(""))
+ errorMessage = getString(R.string.vpnservice_error_cant_open_dnssocket);
+ // Fall through
+ case 2:
+ if (errorMessage.equals(""))
+ errorMessage = getString(R.string.vpnservice_error_handshake_failed);
+ // fall through
+ default:
+ if (errorMessage.equals(""))
+ errorMessage = String.format(getString(R.string.vpnservice_error_unknown_error_code), ret);
+
+ setStatus(ACTION_STATUS_ERROR, mConfiguration.getId(), errorMessage);
+ break;
+ }
+ } catch (IllegalStateException e) {
+ String errorMessage = "IllegalStateException";
+ if (e.getMessage().contains("Cannot create interface")) {
+ errorMessage = "Failed to create tunnel network device";
+ } else {
+ e.printStackTrace();
+ }
+ setStatus(ACTION_STATUS_ERROR, mConfiguration.getId(), errorMessage);
+ } catch (IodineVpnException e) {
+ e.printStackTrace();
+
+ setStatus(ACTION_STATUS_ERROR, mConfiguration.getId(),
+ String.format(getString(R.string.vpnservice_error_unknown_error_string), e.getMessage()));
+ } finally {
+ mThread = null;
+ mConfiguration = null;
+ Log.d(TAG, "VPN Thread exit");
+ }
+ }
+
+ private void runTunnel() throws IodineVpnException {
+ Builder b = new Builder();
+ b.setSession("Iodine VPN Service");
+
+ String ip = IodineClient.getIp();
+ int netbits = IodineClient.getNetbits();
+ int mtu = IodineClient.getMtu();
+ Log.d(TAG, "Build tunnel for configuration: ip=" + ip + " netbits=" + netbits + " mtu=" + mtu);
+
+ String[] ipBytesString = ip.split("\\.");
+ if (ipBytesString.length != 4) {
+ throw new IodineVpnException("Server sent invalid IP");
+ }
+ byte[] ipBytes = new byte[4];
+ for (int i = 0; i < 4; i++) {
+ try {
+ int integer = Integer.parseInt(ipBytesString[i]);
+ ipBytes[i] = (byte) (integer);
+ } catch (NumberFormatException e) {
+ throw new IodineVpnException("Server sent invalid IP", e);
+ }
+ }
+
+ InetAddress hostAddress;
+ try {
+ hostAddress = InetAddress.getByAddress(ipBytes);
+ } catch (UnknownHostException e) {
+ throw new IodineVpnException("Server sent invalid IP", e);
+ }
+ try {
+ switch (mConfiguration.getNameserverMode()) {
+ case LEAVE_DEFAULT:
+ // do nothing
+ break;
+ case SET_SERVER_TUNNEL_IP:
+ b.addDnsServer(IodineClient.getRemoteIp());
+ break;
+ case SET_CUSTOM:
+ b.addDnsServer(InetAddress.getByName(mConfiguration.getNameserver()));
+ break;
+ default:
+ throw new IodineVpnException("Invalid Nameserver mode");
+ }
+ } catch (UnknownHostException e) {
+ throw new IodineVpnException("Invalid Nameserver address", e);
+ }
+
+ b.addAddress(hostAddress, netbits);
+ if (mConfiguration.getDefaultRoute()) {
+ Log.d(TAG, "Set default route");
+ b.addRoute("0.0.0.0", 0); // Default Route
+ }
+ b.setMtu(mtu);
+
+ Log.d(TAG, "Build tunnel interface");
+ ParcelFileDescriptor parcelFD = b.establish();
+
+ protect(IodineClient.getDnsFd());
+
+ int tun_fd = parcelFD.detachFd();
+
+ setStatus(ACTION_STATUS_CONNECTED, mConfiguration.getId(), null);
+
+ Log.d(TAG, "Tunnel active");
+ IodineClient.tunnel(tun_fd);
+ }
+}
diff --git a/src/org/xapek/andiodine/config/ConfigDatabase.java b/src/org/xapek/andiodine/config/ConfigDatabase.java
new file mode 100644
index 0000000..ffc1656
--- /dev/null
+++ b/src/org/xapek/andiodine/config/ConfigDatabase.java
@@ -0,0 +1,126 @@
+package org.xapek.andiodine.config;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.SQLException;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConfigDatabase extends SQLiteOpenHelper {
+ public static final String TAG = "ConfigDatabase";
+
+ private static final String DATABASE_NAME = "andiodine.db";
+ private static final int DATABASE_VERSION = 1;
+ static public final String TABLE_NAME_CONF = "configuration";
+ static public final String COLUMN_CONF_ID = "id";
+ static public final String COLUMN_CONF_NAME = "name";
+ static public final String COLUMN_CONF_LAST_USED = "last_used";
+ static public final String COLUMN_CONF_TUNNEL_NAMESERVER = "tunnel_nameserver";
+ static public final String COLUMN_CONF_TOP_DOMAIN = "top_domain";
+ static public final String COLUMN_CONF_PASSWORD = "password";
+ static public final String COLUMN_CONF_NAMESERVER_MODE = "nameserver_mode";
+ static public final String COLUMN_CONF_NAMESERVER = "nameserver";
+ static public final String COLUMN_CONF_RAW_MODE = "raw_mode";
+ static public final String COLUMN_CONF_LAZY_MODE = "lazy_mode";
+ static public final String COLUMN_CONF_DEFAULT_ROUTE = "default_route";
+ static public final String COLUMN_CONF_REQUEST_TYPE = "request_type";
+
+ private static final String createStmt = "CREATE TABLE " + TABLE_NAME_CONF + " (" + //
+ COLUMN_CONF_ID + " INTEGER PRIMARY KEY," + //
+ COLUMN_CONF_NAME + " TEXT," + //
+ COLUMN_CONF_LAST_USED + " INTEGER," + //
+ COLUMN_CONF_TUNNEL_NAMESERVER + " TEXT," + //
+ COLUMN_CONF_TOP_DOMAIN + " TEXT," + //
+ COLUMN_CONF_PASSWORD + " TEXT," + //
+ COLUMN_CONF_NAMESERVER_MODE + " TEXT," + //
+ COLUMN_CONF_NAMESERVER + " TEXT," + //
+ COLUMN_CONF_RAW_MODE + " INTEGER," + // Boolean stored as 1=true / 0=false
+ COLUMN_CONF_LAZY_MODE + " INTEGER," + //
+ COLUMN_CONF_DEFAULT_ROUTE + " INTEGER," + //
+ COLUMN_CONF_REQUEST_TYPE + " TEXT" + //
+ ");";
+
+ public ConfigDatabase(Context context) {
+ super(context, DATABASE_NAME, null, DATABASE_VERSION);
+ }
+
+ @Override
+ public void onCreate(SQLiteDatabase db) {
+ db.execSQL(createStmt);
+ }
+
+ @Override
+ public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+ }
+
+ public void insert(ContentValues config) throws SQLException {
+ if (config.getAsLong(COLUMN_CONF_ID) != null)
+ throw new SQLException("id must be null for update");
+ SQLiteDatabase writableDatabase = getWritableDatabase();
+ long id = writableDatabase.insertOrThrow(TABLE_NAME_CONF, null, config);
+ writableDatabase.close();
+ config.put(COLUMN_CONF_ID, id);
+
+ Log.d(TAG, "Insert id=" + id);
+ }
+
+ public int update(ContentValues config) throws SQLException {
+ if (config.getAsLong(COLUMN_CONF_ID) == null)
+ throw new SQLException("id must NOT be null for update");
+ SQLiteDatabase writableDatabase = getWritableDatabase();
+ int rows = writableDatabase.update(TABLE_NAME_CONF, config, COLUMN_CONF_ID + " = ?",
+ new String[]{config.getAsString(COLUMN_CONF_ID)});
+ writableDatabase.close();
+ Log.d(TAG, config.toString());
+ Log.d(TAG, "Update rows=" + rows);
+ return rows;
+ }
+
+ public void delete(ContentValues config) throws SQLException {
+ if (config.getAsLong(COLUMN_CONF_ID) == null)
+ throw new SQLException("id must NOT be null for delete");
+ SQLiteDatabase writableDatabase = getWritableDatabase();
+ writableDatabase.delete(TABLE_NAME_CONF, COLUMN_CONF_ID + " = ?",
+ new String[]{config.getAsString(COLUMN_CONF_ID)});
+ writableDatabase.close();
+ }
+
+ public IodineConfiguration selectById(Long id) throws SQLException {
+ ContentValues v = new ContentValues();
+ SQLiteDatabase readableDatabase = getReadableDatabase();
+ Cursor query = readableDatabase.query(TABLE_NAME_CONF, null, COLUMN_CONF_ID + " = ?",
+ new String[]{id.toString()}, null, null, null);
+ assert query.isLast();
+ query.moveToFirst();
+ DatabaseUtils.cursorRowToContentValues(query, v);
+ Log.d(TAG, "Selected: " + v.toString());
+ return new IodineConfiguration(v);
+ }
+
+ public List<IodineConfiguration> selectAll() throws SQLException {
+ List<IodineConfiguration> configurations = new ArrayList<IodineConfiguration>();
+ SQLiteDatabase readableDatabase = getReadableDatabase();
+ Cursor query = readableDatabase.query(TABLE_NAME_CONF, null, null, null, null, null, null);
+
+ while (query.moveToNext()) {
+ ContentValues v = new ContentValues();
+ DatabaseUtils.cursorRowToContentValues(query, v);
+ configurations.add(new IodineConfiguration(v));
+ }
+ return configurations;
+ }
+
+ public void insertOrUpdate(ContentValues config) {
+ try {
+ update(config);
+ } catch (SQLException e) {
+ insert(config);
+ }
+ }
+}
diff --git a/src/org/xapek/andiodine/config/IodineConfiguration.java b/src/org/xapek/andiodine/config/IodineConfiguration.java
new file mode 100644
index 0000000..c41621b
--- /dev/null
+++ b/src/org/xapek/andiodine/config/IodineConfiguration.java
@@ -0,0 +1,127 @@
+package org.xapek.andiodine.config;
+
+import android.content.ContentValues;
+
+/**
+ * Wrapper around ContentValues in Database
+ */
+public class IodineConfiguration {
+ public static enum NameserverMode {
+ LEAVE_DEFAULT, SET_SERVER_TUNNEL_IP, SET_CUSTOM
+ }
+
+ public static enum RequestType {
+ AUTODETECT, NULL, TXT, SRV, MX, CNAME, A
+ }
+
+ private final ContentValues v;
+
+ public IodineConfiguration() {
+ v = new ContentValues();
+ }
+
+ public IodineConfiguration(ContentValues v) {
+ this.v = v;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (o instanceof IodineConfiguration) {
+ return getId() != null && getId().equals(((IodineConfiguration) o).getId());
+ } else {
+ return super.equals(o);
+ }
+ }
+
+ public Long getId() {
+ return v.getAsLong(ConfigDatabase.COLUMN_CONF_ID);
+ }
+
+ public boolean getDefaultRoute() {
+ return v.getAsInteger(ConfigDatabase.COLUMN_CONF_DEFAULT_ROUTE) == 1;
+ }
+
+ public void setDefaultRoute(boolean isDefaultRoute) {
+ v.put(ConfigDatabase.COLUMN_CONF_DEFAULT_ROUTE, isDefaultRoute ? 1 : 0);
+ }
+
+ public boolean getLazyMode() {
+ return v.getAsInteger(ConfigDatabase.COLUMN_CONF_LAZY_MODE) == 1;
+ }
+
+ public String getName() {
+ return v.getAsString(ConfigDatabase.COLUMN_CONF_NAME);
+ }
+
+ public String getNameserver() {
+ return v.getAsString(ConfigDatabase.COLUMN_CONF_NAMESERVER);
+ }
+
+ public NameserverMode getNameserverMode() {
+ return NameserverMode.valueOf(v.getAsString(ConfigDatabase.COLUMN_CONF_NAMESERVER_MODE));
+ }
+
+ public String getPassword() {
+ return v.getAsString(ConfigDatabase.COLUMN_CONF_PASSWORD);
+ }
+
+ public boolean getRawMode() {
+ return v.getAsInteger(ConfigDatabase.COLUMN_CONF_RAW_MODE) == 1;
+ }
+
+ public RequestType getRequestType() {
+ return RequestType.valueOf(v.getAsString(ConfigDatabase.COLUMN_CONF_REQUEST_TYPE));
+ }
+
+ public String getTopDomain() {
+ return v.getAsString(ConfigDatabase.COLUMN_CONF_TOP_DOMAIN);
+ }
+
+ public String getTunnelNameserver() {
+ return v.getAsString(ConfigDatabase.COLUMN_CONF_TUNNEL_NAMESERVER);
+ }
+
+ public void setLazyMode(boolean lazyMode) {
+ v.put(ConfigDatabase.COLUMN_CONF_LAZY_MODE, lazyMode ? 1 : 0);
+ }
+
+ public void setName(String name) {
+ v.put(ConfigDatabase.COLUMN_CONF_NAME, name);
+ }
+
+ public void setNameserver(String nameserver) {
+ v.put(ConfigDatabase.COLUMN_CONF_NAMESERVER, nameserver);
+ }
+
+ public void setNameserverMode(NameserverMode nameserverMode) {
+ v.put(ConfigDatabase.COLUMN_CONF_NAMESERVER_MODE, nameserverMode.name());
+ }
+
+ public void setPassword(String password) {
+ v.put(ConfigDatabase.COLUMN_CONF_PASSWORD, password);
+ }
+
+ public void setRawMode(boolean rawMode) {
+ v.put(ConfigDatabase.COLUMN_CONF_RAW_MODE, rawMode ? 1 : 0);
+ }
+
+ public void setRequestType(RequestType requestType) {
+ v.put(ConfigDatabase.COLUMN_CONF_REQUEST_TYPE, requestType.name());
+ }
+
+ public void setTopDomain(String topDomain) {
+ v.put(ConfigDatabase.COLUMN_CONF_TOP_DOMAIN, topDomain);
+ }
+
+ public void setTunnelNameserver(String tunnelNameserver) {
+ v.put(ConfigDatabase.COLUMN_CONF_TUNNEL_NAMESERVER, tunnelNameserver);
+ }
+
+ public void setId(Long id) {
+ v.put(ConfigDatabase.COLUMN_CONF_ID, id);
+ }
+
+ public ContentValues getContentValues() {
+ return v;
+ }
+}
diff --git a/src/org/xapek/andiodine/preferences/AbstractPreference.java b/src/org/xapek/andiodine/preferences/AbstractPreference.java
new file mode 100644
index 0000000..278de63
--- /dev/null
+++ b/src/org/xapek/andiodine/preferences/AbstractPreference.java
@@ -0,0 +1,49 @@
+package org.xapek.andiodine.preferences;
+
+import android.content.Context;
+import android.util.Log;
+import android.view.View;
+
+abstract class AbstractPreference {
+ public static final String TAG = "Preference";
+ private final String mKey;
+ private final PreferenceActivity mPreferenceActivity;
+ private final String mTitle;
+ private final int mHelpMsgId;
+
+ public AbstractPreference(PreferenceActivity preferenceActivity, String title, int helpResId, String key) {
+ mPreferenceActivity = preferenceActivity;
+ mTitle = title;
+ mHelpMsgId = helpResId;
+ mKey = key;
+ }
+
+ protected abstract View getListItemView(Context context);
+
+ public void persist(final String value) {
+ Log.d(TAG, String.format("persist String %s -> %s", mKey, value));
+ mPreferenceActivity.getContentValues().put(mKey, value);
+ }
+
+ public void persist(final boolean value) {
+ Log.d(TAG, String.format("persist boolean %s -> %s", mKey, "" + value));
+ mPreferenceActivity.getContentValues().put(mKey, value ? 1 : 0);
+ }
+
+ public boolean getAsBoolean() {
+ return mPreferenceActivity.getContentValues().getAsInteger(mKey) != null
+ && mPreferenceActivity.getContentValues().getAsInteger(mKey) == 1;
+ }
+
+ public String getAsString() {
+ return mPreferenceActivity.getContentValues().getAsString(mKey);
+ }
+
+ public String getTitle() {
+ return mTitle;
+ }
+
+ public String getMessage() {
+ return mPreferenceActivity.getResources().getString(mHelpMsgId);
+ }
+}
diff --git a/src/org/xapek/andiodine/preferences/BooleanPreference.java b/src/org/xapek/andiodine/preferences/BooleanPreference.java
new file mode 100644
index 0000000..9e7917d
--- /dev/null
+++ b/src/org/xapek/andiodine/preferences/BooleanPreference.java
@@ -0,0 +1,33 @@
+package org.xapek.andiodine.preferences;
+
+import android.content.Context;
+import android.util.Log;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.CompoundButton.OnCheckedChangeListener;
+
+import org.xapek.andiodine.R;
+
+public class BooleanPreference extends AbstractPreference {
+
+ public BooleanPreference(PreferenceActivity preferenceActivity, String title, int helpMsgId, String key) {
+ super(preferenceActivity, title, helpMsgId, key);
+ }
+
+ @Override
+ protected View getListItemView(Context context) {
+ CheckBox view = new CheckBox(context);
+ view.setText(context.getString(R.string.enable) + " " + getTitle());
+ Log.d(TAG, "Status: " + getTitle() + " = " + getAsBoolean());
+ view.setChecked(getAsBoolean());
+ view.setOnCheckedChangeListener(new OnCheckedChangeListener() {
+ @Override
+ public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+ persist(isChecked);
+ }
+ });
+ return view;
+ }
+
+}
diff --git a/src/org/xapek/andiodine/preferences/PreferenceActivity.java b/src/org/xapek/andiodine/preferences/PreferenceActivity.java
new file mode 100644
index 0000000..dd0faa4
--- /dev/null
+++ b/src/org/xapek/andiodine/preferences/PreferenceActivity.java
@@ -0,0 +1,104 @@
+package org.xapek.andiodine.preferences;
+
+import android.app.AlertDialog;
+import android.app.ListActivity;
+import android.content.ContentValues;
+import android.content.Context;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.ImageButton;
+import android.widget.LinearLayout;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import org.xapek.andiodine.R;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class PreferenceActivity extends ListActivity {
+ private ArrayList<AbstractPreference> mPreferences;
+
+ private ContentValues mContentValues = new ContentValues();
+
+ private static class DialogPreferenceAdapter extends ArrayAdapter<AbstractPreference> {
+
+ private final LayoutInflater mInflater;
+
+ private static class HelpOnClickListener implements OnClickListener {
+ private final AbstractPreference p;
+
+ public HelpOnClickListener(AbstractPreference p) {
+ this.p = p;
+ }
+
+ @Override
+ public void onClick(View v) {
+ new AlertDialog.Builder(v.getContext())//
+ .setTitle(p.getTitle())//
+ .setMessage(p.getMessage())//
+ .create().show();
+ }
+ }
+
+ public DialogPreferenceAdapter(Context context, List<AbstractPreference> preferences) {
+ super(context, -1, preferences);
+ mInflater = (LayoutInflater) getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+
+ }
+
+ @Override
+ public View getView(int position, View convertView, ViewGroup parent) {
+ AbstractPreference item = getItem(position);
+ View rowView = mInflater.inflate(R.layout.rowlayout, parent, false);
+ LinearLayout content = (LinearLayout) rowView.findViewById(R.id.rowlayout_content);
+ ImageButton helpButton = (ImageButton) rowView.findViewById(R.id.rowlayout_help);
+ TextView title = (TextView) rowView.findViewById(R.id.rowlayout_title);
+
+ content.addView(item.getListItemView(getContext()));
+ helpButton.setOnClickListener(new HelpOnClickListener(item));
+ title.setText(item.getTitle());
+
+ return rowView;
+ }
+ }
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ mPreferences = new ArrayList<AbstractPreference>();
+
+ setListAdapter(new DialogPreferenceAdapter(this, mPreferences));
+ }
+
+ public void setContentValues(final ContentValues contentValues) {
+ mContentValues = contentValues;
+ }
+
+ public ContentValues getContentValues() {
+ return mContentValues;
+ }
+
+ public void addPreference(String key, String title, int helpMsgId, String defaultValue) {
+ if (mContentValues.get(key) == null)
+ mContentValues.put(key, defaultValue);
+ mPreferences.add(new TextPreference(this, title, helpMsgId, key));
+ }
+
+ public void addPreference(String key, String title, int helpMsgId, boolean defaultValue) {
+ BooleanPreference preference = new BooleanPreference(this, title, helpMsgId, key);
+ if (mContentValues.get(key) == null)
+ preference.persist(defaultValue);
+ mPreferences.add(preference);
+ }
+
+ public void addPreference(String key, String title, int helpMsgId, String[] values, String defaultValue) {
+ if (mContentValues.get(key) == null)
+ mContentValues.put(key, defaultValue);
+ mPreferences.add(new SpinnerPreference(this, key, title, helpMsgId, values));
+ }
+}
diff --git a/src/org/xapek/andiodine/preferences/SpinnerPreference.java b/src/org/xapek/andiodine/preferences/SpinnerPreference.java
new file mode 100644
index 0000000..3528f05
--- /dev/null
+++ b/src/org/xapek/andiodine/preferences/SpinnerPreference.java
@@ -0,0 +1,47 @@
+package org.xapek.andiodine.preferences;
+
+import android.content.Context;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemSelectedListener;
+import android.widget.ArrayAdapter;
+import android.widget.Spinner;
+
+public class SpinnerPreference extends AbstractPreference {
+ private final String[] mValues;
+
+ public SpinnerPreference(PreferenceActivity preferenceActivity, String key, String title, int helpResId,
+ String[] values) {
+ super(preferenceActivity, title, helpResId, key);
+ mValues = values;
+ }
+
+ @Override
+ protected View getListItemView(Context context) {
+ Spinner view = new Spinner(context);
+ view.setAdapter(new ArrayAdapter<String>(context, android.R.layout.simple_list_item_1, mValues));
+
+ int i = 0;
+ for (final String value : mValues) {
+ if (value != null && value.equals(getAsString())) {
+ view.setSelection(i);
+ break;
+ }
+ i++;
+ }
+
+ view.setOnItemSelectedListener(new OnItemSelectedListener() {
+ @Override
+ public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
+ String item = mValues[position];
+ persist(item);
+ }
+
+ @Override
+ public void onNothingSelected(AdapterView<?> parent) {
+ }
+ });
+
+ return view;
+ }
+}
diff --git a/src/org/xapek/andiodine/preferences/TextPreference.java b/src/org/xapek/andiodine/preferences/TextPreference.java
new file mode 100644
index 0000000..ae28f1e
--- /dev/null
+++ b/src/org/xapek/andiodine/preferences/TextPreference.java
@@ -0,0 +1,35 @@
+package org.xapek.andiodine.preferences;
+
+import android.content.Context;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.View;
+import android.widget.EditText;
+
+public class TextPreference extends AbstractPreference {
+ public TextPreference(PreferenceActivity preferenceActivity, String title, int helpMsgId, String key) {
+ super(preferenceActivity, title, helpMsgId, key);
+ }
+
+ @Override
+ protected View getListItemView(Context context) {
+ final EditText view = new EditText(context);
+ view.setSingleLine();
+ view.setText(getAsString());
+ view.addTextChangedListener(new TextWatcher() {
+ @Override
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ }
+
+ @Override
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+ }
+
+ @Override
+ public void afterTextChanged(Editable s) {
+ persist(s.toString());
+ }
+ });
+ return view;
+ }
+}