Version bump

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>

app/build.gradle

@@ -20,8 +20,8 @@ android {
         applicationId 'com.wireguard.android'
         minSdkVersion 21
         targetSdkVersion 27
-        versionCode 414
-        versionName '0.0.20180521'
+        versionCode 419
+        versionName '0.0.20180529'
     }
     externalNativeBuild {
         cmake {
@@ -33,7 +33,6 @@ ext {
     databindingVersion = '3.1.2'
     supportLibsVersion = '27.1.1'
     daggerVersion = '2.14.1'
-    fabLibVersion = '1.10.1'
     streamsupportVersion = '1.6.0'
 }
 
@@ -45,8 +44,12 @@ dependencies {
     implementation "com.android.support:design:$supportLibsVersion"
     implementation "com.android.support:preference-v14:$supportLibsVersion"
     implementation "com.android.support:support-annotations:$supportLibsVersion"
-    implementation "com.getbase:floatingactionbutton:$fabLibVersion"
     implementation "com.google.dagger:dagger:$daggerVersion"
     implementation "net.sourceforge.streamsupport:android-retrofuture:$streamsupportVersion"
     implementation "net.sourceforge.streamsupport:android-retrostreams:$streamsupportVersion"
 }
+
+tasks.withType(JavaCompile) {
+    options.compilerArgs << '-Xlint:unchecked'
+    options.deprecation = true
+}

app/src/main/AndroidManifest.xml

@@ -62,9 +62,6 @@
             <intent-filter>
                 <action android:name="android.net.VpnService" />
             </intent-filter>
-            <meta-data
-                android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
-                android:value="false" />
         </service>
 
         <service

app/src/main/java/com/wireguard/android/BootShutdownReceiver.java

@@ -11,6 +11,7 @@ import android.content.Context;
 import android.content.Intent;
 import android.util.Log;
 
+import com.wireguard.android.backend.WgQuickBackend;
 import com.wireguard.android.model.TunnelManager;
 import com.wireguard.android.util.ExceptionLoggers;
 
@@ -19,13 +20,16 @@ public class BootShutdownReceiver extends BroadcastReceiver {
 
     @Override
     public void onReceive(final Context context, final Intent intent) {
+        if (Application.getComponent().getBackendType() != WgQuickBackend.class) {
+            return;
+        }
         final String action = intent.getAction();
         if (action == null)
             return;
         final TunnelManager tunnelManager = Application.getComponent().getTunnelManager();
         if (Intent.ACTION_BOOT_COMPLETED.equals(action)) {
             Log.i(TAG, "Broadcast receiver restoring state (boot)");
-            tunnelManager.restoreState().whenComplete(ExceptionLoggers.D);
+            tunnelManager.restoreState(false).whenComplete(ExceptionLoggers.D);
         } else if (Intent.ACTION_SHUTDOWN.equals(action)) {
             Log.i(TAG, "Broadcast receiver saving state (shutdown)");
             tunnelManager.saveState();

app/src/main/java/com/wireguard/android/activity/SettingsActivity.java

@@ -94,9 +94,10 @@ public class SettingsActivity extends AppCompatActivity {
         public void onCreatePreferences(final Bundle savedInstanceState, final String key) {
             addPreferencesFromResource(R.xml.preferences);
             if (Application.getComponent().getBackendType() != WgQuickBackend.class) {
-                final Preference toolsInstaller =
-                        getPreferenceManager().findPreference("tools_installer");
-                getPreferenceScreen().removePreference(toolsInstaller);
+                Preference pref = getPreferenceManager().findPreference("tools_installer");
+                getPreferenceScreen().removePreference(pref);
+                pref = getPreferenceManager().findPreference("restore_on_boot");
+                getPreferenceScreen().removePreference(pref);
             }
         }
     }

app/src/main/java/com/wireguard/android/backend/GoBackend.java

@@ -6,6 +6,7 @@
 
 package com.wireguard.android.backend;
 
+import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
 import android.os.ParcelFileDescriptor;
@@ -13,9 +14,12 @@ import android.support.v4.util.ArraySet;
 import android.util.Log;
 
 import com.wireguard.android.Application;
+import com.wireguard.android.activity.MainActivity;
 import com.wireguard.android.model.Tunnel;
 import com.wireguard.android.model.Tunnel.State;
 import com.wireguard.android.model.Tunnel.Statistics;
+import com.wireguard.android.util.ExceptionLoggers;
+import com.wireguard.android.util.SharedLibraryLoader;
 import com.wireguard.config.Config;
 import com.wireguard.config.IPCidr;
 import com.wireguard.config.Interface;
@@ -35,15 +39,12 @@ public final class GoBackend implements Backend {
     private static final String TAG = "WireGuard/" + GoBackend.class.getSimpleName();
     private static CompletableFuture<VpnService> vpnService = new CompletableFuture<>();
 
-    static {
-        System.loadLibrary("wg-go");
-    }
-
     private final Context context;
     private Tunnel currentTunnel;
     private int currentTunnelHandle = -1;
 
     public GoBackend(final Context context) {
+        SharedLibraryLoader.loadSharedLibrary(context, "wg-go");
         this.context = context;
     }
 
@@ -158,6 +159,10 @@ public final class GoBackend implements Backend {
             final VpnService.Builder builder = service.getBuilder();
             builder.setSession(tunnel.getName());
 
+            final Intent configureIntent = new Intent(context, MainActivity.class);
+            configureIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            builder.setConfigureIntent(PendingIntent.getActivity(context, 0, configureIntent, 0));
+
             for (final IPCidr addr : config.getInterface().getAddresses())
                 builder.addAddress(addr.getAddress(), addr.getCidr());
 
@@ -202,6 +207,7 @@ public final class GoBackend implements Backend {
     }
 
     private void startVpnService() {
+        Log.d(TAG, "Requesting to start VpnService");
         context.startService(new Intent(context, VpnService.class));
     }
 
@@ -225,5 +231,15 @@ public final class GoBackend implements Backend {
             vpnService = vpnService.newIncompleteFuture();
             super.onDestroy();
         }
+
+        @Override
+        public int onStartCommand(Intent intent, int flags, int startId) {
+            vpnService.complete(this);
+            if (intent == null || intent.getComponent() == null || !intent.getComponent().getPackageName().equals(getPackageName())) {
+                Log.d(TAG, "Service started by Always-on VPN feature");
+                Application.getComponent().getTunnelManager().restoreState(true).whenComplete(ExceptionLoggers.D);
+            }
+            return super.onStartCommand(intent, flags, startId);
+        }
     }
 }

app/src/main/java/com/wireguard/android/fragment/TunnelEditorFragment.java

@@ -169,6 +169,7 @@ public class TunnelEditorFragment extends BaseFragment {
             tunnel = newTunnel;
             message = getString(R.string.tunnel_create_success, tunnel.getName());
             Log.d(TAG, message);
+            Toast.makeText(getContext(), message, Toast.LENGTH_SHORT).show();
             onFinished();
         } else {
             final String error = ExceptionLoggers.unwrapMessage(throwable);

app/src/main/java/com/wireguard/android/model/TunnelManager.java

@@ -24,6 +24,7 @@ import com.wireguard.android.util.ObservableSortedKeyedArrayList;
 import com.wireguard.android.util.ObservableSortedKeyedList;
 import com.wireguard.config.Config;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.Set;
@@ -55,6 +56,8 @@ public final class TunnelManager extends BaseObservable {
     private final ObservableSortedKeyedList<String, Tunnel> tunnels =
             new ObservableSortedKeyedArrayList<>(COMPARATOR);
     private Tunnel lastUsedTunnel;
+    private boolean haveLoaded;
+    private ArrayList<CompletableFuture<Void>> delayedLoadRestoreTunnels = new ArrayList<>();
 
     @Inject
     public TunnelManager(final AsyncWorker asyncWorker, final Backend backend,
@@ -140,12 +143,27 @@ public final class TunnelManager extends BaseObservable {
                 .whenComplete(ExceptionLoggers.E);
     }
 
+    @SuppressWarnings("unchecked")
     private void onTunnelsLoaded(final Iterable<String> present, final Collection<String> running) {
         for (final String name : present)
             addToList(name, null, running.contains(name) ? State.UP : State.DOWN);
         final String lastUsedName = preferences.getString(KEY_LAST_USED_TUNNEL, null);
         if (lastUsedName != null)
             setLastUsedTunnel(tunnels.get(lastUsedName));
+        CompletableFuture<Void> toComplete[];
+        synchronized (delayedLoadRestoreTunnels) {
+            haveLoaded = true;
+            toComplete = delayedLoadRestoreTunnels.toArray(new CompletableFuture[delayedLoadRestoreTunnels.size()]);
+            delayedLoadRestoreTunnels.clear();
+        }
+        restoreState(true).whenComplete((v, t) -> {
+            for (final CompletableFuture<Void> f : toComplete) {
+                if (t == null)
+                    f.complete(v);
+                else
+                    f.completeExceptionally(t);
+            }
+        });
     }
 
     public void refreshTunnelStates() {
@@ -157,9 +175,16 @@ public final class TunnelManager extends BaseObservable {
                 .whenComplete(ExceptionLoggers.E);
     }
 
-    public CompletionStage<Void> restoreState() {
-        if (!preferences.getBoolean(KEY_RESTORE_ON_BOOT, false))
+    public CompletionStage<Void> restoreState(boolean force) {
+        if (!force && !preferences.getBoolean(KEY_RESTORE_ON_BOOT, false))
             return CompletableFuture.completedFuture(null);
+        synchronized (delayedLoadRestoreTunnels) {
+            if (!haveLoaded) {
+                CompletableFuture<Void> f = new CompletableFuture<>();
+                delayedLoadRestoreTunnels.add(f);
+                return f;
+            }
+        }
         final Set<String> previouslyRunning = preferences.getStringSet(KEY_RUNNING_TUNNELS, null);
         if (previouslyRunning == null)
             return CompletableFuture.completedFuture(null);
@@ -236,6 +261,7 @@ public final class TunnelManager extends BaseObservable {
             tunnel.onStateChanged(e == null ? newState : tunnel.getState());
             if (e == null && newState == State.UP)
                 setLastUsedTunnel(tunnel);
+            saveState();
         });
     }
 }

app/src/main/java/com/wireguard/android/util/SharedLibraryLoader.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright © 2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+package com.wireguard.android.util;
+
+import android.content.Context;
+import android.os.Build;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipEntry;
+
+public final class SharedLibraryLoader {
+    private static final String TAG = "WireGuard/" + SharedLibraryLoader.class.getSimpleName();
+
+    private SharedLibraryLoader() {
+    }
+
+    public static final void loadSharedLibrary(final Context context, final String libName) {
+        Throwable noAbiException;
+        try {
+            System.loadLibrary(libName);
+            return;
+        } catch (UnsatisfiedLinkError e) {
+            Log.d(TAG, "Failed to load library normally, so attempting to extract from apk", e);
+            noAbiException = e;
+        }
+
+        final ZipFile zipFile;
+        try {
+            zipFile = new ZipFile(new File(context.getApplicationInfo().sourceDir), ZipFile.OPEN_READ);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        final String mappedLibName = System.mapLibraryName(libName);
+        byte buffer[] = new byte[1024 * 32];
+        for (final String abi : Build.SUPPORTED_ABIS) {
+            final String libZipPath = "lib" + File.separatorChar + abi + File.separatorChar + mappedLibName;
+            final ZipEntry zipEntry = zipFile.getEntry(libZipPath);
+            if (zipEntry == null)
+                continue;
+            File f = null;
+            try {
+                f = File.createTempFile("lib", ".so", context.getCacheDir());
+                Log.d(TAG, "Extracting apk:/" + libZipPath + " to " + f.getAbsolutePath() + " and loading");
+                FileOutputStream out = new FileOutputStream(f);
+                InputStream in = zipFile.getInputStream(zipEntry);
+                int len;
+                while ((len = in.read(buffer)) != -1) {
+                    out.write(buffer, 0, len);
+                }
+                out.close();
+                System.load(f.getAbsolutePath());
+                return;
+            } catch (Exception e) {
+                Log.d(TAG, "Failed to load library apk:/" + libZipPath, e);
+                noAbiException = e;
+            } finally {
+                if (f != null)
+                    f.delete();
+            }
+        }
+        if (noAbiException instanceof RuntimeException)
+            throw (RuntimeException) noAbiException;
+        throw new RuntimeException(noAbiException);
+    }
+}

app/src/main/java/com/wireguard/android/widget/fab/AddFloatingActionButton.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright © 2014 Jerzy Chalupski
+ * Copyright © 2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+package com.wireguard.android.widget.fab;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Paint.Style;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.Shape;
+import android.support.annotation.ColorRes;
+import android.support.annotation.DrawableRes;
+import android.util.AttributeSet;
+
+import com.wireguard.android.R;
+
+public class AddFloatingActionButton extends FloatingActionButton {
+    int mPlusColor;
+
+    public AddFloatingActionButton(final Context context) {
+        this(context, null);
+    }
+
+    public AddFloatingActionButton(final Context context, final AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public AddFloatingActionButton(final Context context, final AttributeSet attrs, final int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    void init(final Context context, final AttributeSet attributeSet) {
+        final TypedArray attr = context.obtainStyledAttributes(attributeSet, R.styleable.AddFloatingActionButton, 0, 0);
+        mPlusColor = attr.getColor(R.styleable.AddFloatingActionButton_fab_plusIconColor, getColor(android.R.color.white));
+        attr.recycle();
+
+        super.init(context, attributeSet);
+    }
+
+    /**
+     * @return the current Color of plus icon.
+     */
+    public int getPlusColor() {
+        return mPlusColor;
+    }
+
+    public void setPlusColor(final int color) {
+        if (mPlusColor != color) {
+            mPlusColor = color;
+            updateBackground();
+        }
+    }
+
+    public void setPlusColorResId(@ColorRes int plusColor) {
+        setPlusColor(getColor(plusColor));
+    }
+
+    @Override
+    public void setIcon(@DrawableRes final int icon) {
+        throw new UnsupportedOperationException("Use FloatingActionButton if you want to use custom icon");
+    }
+
+    @Override
+    Drawable getIconDrawable() {
+        final float iconSize = getDimension(R.dimen.fab_icon_size);
+        final float iconHalfSize = iconSize / 2f;
+
+        final float plusSize = getDimension(R.dimen.fab_plus_icon_size);
+        final float plusHalfStroke = getDimension(R.dimen.fab_plus_icon_stroke) / 2f;
+        final float plusOffset = (iconSize - plusSize) / 2f;
+
+        final Shape shape = new Shape() {
+            @Override
+            public void draw(final Canvas canvas, final Paint paint) {
+                canvas.drawRect(plusOffset, iconHalfSize - plusHalfStroke, iconSize - plusOffset, iconHalfSize + plusHalfStroke, paint);
+                canvas.drawRect(iconHalfSize - plusHalfStroke, plusOffset, iconHalfSize + plusHalfStroke, iconSize - plusOffset, paint);
+            }
+        };
+
+        final ShapeDrawable drawable = new ShapeDrawable(shape);
+
+        final Paint paint = drawable.getPaint();
+        paint.setColor(mPlusColor);
+        paint.setStyle(Style.FILL);
+        paint.setAntiAlias(true);
+
+        return drawable;
+    }
+}

app/src/main/java/com/wireguard/android/widget/fab/FloatingActionButton.java

@@ -0,0 +1,409 @@
+/*
+ * Copyright © 2014 Jerzy Chalupski
+ * Copyright © 2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+package com.wireguard.android.widget.fab;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.*;
+import android.graphics.Paint.Style;
+import android.graphics.Shader.TileMode;
+import android.graphics.drawable.*;
+import android.graphics.drawable.ShapeDrawable.ShaderFactory;
+import android.graphics.drawable.shapes.OvalShape;
+import android.support.annotation.*;
+import android.support.v7.widget.AppCompatImageButton;
+import android.util.AttributeSet;
+import android.widget.TextView;
+
+import com.wireguard.android.R;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class FloatingActionButton extends AppCompatImageButton {
+
+    public static final int SIZE_NORMAL = 0;
+    public static final int SIZE_MINI = 1;
+    int mColorNormal;
+    int mColorPressed;
+    int mColorDisabled;
+    String mTitle;
+    boolean mStrokeVisible;
+    @DrawableRes
+    private int mIcon;
+    private Drawable mIconDrawable;
+    private int mSize;
+
+    private float mCircleSize;
+    private float mShadowRadius;
+    private float mShadowOffset;
+    private int mDrawableSize;
+    public FloatingActionButton(final Context context) {
+        this(context, null);
+    }
+
+    public FloatingActionButton(final Context context, final AttributeSet attrs) {
+        super(context, attrs);
+        init(context, attrs);
+    }
+
+    public FloatingActionButton(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init(context, attrs);
+    }
+
+    void init(final Context context, final AttributeSet attributeSet) {
+        final TypedArray attr = context.obtainStyledAttributes(attributeSet, R.styleable.FloatingActionButton, 0, 0);
+        mColorNormal = attr.getColor(R.styleable.FloatingActionButton_fab_colorNormal, getColor(android.R.color.holo_blue_dark));
+        mColorPressed = attr.getColor(R.styleable.FloatingActionButton_fab_colorPressed, getColor(android.R.color.holo_blue_light));
+        mColorDisabled = attr.getColor(R.styleable.FloatingActionButton_fab_colorDisabled, getColor(android.R.color.darker_gray));
+        mSize = attr.getInt(R.styleable.FloatingActionButton_fab_size, SIZE_NORMAL);
+        mIcon = attr.getResourceId(R.styleable.FloatingActionButton_fab_icon, 0);
+        mTitle = attr.getString(R.styleable.FloatingActionButton_fab_title);
+        mStrokeVisible = attr.getBoolean(R.styleable.FloatingActionButton_fab_stroke_visible, true);
+        attr.recycle();
+
+        updateCircleSize();
+        mShadowRadius = getDimension(R.dimen.fab_shadow_radius);
+        mShadowOffset = getDimension(R.dimen.fab_shadow_offset);
+        updateDrawableSize();
+
+        updateBackground();
+    }
+
+    private void updateDrawableSize() {
+        mDrawableSize = (int) (mCircleSize + 2 * mShadowRadius);
+    }
+
+    private void updateCircleSize() {
+        mCircleSize = getDimension(mSize == SIZE_NORMAL ? R.dimen.fab_size_normal : R.dimen.fab_size_mini);
+    }
+
+    @FAB_SIZE
+    public int getSize() {
+        return mSize;
+    }
+
+    public void setSize(@FAB_SIZE final int size) {
+        if (size != SIZE_MINI && size != SIZE_NORMAL) {
+            throw new IllegalArgumentException("Use @FAB_SIZE constants only!");
+        }
+
+        if (mSize != size) {
+            mSize = size;
+            updateCircleSize();
+            updateDrawableSize();
+            updateBackground();
+        }
+    }
+
+    public void setIcon(@DrawableRes final int icon) {
+        if (mIcon != icon) {
+            mIcon = icon;
+            mIconDrawable = null;
+            updateBackground();
+        }
+    }
+
+    /**
+     * @return the current Color for normal state.
+     */
+    public int getColorNormal() {
+        return mColorNormal;
+    }
+
+    public void setColorNormal(final int color) {
+        if (mColorNormal != color) {
+            mColorNormal = color;
+            updateBackground();
+        }
+    }
+
+    public void setColorNormalResId(@ColorRes final int colorNormal) {
+        setColorNormal(getColor(colorNormal));
+    }
+
+    /**
+     * @return the current color for pressed state.
+     */
+    public int getColorPressed() {
+        return mColorPressed;
+    }
+
+    public void setColorPressed(final int color) {
+        if (mColorPressed != color) {
+            mColorPressed = color;
+            updateBackground();
+        }
+    }
+
+    public void setColorPressedResId(@ColorRes final int colorPressed) {
+        setColorPressed(getColor(colorPressed));
+    }
+
+    /**
+     * @return the current color for disabled state.
+     */
+    public int getColorDisabled() {
+        return mColorDisabled;
+    }
+
+    public void setColorDisabled(final int color) {
+        if (mColorDisabled != color) {
+            mColorDisabled = color;
+            updateBackground();
+        }
+    }
+
+    public void setColorDisabledResId(@ColorRes final int colorDisabled) {
+        setColorDisabled(getColor(colorDisabled));
+    }
+
+    public boolean isStrokeVisible() {
+        return mStrokeVisible;
+    }
+
+    public void setStrokeVisible(final boolean visible) {
+        if (mStrokeVisible != visible) {
+            mStrokeVisible = visible;
+            updateBackground();
+        }
+    }
+
+    int getColor(@ColorRes final int id) {
+        return getResources().getColor(id);
+    }
+
+    float getDimension(@DimenRes final int id) {
+        return getResources().getDimension(id);
+    }
+
+    TextView getLabelView() {
+        return (TextView) getTag(R.id.fab_label);
+    }
+
+    public String getTitle() {
+        return mTitle;
+    }
+
+    public void setTitle(final String title) {
+        mTitle = title;
+        final TextView label = getLabelView();
+        if (label != null) {
+            label.setText(title);
+        }
+    }
+
+    @Override
+    protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        setMeasuredDimension(mDrawableSize, mDrawableSize);
+    }
+
+    void updateBackground() {
+        final float strokeWidth = getDimension(R.dimen.fab_stroke_width);
+        final float halfStrokeWidth = strokeWidth / 2f;
+
+        final LayerDrawable layerDrawable = new LayerDrawable(
+                new Drawable[]{
+                        getResources().getDrawable(mSize == SIZE_NORMAL ? R.drawable.fab_bg_normal : R.drawable.fab_bg_mini, null),
+                        createFillDrawable(strokeWidth),
+                        createOuterStrokeDrawable(strokeWidth),
+                        getIconDrawable()
+                });
+
+        final int iconOffset = (int) (mCircleSize - getDimension(R.dimen.fab_icon_size)) / 2;
+
+        final int circleInsetHorizontal = (int) (mShadowRadius);
+        final int circleInsetTop = (int) (mShadowRadius - mShadowOffset);
+        final int circleInsetBottom = (int) (mShadowRadius + mShadowOffset);
+
+        layerDrawable.setLayerInset(1,
+                circleInsetHorizontal,
+                circleInsetTop,
+                circleInsetHorizontal,
+                circleInsetBottom);
+
+        layerDrawable.setLayerInset(2,
+                (int) (circleInsetHorizontal - halfStrokeWidth),
+                (int) (circleInsetTop - halfStrokeWidth),
+                (int) (circleInsetHorizontal - halfStrokeWidth),
+                (int) (circleInsetBottom - halfStrokeWidth));
+
+        layerDrawable.setLayerInset(3,
+                circleInsetHorizontal + iconOffset,
+                circleInsetTop + iconOffset,
+                circleInsetHorizontal + iconOffset,
+                circleInsetBottom + iconOffset);
+
+        setBackground(layerDrawable);
+    }
+
+    Drawable getIconDrawable() {
+        if (mIconDrawable != null) {
+            return mIconDrawable;
+        } else if (mIcon != 0) {
+            return getResources().getDrawable(mIcon, null);
+        } else {
+            return new ColorDrawable(Color.TRANSPARENT);
+        }
+    }
+
+    public void setIconDrawable(@NonNull final Drawable iconDrawable) {
+        if (mIconDrawable != iconDrawable) {
+            mIcon = 0;
+            mIconDrawable = iconDrawable;
+            updateBackground();
+        }
+    }
+
+    private StateListDrawable createFillDrawable(final float strokeWidth) {
+        final StateListDrawable drawable = new StateListDrawable();
+        drawable.addState(new int[]{-android.R.attr.state_enabled}, createCircleDrawable(mColorDisabled, strokeWidth));
+        drawable.addState(new int[]{android.R.attr.state_pressed}, createCircleDrawable(mColorPressed, strokeWidth));
+        drawable.addState(new int[]{}, createCircleDrawable(mColorNormal, strokeWidth));
+        return drawable;
+    }
+
+    private Drawable createCircleDrawable(final int color, final float strokeWidth) {
+        final int alpha = Color.alpha(color);
+        final int opaqueColor = opaque(color);
+
+        final ShapeDrawable fillDrawable = new ShapeDrawable(new OvalShape());
+
+        final Paint paint = fillDrawable.getPaint();
+        paint.setAntiAlias(true);
+        paint.setColor(opaqueColor);
+
+        final Drawable[] layers = {
+                fillDrawable,
+                createInnerStrokesDrawable(opaqueColor, strokeWidth)
+        };
+
+        final LayerDrawable drawable = alpha == 255 || !mStrokeVisible
+                ? new LayerDrawable(layers)
+                : new TranslucentLayerDrawable(alpha, layers);
+
+        final int halfStrokeWidth = (int) (strokeWidth / 2f);
+        drawable.setLayerInset(1, halfStrokeWidth, halfStrokeWidth, halfStrokeWidth, halfStrokeWidth);
+
+        return drawable;
+    }
+
+    private Drawable createOuterStrokeDrawable(final float strokeWidth) {
+        final ShapeDrawable shapeDrawable = new ShapeDrawable(new OvalShape());
+
+        final Paint paint = shapeDrawable.getPaint();
+        paint.setAntiAlias(true);
+        paint.setStrokeWidth(strokeWidth);
+        paint.setStyle(Style.STROKE);
+        paint.setColor(Color.BLACK);
+        paint.setAlpha(opacityToAlpha(0.02f));
+
+        return shapeDrawable;
+    }
+
+    private int opacityToAlpha(final float opacity) {
+        return (int) (255f * opacity);
+    }
+
+    private int darkenColor(final int argb) {
+        return adjustColorBrightness(argb, 0.9f);
+    }
+
+    private int lightenColor(final int argb) {
+        return adjustColorBrightness(argb, 1.1f);
+    }
+
+    private int adjustColorBrightness(final int argb, final float factor) {
+        final float[] hsv = new float[3];
+        Color.colorToHSV(argb, hsv);
+
+        hsv[2] = Math.min(hsv[2] * factor, 1f);
+
+        return Color.HSVToColor(Color.alpha(argb), hsv);
+    }
+
+    private int halfTransparent(final int argb) {
+        return Color.argb(
+                Color.alpha(argb) / 2,
+                Color.red(argb),
+                Color.green(argb),
+                Color.blue(argb)
+        );
+    }
+
+    private int opaque(final int argb) {
+        return Color.rgb(
+                Color.red(argb),
+                Color.green(argb),
+                Color.blue(argb)
+        );
+    }
+
+    private Drawable createInnerStrokesDrawable(final int color, final float strokeWidth) {
+        if (!mStrokeVisible) {
+            return new ColorDrawable(Color.TRANSPARENT);
+        }
+
+        final ShapeDrawable shapeDrawable = new ShapeDrawable(new OvalShape());
+
+        final int bottomStrokeColor = darkenColor(color);
+        final int bottomStrokeColorHalfTransparent = halfTransparent(bottomStrokeColor);
+        final int topStrokeColor = lightenColor(color);
+        final int topStrokeColorHalfTransparent = halfTransparent(topStrokeColor);
+
+        final Paint paint = shapeDrawable.getPaint();
+        paint.setAntiAlias(true);
+        paint.setStrokeWidth(strokeWidth);
+        paint.setStyle(Style.STROKE);
+        shapeDrawable.setShaderFactory(new ShaderFactory() {
+            @Override
+            public Shader resize(int width, int height) {
+                return new LinearGradient(width / 2, 0, width / 2, height,
+                        new int[]{topStrokeColor, topStrokeColorHalfTransparent, color, bottomStrokeColorHalfTransparent, bottomStrokeColor},
+                        new float[]{0f, 0.2f, 0.5f, 0.8f, 1f},
+                        TileMode.CLAMP
+                );
+            }
+        });
+
+        return shapeDrawable;
+    }
+
+    @Override
+    public void setVisibility(final int visibility) {
+        final TextView label = getLabelView();
+        if (label != null) {
+            label.setVisibility(visibility);
+        }
+
+        super.setVisibility(visibility);
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @IntDef({SIZE_NORMAL, SIZE_MINI})
+    public @interface FAB_SIZE {
+    }
+
+    private static class TranslucentLayerDrawable extends LayerDrawable {
+        private final int mAlpha;
+
+        public TranslucentLayerDrawable(final int alpha, final Drawable... layers) {
+            super(layers);
+            mAlpha = alpha;
+        }
+
+        @Override
+        public void draw(final Canvas canvas) {
+            final Rect bounds = getBounds();
+            canvas.saveLayerAlpha(bounds.left, bounds.top, bounds.right, bounds.bottom, mAlpha);
+            super.draw(canvas);
+            canvas.restore();
+        }
+    }
+}

app/src/main/java/com/wireguard/android/widget/fab/FloatingActionsMenu.java

@@ -0,0 +1,643 @@
+/*
+ * Copyright © 2014 Jerzy Chalupski
+ * Copyright © 2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+package com.wireguard.android.widget.fab;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.LayerDrawable;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.support.annotation.ColorRes;
+import android.support.annotation.NonNull;
+import android.util.AttributeSet;
+import android.view.ContextThemeWrapper;
+import android.view.TouchDelegate;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Interpolator;
+import android.view.animation.OvershootInterpolator;
+import android.widget.TextView;
+
+import com.wireguard.android.R;
+
+public class FloatingActionsMenu extends ViewGroup {
+    public static final int EXPAND_UP = 0;
+    public static final int EXPAND_DOWN = 1;
+    public static final int EXPAND_LEFT = 2;
+    public static final int EXPAND_RIGHT = 3;
+
+    public static final int LABELS_ON_LEFT_SIDE = 0;
+    public static final int LABELS_ON_RIGHT_SIDE = 1;
+
+    private static final int ANIMATION_DURATION = 300;
+    private static final float COLLAPSED_PLUS_ROTATION = 0f;
+    private static final float EXPANDED_PLUS_ROTATION = 90f + 45f;
+    private static final Interpolator sExpandInterpolator = new OvershootInterpolator();
+    private static final Interpolator sCollapseInterpolator = new DecelerateInterpolator(3f);
+    private static final Interpolator sAlphaExpandInterpolator = new DecelerateInterpolator();
+    private int mAddButtonPlusColor;
+    private int mAddButtonColorNormal;
+    private int mAddButtonColorPressed;
+    private int mAddButtonSize;
+    private boolean mAddButtonStrokeVisible;
+    private int mExpandDirection;
+    private int mButtonSpacing;
+    private int mLabelsMargin;
+    private int mLabelsVerticalOffset;
+    private boolean mExpanded;
+    private final AnimatorSet mExpandAnimation = new AnimatorSet().setDuration(ANIMATION_DURATION);
+    private final AnimatorSet mCollapseAnimation = new AnimatorSet().setDuration(ANIMATION_DURATION);
+    private AddFloatingActionButton mAddButton;
+    private RotatingDrawable mRotatingDrawable;
+    private int mMaxButtonWidth;
+    private int mMaxButtonHeight;
+    private int mLabelsStyle;
+    private int mLabelsPosition;
+    private int mButtonsCount;
+    private TouchDelegateGroup mTouchDelegateGroup;
+    private OnFloatingActionsMenuUpdateListener mListener;
+    private final Rect touchArea = new Rect(0, 0, 0, 0);
+
+    public FloatingActionsMenu(final Context context) {
+        this(context, null);
+    }
+
+    public FloatingActionsMenu(final Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context, attrs);
+    }
+
+    public FloatingActionsMenu(final Context context, final AttributeSet attrs, final int defStyle) {
+        super(context, attrs, defStyle);
+        init(context, attrs);
+    }
+
+    private void init(final Context context, final AttributeSet attributeSet) {
+        mButtonSpacing = (int) (getResources().getDimension(R.dimen.fab_actions_spacing) - getResources().getDimension(R.dimen.fab_shadow_radius) - getResources().getDimension(R.dimen.fab_shadow_offset));
+        mLabelsMargin = getResources().getDimensionPixelSize(R.dimen.fab_labels_margin);
+        mLabelsVerticalOffset = getResources().getDimensionPixelSize(R.dimen.fab_shadow_offset);
+
+        mTouchDelegateGroup = new TouchDelegateGroup(this);
+        setTouchDelegate(mTouchDelegateGroup);
+
+        final TypedArray attr = context.obtainStyledAttributes(attributeSet, R.styleable.FloatingActionsMenu, 0, 0);
+        mAddButtonPlusColor = attr.getColor(R.styleable.FloatingActionsMenu_fab_addButtonPlusIconColor, getColor(android.R.color.white));
+        mAddButtonColorNormal = attr.getColor(R.styleable.FloatingActionsMenu_fab_addButtonColorNormal, getColor(android.R.color.holo_blue_dark));
+        mAddButtonColorPressed = attr.getColor(R.styleable.FloatingActionsMenu_fab_addButtonColorPressed, getColor(android.R.color.holo_blue_light));
+        mAddButtonSize = attr.getInt(R.styleable.FloatingActionsMenu_fab_addButtonSize, FloatingActionButton.SIZE_NORMAL);
+        mAddButtonStrokeVisible = attr.getBoolean(R.styleable.FloatingActionsMenu_fab_addButtonStrokeVisible, true);
+        mExpandDirection = attr.getInt(R.styleable.FloatingActionsMenu_fab_expandDirection, EXPAND_UP);
+        mLabelsStyle = attr.getResourceId(R.styleable.FloatingActionsMenu_fab_labelStyle, 0);
+        mLabelsPosition = attr.getInt(R.styleable.FloatingActionsMenu_fab_labelsPosition, LABELS_ON_LEFT_SIDE);
+        attr.recycle();
+
+        if (mLabelsStyle != 0 && expandsHorizontally()) {
+            throw new IllegalStateException("Action labels in horizontal expand orientation is not supported.");
+        }
+
+        createAddButton(context);
+    }
+
+    public void setOnFloatingActionsMenuUpdateListener(final OnFloatingActionsMenuUpdateListener listener) {
+        mListener = listener;
+    }
+
+    private boolean expandsHorizontally() {
+        return mExpandDirection == EXPAND_LEFT || mExpandDirection == EXPAND_RIGHT;
+    }
+
+    private void createAddButton(final Context context) {
+        mAddButton = new AddFloatingActionButton(context) {
+            @Override
+            void updateBackground() {
+                mPlusColor = mAddButtonPlusColor;
+                mColorNormal = mAddButtonColorNormal;
+                mColorPressed = mAddButtonColorPressed;
+                mStrokeVisible = mAddButtonStrokeVisible;
+                super.updateBackground();
+            }
+
+            @Override
+            Drawable getIconDrawable() {
+                final RotatingDrawable rotatingDrawable = new RotatingDrawable(super.getIconDrawable());
+                mRotatingDrawable = rotatingDrawable;
+
+                final OvershootInterpolator interpolator = new OvershootInterpolator();
+
+                final ObjectAnimator collapseAnimator = ObjectAnimator.ofFloat(rotatingDrawable, "rotation", EXPANDED_PLUS_ROTATION, COLLAPSED_PLUS_ROTATION);
+                final ObjectAnimator expandAnimator = ObjectAnimator.ofFloat(rotatingDrawable, "rotation", COLLAPSED_PLUS_ROTATION, EXPANDED_PLUS_ROTATION);
+
+                collapseAnimator.setInterpolator(interpolator);
+                expandAnimator.setInterpolator(interpolator);
+
+                mExpandAnimation.play(expandAnimator);
+                mCollapseAnimation.play(collapseAnimator);
+
+                return rotatingDrawable;
+            }
+        };
+
+        mAddButton.setId(R.id.fab_expand_menu_button);
+        mAddButton.setSize(mAddButtonSize);
+        mAddButton.setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                toggle();
+            }
+        });
+
+        addView(mAddButton, super.generateDefaultLayoutParams());
+        mButtonsCount++;
+    }
+
+    public void addButton(final FloatingActionButton button) {
+        addView(button, mButtonsCount - 1);
+        mButtonsCount++;
+
+        if (mLabelsStyle != 0) {
+            createLabels();
+        }
+    }
+
+    public void removeButton(final FloatingActionButton button) {
+        removeView(button.getLabelView());
+        removeView(button);
+        button.setTag(R.id.fab_label, null);
+        mButtonsCount--;
+    }
+
+    private int getColor(@ColorRes final int id) {
+        return getResources().getColor(id);
+    }
+
+    @Override
+    protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
+        measureChildren(widthMeasureSpec, heightMeasureSpec);
+
+        int width = 0;
+        int height = 0;
+
+        mMaxButtonWidth = 0;
+        mMaxButtonHeight = 0;
+        int maxLabelWidth = 0;
+
+        for (int i = 0; i < mButtonsCount; i++) {
+            View child = getChildAt(i);
+
+            if (child.getVisibility() == GONE) {
+                continue;
+            }
+
+            switch (mExpandDirection) {
+                case EXPAND_UP:
+                case EXPAND_DOWN:
+                    mMaxButtonWidth = Math.max(mMaxButtonWidth, child.getMeasuredWidth());
+                    height += child.getMeasuredHeight();
+                    break;
+                case EXPAND_LEFT:
+                case EXPAND_RIGHT:
+                    width += child.getMeasuredWidth();
+                    mMaxButtonHeight = Math.max(mMaxButtonHeight, child.getMeasuredHeight());
+                    break;
+            }
+
+            if (!expandsHorizontally()) {
+                TextView label = (TextView) child.getTag(R.id.fab_label);
+                if (label != null) {
+                    maxLabelWidth = Math.max(maxLabelWidth, label.getMeasuredWidth());
+                }
+            }
+        }
+
+        if (!expandsHorizontally()) {
+            width = mMaxButtonWidth + (maxLabelWidth > 0 ? maxLabelWidth + mLabelsMargin : 0);
+        } else {
+            height = mMaxButtonHeight;
+        }
+
+        switch (mExpandDirection) {
+            case EXPAND_UP:
+            case EXPAND_DOWN:
+                height += mButtonSpacing * (mButtonsCount - 1);
+                height = adjustForOvershoot(height);
+                break;
+            case EXPAND_LEFT:
+            case EXPAND_RIGHT:
+                width += mButtonSpacing * (mButtonsCount - 1);
+                width = adjustForOvershoot(width);
+                break;
+        }
+
+        setMeasuredDimension(width, height);
+    }
+
+    private int adjustForOvershoot(final int dimension) {
+        return dimension * 12 / 10;
+    }
+
+    @Override
+    protected void onLayout(final boolean changed, final int l, final int t, final int r, final int b) {
+        switch (mExpandDirection) {
+            case EXPAND_UP:
+            case EXPAND_DOWN:
+                final boolean expandUp = mExpandDirection == EXPAND_UP;
+
+                if (changed) {
+                    mTouchDelegateGroup.clearTouchDelegates();
+                }
+
+                final int addButtonY = expandUp ? b - t - mAddButton.getMeasuredHeight() : 0;
+                // Ensure mAddButton is centered on the line where the buttons should be
+                final int buttonsHorizontalCenter = mLabelsPosition == LABELS_ON_LEFT_SIDE
+                        ? r - l - mMaxButtonWidth / 2
+                        : mMaxButtonWidth / 2;
+                final int addButtonLeft = buttonsHorizontalCenter - mAddButton.getMeasuredWidth() / 2;
+                mAddButton.layout(addButtonLeft, addButtonY, addButtonLeft + mAddButton.getMeasuredWidth(), addButtonY + mAddButton.getMeasuredHeight());
+
+                final int labelsOffset = mMaxButtonWidth / 2 + mLabelsMargin;
+                final int labelsXNearButton = mLabelsPosition == LABELS_ON_LEFT_SIDE
+                        ? buttonsHorizontalCenter - labelsOffset
+                        : buttonsHorizontalCenter + labelsOffset;
+
+                int nextY = expandUp ?
+                        addButtonY - mButtonSpacing :
+                        addButtonY + mAddButton.getMeasuredHeight() + mButtonSpacing;
+
+                for (int i = mButtonsCount - 1; i >= 0; i--) {
+                    final View child = getChildAt(i);
+
+                    if (child == mAddButton || child.getVisibility() == GONE) continue;
+
+                    final int childX = buttonsHorizontalCenter - child.getMeasuredWidth() / 2;
+                    final int childY = expandUp ? nextY - child.getMeasuredHeight() : nextY;
+                    child.layout(childX, childY, childX + child.getMeasuredWidth(), childY + child.getMeasuredHeight());
+
+                    final float collapsedTranslation = addButtonY - childY;
+                    final float expandedTranslation = 0f;
+
+                    child.setTranslationY(mExpanded ? expandedTranslation : collapsedTranslation);
+                    child.setAlpha(mExpanded ? 1f : 0f);
+
+                    LayoutParams params = (LayoutParams) child.getLayoutParams();
+                    params.mCollapseDir.setFloatValues(expandedTranslation, collapsedTranslation);
+                    params.mExpandDir.setFloatValues(collapsedTranslation, expandedTranslation);
+                    params.setAnimationsTarget(child);
+
+                    final View label = (View) child.getTag(R.id.fab_label);
+                    if (label != null) {
+                        final int labelXAwayFromButton = mLabelsPosition == LABELS_ON_LEFT_SIDE
+                                ? labelsXNearButton - label.getMeasuredWidth()
+                                : labelsXNearButton + label.getMeasuredWidth();
+
+                        final int labelLeft = mLabelsPosition == LABELS_ON_LEFT_SIDE
+                                ? labelXAwayFromButton
+                                : labelsXNearButton;
+
+                        final int labelRight = mLabelsPosition == LABELS_ON_LEFT_SIDE
+                                ? labelsXNearButton
+                                : labelXAwayFromButton;
+
+                        final int labelTop = childY - mLabelsVerticalOffset + (child.getMeasuredHeight() - label.getMeasuredHeight()) / 2;
+
+                        label.layout(labelLeft, labelTop, labelRight, labelTop + label.getMeasuredHeight());
+
+                        touchArea.set(Math.min(childX, labelLeft),
+                                childY - mButtonSpacing / 2,
+                                Math.max(childX + child.getMeasuredWidth(), labelRight),
+                                childY + child.getMeasuredHeight() + mButtonSpacing / 2);
+                        mTouchDelegateGroup.addTouchDelegate(new TouchDelegate(touchArea, child));
+
+                        label.setTranslationY(mExpanded ? expandedTranslation : collapsedTranslation);
+                        label.setAlpha(mExpanded ? 1f : 0f);
+
+                        LayoutParams labelParams = (LayoutParams) label.getLayoutParams();
+                        labelParams.mCollapseDir.setFloatValues(expandedTranslation, collapsedTranslation);
+                        labelParams.mExpandDir.setFloatValues(collapsedTranslation, expandedTranslation);
+                        labelParams.setAnimationsTarget(label);
+                    }
+
+                    nextY = expandUp ?
+                            childY - mButtonSpacing :
+                            childY + child.getMeasuredHeight() + mButtonSpacing;
+                }
+                break;
+
+            case EXPAND_LEFT:
+            case EXPAND_RIGHT:
+                final boolean expandLeft = mExpandDirection == EXPAND_LEFT;
+
+                final int addButtonX = expandLeft ? r - l - mAddButton.getMeasuredWidth() : 0;
+                // Ensure mAddButton is centered on the line where the buttons should be
+                final int addButtonTop = b - t - mMaxButtonHeight + (mMaxButtonHeight - mAddButton.getMeasuredHeight()) / 2;
+                mAddButton.layout(addButtonX, addButtonTop, addButtonX + mAddButton.getMeasuredWidth(), addButtonTop + mAddButton.getMeasuredHeight());
+
+                int nextX = expandLeft ?
+                        addButtonX - mButtonSpacing :
+                        addButtonX + mAddButton.getMeasuredWidth() + mButtonSpacing;
+
+                for (int i = mButtonsCount - 1; i >= 0; i--) {
+                    final View child = getChildAt(i);
+
+                    if (child == mAddButton || child.getVisibility() == GONE) continue;
+
+                    final int childX = expandLeft ? nextX - child.getMeasuredWidth() : nextX;
+                    final int childY = addButtonTop + (mAddButton.getMeasuredHeight() - child.getMeasuredHeight()) / 2;
+                    child.layout(childX, childY, childX + child.getMeasuredWidth(), childY + child.getMeasuredHeight());
+
+                    final float collapsedTranslation = addButtonX - childX;
+                    final float expandedTranslation = 0f;
+
+                    child.setTranslationX(mExpanded ? expandedTranslation : collapsedTranslation);
+                    child.setAlpha(mExpanded ? 1f : 0f);
+
+                    final LayoutParams params = (LayoutParams) child.getLayoutParams();
+                    params.mCollapseDir.setFloatValues(expandedTranslation, collapsedTranslation);
+                    params.mExpandDir.setFloatValues(collapsedTranslation, expandedTranslation);
+                    params.setAnimationsTarget(child);
+
+                    nextX = expandLeft ?
+                            childX - mButtonSpacing :
+                            childX + child.getMeasuredWidth() + mButtonSpacing;
+                }
+
+                break;
+        }
+    }
+
+    @Override
+    protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
+        return new LayoutParams(super.generateDefaultLayoutParams());
+    }
+
+    @Override
+    public ViewGroup.LayoutParams generateLayoutParams(final AttributeSet attrs) {
+        return new LayoutParams(super.generateLayoutParams(attrs));
+    }
+
+    @Override
+    protected ViewGroup.LayoutParams generateLayoutParams(final ViewGroup.LayoutParams p) {
+        return new LayoutParams(super.generateLayoutParams(p));
+    }
+
+    @Override
+    protected boolean checkLayoutParams(final ViewGroup.LayoutParams p) {
+        return super.checkLayoutParams(p);
+    }
+
+    @Override
+    protected void onFinishInflate() {
+        super.onFinishInflate();
+
+        bringChildToFront(mAddButton);
+        mButtonsCount = getChildCount();
+
+        if (mLabelsStyle != 0) {
+            createLabels();
+        }
+    }
+
+    private void createLabels() {
+        final Context context = new ContextThemeWrapper(getContext(), mLabelsStyle);
+
+        for (int i = 0; i < mButtonsCount; i++) {
+            final FloatingActionButton button = (FloatingActionButton) getChildAt(i);
+            final String title = button.getTitle();
+
+            if (button == mAddButton || title == null ||
+                    button.getTag(R.id.fab_label) != null) continue;
+
+            final TextView label = new TextView(context);
+            label.setTextAppearance(context, mLabelsStyle);
+            label.setText(button.getTitle());
+            addView(label);
+
+            button.setTag(R.id.fab_label, label);
+        }
+    }
+
+    public void collapse() {
+        collapse(false);
+    }
+
+    public void collapseImmediately() {
+        collapse(true);
+    }
+
+    private void collapse(final boolean immediately) {
+        if (mExpanded) {
+            mExpanded = false;
+            mTouchDelegateGroup.setEnabled(false);
+            mCollapseAnimation.setDuration(immediately ? 0 : ANIMATION_DURATION);
+            mCollapseAnimation.start();
+            mExpandAnimation.cancel();
+
+            if (mListener != null) {
+                mListener.onMenuCollapsed();
+            }
+        }
+    }
+
+    public void toggle() {
+        if (mExpanded) {
+            collapse();
+        } else {
+            expand();
+        }
+    }
+
+    public void expand() {
+        if (!mExpanded) {
+            mExpanded = true;
+            mTouchDelegateGroup.setEnabled(true);
+            mCollapseAnimation.cancel();
+            mExpandAnimation.start();
+
+            if (mListener != null) {
+                mListener.onMenuExpanded();
+            }
+        }
+    }
+
+    public boolean isExpanded() {
+        return mExpanded;
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+        super.setEnabled(enabled);
+
+        mAddButton.setEnabled(enabled);
+    }
+
+    @Override
+    public Parcelable onSaveInstanceState() {
+        final Parcelable superState = super.onSaveInstanceState();
+        final SavedState savedState = new SavedState(superState);
+        savedState.mExpanded = mExpanded;
+
+        return savedState;
+    }
+
+    @Override
+    public void onRestoreInstanceState(final Parcelable state) {
+        if (state instanceof SavedState) {
+            final SavedState savedState = (SavedState) state;
+            mExpanded = savedState.mExpanded;
+            mTouchDelegateGroup.setEnabled(mExpanded);
+
+            if (mRotatingDrawable != null) {
+                mRotatingDrawable.setRotation(mExpanded ? EXPANDED_PLUS_ROTATION : COLLAPSED_PLUS_ROTATION);
+            }
+
+            super.onRestoreInstanceState(savedState.getSuperState());
+        } else {
+            super.onRestoreInstanceState(state);
+        }
+    }
+
+    public interface OnFloatingActionsMenuUpdateListener {
+        void onMenuExpanded();
+
+        void onMenuCollapsed();
+    }
+
+    private static class RotatingDrawable extends LayerDrawable {
+        private float mRotation;
+
+        RotatingDrawable(final Drawable drawable) {
+            super(new Drawable[]{drawable});
+        }
+
+        @SuppressWarnings("UnusedDeclaration")
+        public float getRotation() {
+            return mRotation;
+        }
+
+        @SuppressWarnings("UnusedDeclaration")
+        public void setRotation(final float rotation) {
+            mRotation = rotation;
+            invalidateSelf();
+        }
+
+        @Override
+        public void draw(final Canvas canvas) {
+            canvas.save();
+            canvas.rotate(mRotation, getBounds().centerX(), getBounds().centerY());
+            super.draw(canvas);
+            canvas.restore();
+        }
+    }
+
+    public static class SavedState extends BaseSavedState {
+        public static final Creator<SavedState> CREATOR = new Creator<SavedState>() {
+
+            @Override
+            public SavedState createFromParcel(Parcel in) {
+                return new SavedState(in);
+            }
+
+            @Override
+            public SavedState[] newArray(int size) {
+                return new SavedState[size];
+            }
+        };
+        public boolean mExpanded;
+
+        public SavedState(final Parcelable parcel) {
+            super(parcel);
+        }
+
+        private SavedState(final Parcel in) {
+            super(in);
+            mExpanded = in.readInt() == 1;
+        }
+
+        @Override
+        public void writeToParcel(@NonNull final Parcel out, final int flags) {
+            super.writeToParcel(out, flags);
+            out.writeInt(mExpanded ? 1 : 0);
+        }
+    }
+
+    private class LayoutParams extends ViewGroup.LayoutParams {
+
+        private final ObjectAnimator mExpandDir = new ObjectAnimator();
+        private final ObjectAnimator mExpandAlpha = new ObjectAnimator();
+        private final ObjectAnimator mCollapseDir = new ObjectAnimator();
+        private final ObjectAnimator mCollapseAlpha = new ObjectAnimator();
+        private boolean animationsSetToPlay;
+
+        LayoutParams(final ViewGroup.LayoutParams source) {
+            super(source);
+
+            mExpandDir.setInterpolator(sExpandInterpolator);
+            mExpandAlpha.setInterpolator(sAlphaExpandInterpolator);
+            mCollapseDir.setInterpolator(sCollapseInterpolator);
+            mCollapseAlpha.setInterpolator(sCollapseInterpolator);
+
+            mCollapseAlpha.setProperty(View.ALPHA);
+            mCollapseAlpha.setFloatValues(1f, 0f);
+
+            mExpandAlpha.setProperty(View.ALPHA);
+            mExpandAlpha.setFloatValues(0f, 1f);
+
+            switch (mExpandDirection) {
+                case EXPAND_UP:
+                case EXPAND_DOWN:
+                    mCollapseDir.setProperty(View.TRANSLATION_Y);
+                    mExpandDir.setProperty(View.TRANSLATION_Y);
+                    break;
+                case EXPAND_LEFT:
+                case EXPAND_RIGHT:
+                    mCollapseDir.setProperty(View.TRANSLATION_X);
+                    mExpandDir.setProperty(View.TRANSLATION_X);
+                    break;
+            }
+        }
+
+        public void setAnimationsTarget(final View view) {
+            mCollapseAlpha.setTarget(view);
+            mCollapseDir.setTarget(view);
+            mExpandAlpha.setTarget(view);
+            mExpandDir.setTarget(view);
+
+            // Now that the animations have targets, set them to be played
+            if (!animationsSetToPlay) {
+                addLayerTypeListener(mExpandDir, view);
+                addLayerTypeListener(mCollapseDir, view);
+
+                mCollapseAnimation.play(mCollapseAlpha);
+                mCollapseAnimation.play(mCollapseDir);
+                mExpandAnimation.play(mExpandAlpha);
+                mExpandAnimation.play(mExpandDir);
+                animationsSetToPlay = true;
+            }
+        }
+
+        private void addLayerTypeListener(final Animator animator, final View view) {
+            animator.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(final Animator animation) {
+                    view.setLayerType(LAYER_TYPE_NONE, null);
+                }
+
+                @Override
+                public void onAnimationStart(final Animator animation) {
+                    view.setLayerType(LAYER_TYPE_HARDWARE, null);
+                }
+            });
+        }
+    }
+}

app/src/main/java/com/wireguard/android/widget/fab/TouchDelegateGroup.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright © 2014 Jerzy Chalupski
+ * Copyright © 2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+package com.wireguard.android.widget.fab;
+
+import android.graphics.Rect;
+import android.support.annotation.NonNull;
+import android.view.MotionEvent;
+import android.view.TouchDelegate;
+import android.view.View;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TouchDelegateGroup extends TouchDelegate {
+    private static final Rect USELESS_HACKY_RECT = new Rect();
+    private final List<TouchDelegate> mTouchDelegates = new ArrayList<>();
+    private TouchDelegate mCurrentTouchDelegate;
+    private boolean mEnabled;
+
+    public TouchDelegateGroup(final View uselessHackyView) {
+        super(USELESS_HACKY_RECT, uselessHackyView);
+    }
+
+    public void addTouchDelegate(@NonNull final TouchDelegate touchDelegate) {
+        mTouchDelegates.add(touchDelegate);
+    }
+
+    public void removeTouchDelegate(final TouchDelegate touchDelegate) {
+        mTouchDelegates.remove(touchDelegate);
+        if (mCurrentTouchDelegate == touchDelegate) {
+            mCurrentTouchDelegate = null;
+        }
+    }
+
+    public void clearTouchDelegates() {
+        mTouchDelegates.clear();
+        mCurrentTouchDelegate = null;
+    }
+
+    @Override
+    public boolean onTouchEvent(@NonNull final MotionEvent event) {
+        if (!mEnabled) return false;
+
+        TouchDelegate delegate = null;
+
+        switch (event.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                for (int i = 0; i < mTouchDelegates.size(); i++) {
+                    final TouchDelegate touchDelegate = mTouchDelegates.get(i);
+                    if (touchDelegate.onTouchEvent(event)) {
+                        mCurrentTouchDelegate = touchDelegate;
+                        return true;
+                    }
+                }
+                break;
+
+            case MotionEvent.ACTION_MOVE:
+                delegate = mCurrentTouchDelegate;
+                break;
+
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP:
+                delegate = mCurrentTouchDelegate;
+                mCurrentTouchDelegate = null;
+                break;
+        }
+
+        return delegate != null && delegate.onTouchEvent(event);
+    }
+
+    public void setEnabled(final boolean enabled) {
+        mEnabled = enabled;
+    }
+}

app/src/main/res/layout/tunnel_list_fragment.xml

@@ -29,7 +29,7 @@
             app:items="@{tunnels}"
             app:layout="@{@layout/tunnel_list_item}" />
 
-        <com.getbase.floatingactionbutton.FloatingActionsMenu
+        <com.wireguard.android.widget.fab.FloatingActionsMenu
             android:id="@+id/create_menu"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
@@ -39,7 +39,7 @@
             app:fab_labelsPosition="left"
             app:layout_dodgeInsetEdges="bottom">
 
-            <com.getbase.floatingactionbutton.FloatingActionButton
+            <com.wireguard.android.widget.fab.FloatingActionButton
                 android:id="@+id/create_empty"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
@@ -48,7 +48,7 @@
                 app:fab_size="mini"
                 app:fab_title="@string/create_empty" />
 
-            <com.getbase.floatingactionbutton.FloatingActionButton
+            <com.wireguard.android.widget.fab.FloatingActionButton
                 android:id="@+id/create_from_file"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
@@ -56,6 +56,6 @@
                 app:fab_icon="@drawable/ic_action_open"
                 app:fab_size="mini"
                 app:fab_title="@string/create_from_file" />
-        </com.getbase.floatingactionbutton.FloatingActionsMenu>
+        </com.wireguard.android.widget.fab.FloatingActionsMenu>
     </android.support.design.widget.CoordinatorLayout>
 </layout>

app/src/main/res/values/fab.xml

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <item name="fab_expand_menu_button" type="id"/>
+    <item name="fab_label" type="id"/>
+
+    <dimen name="fab_size_normal">56dp</dimen>
+    <dimen name="fab_size_mini">40dp</dimen>
+
+    <dimen name="fab_icon_size">24dp</dimen>
+
+    <dimen name="fab_plus_icon_size">14dp</dimen>
+    <dimen name="fab_plus_icon_stroke">2dp</dimen>
+
+    <dimen name="fab_shadow_offset">3dp</dimen>
+    <dimen name="fab_shadow_radius">9dp</dimen>
+
+    <dimen name="fab_stroke_width">1dp</dimen>
+
+    <dimen name="fab_actions_spacing">16dp</dimen>
+    <dimen name="fab_labels_margin">8dp</dimen>
+
+    <declare-styleable name="FloatingActionButton">
+        <attr name="fab_colorPressed" format="color"/>
+        <attr name="fab_colorDisabled" format="color"/>
+        <attr name="fab_colorNormal" format="color"/>
+        <attr name="fab_icon" format="reference"/>
+        <attr name="fab_size" format="enum">
+            <enum name="normal" value="0"/>
+            <enum name="mini" value="1"/>
+        </attr>
+        <attr name="fab_title" format="string"/>
+        <attr name="fab_stroke_visible" format="boolean"/>
+    </declare-styleable>
+    <declare-styleable name="AddFloatingActionButton">
+        <attr name="fab_plusIconColor" format="color"/>
+    </declare-styleable>
+    <declare-styleable name="FloatingActionsMenu">
+        <attr name="fab_addButtonColorPressed" format="color"/>
+        <attr name="fab_addButtonColorNormal" format="color"/>
+        <attr name="fab_addButtonSize" format="enum">
+            <enum name="normal" value="0"/>
+            <enum name="mini" value="1"/>
+        </attr>
+        <attr name="fab_addButtonPlusIconColor" format="color"/>
+        <attr name="fab_addButtonStrokeVisible" format="boolean"/>
+        <attr name="fab_labelStyle" format="reference"/>
+        <attr name="fab_labelsPosition" format="enum">
+            <enum name="left" value="0"/>
+            <enum name="right" value="1"/>
+        </attr>
+        <attr name="fab_expandDirection" format="enum">
+            <enum name="up" value="0"/>
+            <enum name="down" value="1"/>
+            <enum name="left" value="2"/>
+            <enum name="right" value="3"/>
+        </attr>
+    </declare-styleable>
+</resources>

app/tools/libwg-go/.gitignore

@@ -1,7 +1,2 @@
-go/
-*.go
-libwg-go.h
-jni.o
-gopath/
-goroot/
+src/
 .gobuildversion

app/tools/libwg-go/Makefile

@@ -11,7 +11,6 @@ NDK_GO_ARCH_MAP_arm64 := arm64
 NDK_GO_ARCH_MAP_mips := mipsx
 NDK_GO_ARCH_MAP_mips64 := mips64x
 
-export GOPATH := $(CURDIR)/gopath
 CLANG_FLAGS := --target=$(ANDROID_LLVM_TRIPLE) --gcc-toolchain=$(ANDROID_TOOLCHAIN_ROOT) --sysroot=$(ANDROID_SYSROOT)
 export CGO_CFLAGS := $(CLANG_FLAGS) $(CFLAGS)
 export CGO_LDFLAGS := $(CLANG_FLAGS) $(LDFLAGS)
@@ -48,12 +47,12 @@ endif
 
 $(shell test "$$(cat .gobuildversion 2>/dev/null)" = "$(GOBUILDVERSION_CURRENT)" || rm -f "$(DESTDIR)/libwg-go.so")
 
-$(DESTDIR)/libwg-go.so: $(FILES) api-android.go jni.c
+$(DESTDIR)/libwg-go.so: $(FILES) src/git.zx2c4.com/wireguard-go/api-android.go src/git.zx2c4.com/wireguard-go/tun/api-android.go src/git.zx2c4.com/wireguard-go/jni.c
 	find . -name '*.go' -type l -delete
 	find . -type d -empty -delete
-	mkdir -p $(subst ../wireguard-go/,./,$(dir $(FILES)))
-	$(foreach FILE,$(FILES),ln -sfrt $(subst ../wireguard-go/,./,$(dir $(FILE))) $(FILE);)
+	mkdir -p $(subst ../wireguard-go/,./src/git.zx2c4.com/wireguard-go/,$(dir $(FILES)))
+	$(foreach FILE,$(FILES),ln -sfrt $(subst ../wireguard-go/,./src/git.zx2c4.com/wireguard-go/,$(dir $(FILE))) $(FILE);)
 	patch -p1 -f -R -s --dry-run -d"$$(go env GOROOT)" < goruntime-boottime-over-monotonic.diff
-	go get -v -d
-	go build -v -o $(DESTDIR)/libwg-go.so -buildmode c-shared
+	GOPATH=$(PWD) go get -v -d git.zx2c4.com/wireguard-go
+	GOPATH=$(PWD) go build -v -o $(DESTDIR)/libwg-go.so -buildmode c-shared git.zx2c4.com/wireguard-go
 	go version > .gobuildversion

app/tools/libwg-go/src/git.zx2c4.com/wireguard-go/api-android.go

@@ -10,8 +10,8 @@ package main
 import "C"
 
 import (
-	"./rwcancel"
 	"bufio"
+	"git.zx2c4.com/wireguard-go/tun"
 	"golang.org/x/sys/unix"
 	"io/ioutil"
 	"log"
@@ -36,6 +36,7 @@ func (l AndroidLogger) Write(p []byte) (int, error) {
 var tunnelHandles map[int32]*Device
 
 func init() {
+	roamingDisabled = true
 	tunnelHandles = make(map[int32]*Device)
 	signals := make(chan os.Signal)
 	signal.Notify(signals, unix.SIGUSR2)
@@ -64,28 +65,16 @@ func wgTurnOn(ifnameRef string, tun_fd int32, settings string) int32 {
 
 	logger.Debug.Println("Debug log enabled")
 
-	tun := &NativeTun{
-		fd:     os.NewFile(uintptr(tun_fd), "/dev/tun"),
-		events: make(chan TUNEvent, 5),
-		errors: make(chan error, 5),
-		nopi:   true,
+	tun, name, err := tun.CreateTUNFromFD(int(tun_fd))
+	if err != nil {
+		unix.Close(int(tun_fd))
+		logger.Error.Println(err)
+		return -1
 	}
-	var err error
 
-	tun.fdCancel, err = rwcancel.NewRWCancel(int(tun_fd))
-	if err != nil {
-		unix.Close(int(tun_fd))
-		logger.Error.Println(err)
-		return -1
-	}
-	name, err := tun.Name()
-	if err != nil {
-		unix.Close(int(tun_fd))
-		logger.Error.Println(err)
-		return -1
-	}
 	logger.Info.Println("Attaching to interface", name)
 	device := NewDevice(tun, logger)
+
 	logger.Debug.Println("Interface has MTU", device.tun.mtu)
 
 	bufferedSettings := bufio.NewReadWriter(bufio.NewReader(strings.NewReader(settings)), bufio.NewWriter(ioutil.Discard))
@@ -133,7 +122,18 @@ func wgGetSocketV4(tunnelHandle int32) int32 {
 	if !ok {
 		return -1
 	}
-	return int32(native.sock4)
+	fd := int32(-1)
+	conn, err := native.ipv4.SyscallConn()
+	if err != nil {
+		return -1
+	}
+	err = conn.Control(func(f uintptr) {
+		fd = int32(f)
+	})
+	if err != nil {
+		return -1
+	}
+	return fd
 }
 
 //export wgGetSocketV6
@@ -146,7 +146,18 @@ func wgGetSocketV6(tunnelHandle int32) int32 {
 	if !ok {
 		return -1
 	}
-	return int32(native.sock6)
+	fd := int32(-1)
+	conn, err := native.ipv6.SyscallConn()
+	if err != nil {
+		return -1
+	}
+	err = conn.Control(func(f uintptr) {
+		fd = int32(f)
+	})
+	if err != nil {
+		return -1
+	}
+	return fd
 }
 
 func main() {}

app/tools/libwg-go/src/git.zx2c4.com/wireguard-go/tun/api-android.go

@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * Copyright (C) 2017-2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
+ */
+
+package tun
+
+import (
+	"git.zx2c4.com/wireguard-go/rwcancel"
+	"os"
+)
+
+func CreateTUNFromFD(tun_fd int) (TUNDevice, string, error) {
+	tun := &nativeTun{
+		fd:     os.NewFile(uintptr(tun_fd), "/dev/tun"),
+		events: make(chan TUNEvent, 5),
+		errors: make(chan error, 5),
+		nopi:   true,
+	}
+	var err error
+	tun.fdCancel, err = rwcancel.NewRWCancel(tun_fd)
+	if err != nil {
+		return nil, "", err
+	}
+	name, err := tun.Name()
+	if err != nil {
+		tun.fdCancel.Cancel()
+		return nil, "", err
+	}
+	return tun, name, nil
+}