summaryrefslogtreecommitdiffhomepage
path: root/app/src/main/java/com/wireguard/android
diff options
context:
space:
mode:
Diffstat (limited to 'app/src/main/java/com/wireguard/android')
-rw-r--r--app/src/main/java/com/wireguard/android/ObservableMapAdapter.java111
-rw-r--r--app/src/main/java/com/wireguard/android/ObservableSortedMap.java12
-rw-r--r--app/src/main/java/com/wireguard/android/ObservableTreeMap.java67
3 files changed, 190 insertions, 0 deletions
diff --git a/app/src/main/java/com/wireguard/android/ObservableMapAdapter.java b/app/src/main/java/com/wireguard/android/ObservableMapAdapter.java
new file mode 100644
index 00000000..d13b2b94
--- /dev/null
+++ b/app/src/main/java/com/wireguard/android/ObservableMapAdapter.java
@@ -0,0 +1,111 @@
+package com.wireguard.android;
+
+import android.content.Context;
+import android.databinding.DataBindingUtil;
+import android.databinding.ObservableMap;
+import android.databinding.ViewDataBinding;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ListAdapter;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Collections;
+
+/**
+ * A generic ListAdapter backed by a TreeMap that adds observability.
+ */
+
+class ObservableMapAdapter<K extends Comparable<K>, V> extends BaseAdapter implements ListAdapter {
+ private ArrayList<K> keys;
+ private final int layoutId;
+ private final LayoutInflater layoutInflater;
+ private ObservableSortedMap<K, V> map;
+ private final OnMapChangedCallback<K, V> callback = new OnMapChangedCallback<>(this);
+
+ ObservableMapAdapter(final Context context, final int layoutId,
+ final ObservableSortedMap<K, V> map) {
+ layoutInflater = LayoutInflater.from(context);
+ this.layoutId = layoutId;
+ setMap(map);
+ }
+
+ @Override
+ public int getCount() {
+ return map != null ? map.size() : 0;
+ }
+
+ @Override
+ public V getItem(final int position) {
+ if (map == null || position < 0 || position >= map.size())
+ return null;
+ return map.get(getKeys().get(position));
+ }
+
+ @Override
+ public long getItemId(final int position) {
+ if (map == null || position < 0 || position >= map.size())
+ return -1;
+ return getKeys().get(position).hashCode();
+ }
+
+ public int getItemPosition(final K key) {
+ if (map == null)
+ return -1;
+ return Collections.binarySearch(getKeys(), key);
+ }
+
+ private ArrayList<K> getKeys() {
+ if (keys == null)
+ keys = new ArrayList<>(map.keySet());
+ return keys;
+ }
+
+ @Override
+ public View getView(final int position, final View convertView, final ViewGroup parent) {
+ ViewDataBinding binding = DataBindingUtil.getBinding(convertView);
+ if (binding == null)
+ binding = DataBindingUtil.inflate(layoutInflater, layoutId, parent, false);
+ binding.setVariable(BR.item, getItem(position));
+ binding.executePendingBindings();
+ return binding.getRoot();
+ }
+
+ @Override
+ public boolean hasStableIds() {
+ return true;
+ }
+
+ public void setMap(final ObservableSortedMap<K, V> newMap) {
+ if (map != null)
+ map.removeOnMapChangedCallback(callback);
+ keys = null;
+ map = newMap;
+ if (map != null) {
+ map.addOnMapChangedCallback(callback);
+ }
+ }
+
+ private static class OnMapChangedCallback<K extends Comparable<K>, V>
+ extends ObservableMap.OnMapChangedCallback<ObservableSortedMap<K, V>, K, V> {
+
+ private final WeakReference<ObservableMapAdapter<K, V>> weakAdapter;
+
+ private OnMapChangedCallback(final ObservableMapAdapter<K, V> adapter) {
+ weakAdapter = new WeakReference<>(adapter);
+ }
+
+ @Override
+ public void onMapChanged(final ObservableSortedMap<K, V> sender, final K key) {
+ final ObservableMapAdapter<K, V> adapter = weakAdapter.get();
+ if (adapter != null) {
+ adapter.keys = null;
+ adapter.notifyDataSetChanged();
+ } else {
+ sender.removeOnMapChangedCallback(this);
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/wireguard/android/ObservableSortedMap.java b/app/src/main/java/com/wireguard/android/ObservableSortedMap.java
new file mode 100644
index 00000000..8a642476
--- /dev/null
+++ b/app/src/main/java/com/wireguard/android/ObservableSortedMap.java
@@ -0,0 +1,12 @@
+package com.wireguard.android;
+
+import android.databinding.ObservableMap;
+
+import java.util.SortedMap;
+
+/**
+ * Interface for maps that are both observable and sorted.
+ */
+
+public interface ObservableSortedMap<K, V> extends ObservableMap<K, V>, SortedMap<K, V> {
+}
diff --git a/app/src/main/java/com/wireguard/android/ObservableTreeMap.java b/app/src/main/java/com/wireguard/android/ObservableTreeMap.java
new file mode 100644
index 00000000..b0444d66
--- /dev/null
+++ b/app/src/main/java/com/wireguard/android/ObservableTreeMap.java
@@ -0,0 +1,67 @@
+package com.wireguard.android;
+
+import android.databinding.MapChangeRegistry;
+import android.databinding.ObservableMap;
+import android.support.annotation.NonNull;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * Observable version of a TreeMap. Only notifies for changes made through methods, not iterators or
+ * views. This behavior is in line with that of ObservableArrayMap.
+ */
+
+public class ObservableTreeMap<K, V> extends TreeMap<K, V> implements ObservableSortedMap<K, V> {
+ private transient MapChangeRegistry listeners;
+
+ @Override
+ public void clear() {
+ super.clear();
+ notifyChange(null);
+ }
+
+ @Override
+ public void addOnMapChangedCallback(
+ final OnMapChangedCallback<? extends ObservableMap<K, V>, K, V> listener) {
+ if (listeners == null)
+ listeners = new MapChangeRegistry();
+ listeners.add(listener);
+ }
+
+ private void notifyChange(final K key) {
+ if (listeners != null)
+ listeners.notifyChange(this, key);
+ }
+
+ @Override
+ public V put(final K key, final V value) {
+ final V oldValue = super.put(key, value);
+ notifyChange(key);
+ return oldValue;
+ }
+
+ @Override
+ public void putAll(@NonNull final Map<? extends K, ? extends V> map) {
+ super.putAll(map);
+ for (final K key : map.keySet())
+ notifyChange(key);
+ }
+
+ @Override
+ public V remove(final Object key) {
+ final V oldValue = super.remove(key);
+ @SuppressWarnings("unchecked")
+ final K k = (K) key;
+ notifyChange(k);
+ return oldValue;
+ }
+
+ @Override
+ public void removeOnMapChangedCallback(
+ final OnMapChangedCallback<? extends ObservableMap<K, V>, K, V> listener) {
+ if (listeners != null)
+ listeners.remove(listener);
+ }
+}