Restructure project

app/shared/.gitignore

@@ -0,0 +1 @@
+/build

app/shared/build.gradle

@@ -0,0 +1,12 @@
+apply plugin: 'com.android.library'
+
+android {
+    defaultConfig {
+        vectorDrawables.useSupportLibrary = true
+        consumerProguardFiles 'proguard-rules.pro'
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+}

app/shared/proguard-rules.pro

@@ -0,0 +1,25 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
+
+-keepclassmembers class * extends javax.net.ssl.SSLSocketFactory {
+    ** delegate;
+}

app/shared/src/main/AndroidManifest.xml

@@ -0,0 +1,25 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    package="com.topjohnwu.shared">
+
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
+    <application
+        android:icon="@drawable/ic_launcher"
+        android:label="Magisk Manager"
+        android:installLocation="internalOnly"
+        android:usesCleartextTraffic="true"
+        android:supportsRtl="true"
+        android:theme="@android:style/Theme.Translucent.NoTitleBar"
+        tools:ignore="UnusedAttribute">
+
+        <provider
+            android:name="a.p"
+            android:authorities="${applicationId}.provider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+        </provider>
+    </application>
+</manifest>

app/shared/src/main/java/a/p.java

@@ -0,0 +1,7 @@
+package a;
+
+import com.topjohnwu.magisk.FileProvider;
+
+public class p extends FileProvider {
+    /* Stub */
+}

app/shared/src/main/java/com/topjohnwu/magisk/DynAPK.java

@@ -0,0 +1,68 @@
+package com.topjohnwu.magisk;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.util.Map;
+
+import static android.os.Build.VERSION.SDK_INT;
+
+public class DynAPK {
+
+    // Indices of the object array
+    private static final int STUB_VERSION_ENTRY = 0;
+    private static final int CLASS_COMPONENT_MAP = 1;
+
+    private static File dynDir;
+    private static Method addAssetPath;
+
+    private static File getDynDir(Context c) {
+        if (dynDir == null) {
+            if (SDK_INT >= 24) {
+                // Use protected context to allow directBootAware
+                c = c.createDeviceProtectedStorageContext();
+            }
+            dynDir = new File(c.getFilesDir().getParent(), "dyn");
+            dynDir.mkdir();
+        }
+        return dynDir;
+    }
+
+    public static File current(Context c) {
+        return new File(getDynDir(c), "current.apk");
+    }
+
+    public static File update(Context c) {
+        return new File(getDynDir(c), "update.apk");
+    }
+
+    public static Data load(Object o) {
+        Object[] arr = (Object[]) o;
+        Data data = new Data();
+        data.version = (int) arr[STUB_VERSION_ENTRY];
+        data.classToComponent = (Map<String, String>) arr[CLASS_COMPONENT_MAP];
+        return data;
+    }
+
+    public static Object pack(Data data) {
+        Object[] arr = new Object[2];
+        arr[STUB_VERSION_ENTRY] = data.version;
+        arr[CLASS_COMPONENT_MAP] = data.classToComponent;
+        return arr;
+    }
+
+    public static void addAssetPath(AssetManager asset, String path) {
+        try {
+            if (addAssetPath == null)
+                addAssetPath = AssetManager.class.getMethod("addAssetPath", String.class);
+            addAssetPath.invoke(asset, path);
+        } catch (Exception ignored) {}
+    }
+
+    public static class Data {
+        public int version;
+        public Map<String, String> classToComponent;
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/FileProvider.java

@@ -0,0 +1,351 @@
+package com.topjohnwu.magisk;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.pm.ProviderInfo;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Environment;
+import android.os.ParcelFileDescriptor;
+import android.provider.OpenableColumns;
+import android.text.TextUtils;
+import android.webkit.MimeTypeMap;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Modified from androidx.core.content.FileProvider
+ */
+public class FileProvider extends ContentProvider {
+    private static final String[] COLUMNS = {
+            OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE };
+
+    private static final File DEVICE_ROOT = new File("/");
+
+    private static HashMap<String, PathStrategy> sCache = new HashMap<>();
+
+    private PathStrategy mStrategy;
+
+    public static ProviderCallHandler callHandler;
+
+    @Override
+    public boolean onCreate() {
+        return true;
+    }
+
+    @Override
+    public void attachInfo(Context context, ProviderInfo info) {
+        super.attachInfo(context, info);
+
+        
+        if (info.exported) {
+            throw new SecurityException("Provider must not be exported");
+        }
+        if (!info.grantUriPermissions) {
+            throw new SecurityException("Provider must grant uri permissions");
+        }
+
+        mStrategy = getPathStrategy(context, info.authority);
+    }
+
+    
+    public static Uri getUriForFile(Context context, String authority,
+                                    File file) {
+        final PathStrategy strategy = getPathStrategy(context, authority);
+        return strategy.getUriForFile(file);
+    }
+
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection,
+                        String[] selectionArgs,
+                        String sortOrder) {
+        
+        final File file = mStrategy.getFileForUri(uri);
+
+        if (projection == null) {
+            projection = COLUMNS;
+        }
+
+        String[] cols = new String[projection.length];
+        Object[] values = new Object[projection.length];
+        int i = 0;
+        for (String col : projection) {
+            if (OpenableColumns.DISPLAY_NAME.equals(col)) {
+                cols[i] = OpenableColumns.DISPLAY_NAME;
+                values[i++] = file.getName();
+            } else if (OpenableColumns.SIZE.equals(col)) {
+                cols[i] = OpenableColumns.SIZE;
+                values[i++] = file.length();
+            }
+        }
+
+        cols = copyOf(cols, i);
+        values = copyOf(values, i);
+
+        final MatrixCursor cursor = new MatrixCursor(cols, 1);
+        cursor.addRow(values);
+        return cursor;
+    }
+
+    @Override
+    public String getType(Uri uri) {
+        
+        final File file = mStrategy.getFileForUri(uri);
+
+        final int lastDot = file.getName().lastIndexOf('.');
+        if (lastDot >= 0) {
+            final String extension = file.getName().substring(lastDot + 1);
+            final String mime = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
+            if (mime != null) {
+                return mime;
+            }
+        }
+
+        return "application/octet-stream";
+    }
+
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        throw new UnsupportedOperationException("No external inserts");
+    }
+
+    @Override
+    public int update(Uri uri, ContentValues values, String selection,
+                      String[] selectionArgs) {
+        throw new UnsupportedOperationException("No external updates");
+    }
+
+    @Override
+    public int delete(Uri uri, String selection,
+                      String[] selectionArgs) {
+        
+        final File file = mStrategy.getFileForUri(uri);
+        return file.delete() ? 1 : 0;
+    }
+
+    @Override
+    public Bundle call(String method, String arg, Bundle extras) {
+        if (callHandler != null)
+            return callHandler.call(getContext(), method, arg, extras);
+        return Bundle.EMPTY;
+    }
+
+    @Override
+    public ParcelFileDescriptor openFile(Uri uri, String mode)
+            throws FileNotFoundException {
+        
+        final File file = mStrategy.getFileForUri(uri);
+        final int fileMode = modeToMode(mode);
+        return ParcelFileDescriptor.open(file, fileMode);
+    }
+
+    private static PathStrategy getPathStrategy(Context context, String authority) {
+        PathStrategy strat;
+        synchronized (sCache) {
+            strat = sCache.get(authority);
+            if (strat == null) {
+                strat = createPathStrategy(context, authority);
+                sCache.put(authority, strat);
+            }
+        }
+        return strat;
+    }
+
+    private static PathStrategy createPathStrategy(Context context, String authority) {
+        final SimplePathStrategy strat = new SimplePathStrategy(authority);
+
+        strat.addRoot("root_files", buildPath(DEVICE_ROOT, "."));
+        strat.addRoot("internal_files", buildPath(context.getFilesDir(), "."));
+        strat.addRoot("cache_files", buildPath(context.getCacheDir(), "."));
+        strat.addRoot("external_files", buildPath(Environment.getExternalStorageDirectory(), "."));
+        {
+            File[] externalFilesDirs = getExternalFilesDirs(context, null);
+            if (externalFilesDirs.length > 0) {
+                strat.addRoot("external_file_files", buildPath(externalFilesDirs[0], "."));
+            }
+        }
+        {
+            File[] externalCacheDirs = getExternalCacheDirs(context);
+            if (externalCacheDirs.length > 0) {
+                strat.addRoot("external_cache_files", buildPath(externalCacheDirs[0], "."));
+            }
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            File[] externalMediaDirs = context.getExternalMediaDirs();
+            if (externalMediaDirs.length > 0) {
+                strat.addRoot("external_media_files", buildPath(externalMediaDirs[0], "."));
+            }
+        }
+
+        return strat;
+    }
+
+    interface PathStrategy {
+        
+        Uri getUriForFile(File file);
+
+        File getFileForUri(Uri uri);
+    }
+
+    static class SimplePathStrategy implements PathStrategy {
+        private final String mAuthority;
+        private final HashMap<String, File> mRoots = new HashMap<>();
+
+        SimplePathStrategy(String authority) {
+            mAuthority = authority;
+        }
+
+        void addRoot(String name, File root) {
+            if (TextUtils.isEmpty(name)) {
+                throw new IllegalArgumentException("Name must not be empty");
+            }
+
+            try {
+                
+                root = root.getCanonicalFile();
+            } catch (IOException e) {
+                throw new IllegalArgumentException(
+                        "Failed to resolve canonical path for " + root, e);
+            }
+
+            mRoots.put(name, root);
+        }
+
+        @Override
+        public Uri getUriForFile(File file) {
+            String path;
+            try {
+                path = file.getCanonicalPath();
+            } catch (IOException e) {
+                throw new IllegalArgumentException("Failed to resolve canonical path for " + file);
+            }
+
+            
+            Map.Entry<String, File> mostSpecific = null;
+            for (Map.Entry<String, File> root : mRoots.entrySet()) {
+                final String rootPath = root.getValue().getPath();
+                if (path.startsWith(rootPath) && (mostSpecific == null
+                        || rootPath.length() > mostSpecific.getValue().getPath().length())) {
+                    mostSpecific = root;
+                }
+            }
+
+            if (mostSpecific == null) {
+                throw new IllegalArgumentException(
+                        "Failed to find configured root that contains " + path);
+            }
+
+            
+            final String rootPath = mostSpecific.getValue().getPath();
+            if (rootPath.endsWith("/")) {
+                path = path.substring(rootPath.length());
+            } else {
+                path = path.substring(rootPath.length() + 1);
+            }
+
+            
+            path = Uri.encode(mostSpecific.getKey()) + '/' + Uri.encode(path, "/");
+            return new Uri.Builder().scheme("content")
+                    .authority(mAuthority).encodedPath(path).build();
+        }
+
+        @Override
+        public File getFileForUri(Uri uri) {
+            String path = uri.getEncodedPath();
+
+            final int splitIndex = path.indexOf('/', 1);
+            final String tag = Uri.decode(path.substring(1, splitIndex));
+            path = Uri.decode(path.substring(splitIndex + 1));
+
+            final File root = mRoots.get(tag);
+            if (root == null) {
+                throw new IllegalArgumentException("Unable to find configured root for " + uri);
+            }
+
+            File file = new File(root, path);
+            try {
+                file = file.getCanonicalFile();
+            } catch (IOException e) {
+                throw new IllegalArgumentException("Failed to resolve canonical path for " + file);
+            }
+
+            if (!file.getPath().startsWith(root.getPath())) {
+                throw new SecurityException("Resolved path jumped beyond configured root");
+            }
+
+            return file;
+        }
+    }
+
+    
+    private static int modeToMode(String mode) {
+        int modeBits;
+        if ("r".equals(mode)) {
+            modeBits = ParcelFileDescriptor.MODE_READ_ONLY;
+        } else if ("w".equals(mode) || "wt".equals(mode)) {
+            modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY
+                    | ParcelFileDescriptor.MODE_CREATE
+                    | ParcelFileDescriptor.MODE_TRUNCATE;
+        } else if ("wa".equals(mode)) {
+            modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY
+                    | ParcelFileDescriptor.MODE_CREATE
+                    | ParcelFileDescriptor.MODE_APPEND;
+        } else if ("rw".equals(mode)) {
+            modeBits = ParcelFileDescriptor.MODE_READ_WRITE
+                    | ParcelFileDescriptor.MODE_CREATE;
+        } else if ("rwt".equals(mode)) {
+            modeBits = ParcelFileDescriptor.MODE_READ_WRITE
+                    | ParcelFileDescriptor.MODE_CREATE
+                    | ParcelFileDescriptor.MODE_TRUNCATE;
+        } else {
+            throw new IllegalArgumentException("Invalid mode: " + mode);
+        }
+        return modeBits;
+    }
+
+    private static File buildPath(File base, String... segments) {
+        File cur = base;
+        for (String segment : segments) {
+            if (segment != null) {
+                cur = new File(cur, segment);
+            }
+        }
+        return cur;
+    }
+
+    private static String[] copyOf(String[] original, int newLength) {
+        final String[] result = new String[newLength];
+        System.arraycopy(original, 0, result, 0, newLength);
+        return result;
+    }
+
+    private static Object[] copyOf(Object[] original, int newLength) {
+        final Object[] result = new Object[newLength];
+        System.arraycopy(original, 0, result, 0, newLength);
+        return result;
+    }
+
+    private static File[] getExternalFilesDirs(Context context, String type) {
+        if (Build.VERSION.SDK_INT >= 19) {
+            return context.getExternalFilesDirs(type);
+        } else {
+            return new File[] { context.getExternalFilesDir(type) };
+        }
+    }
+
+    private static File[] getExternalCacheDirs(Context context) {
+        if (Build.VERSION.SDK_INT >= 19) {
+            return context.getExternalCacheDirs();
+        } else {
+            return new File[] { context.getExternalCacheDir() };
+        }
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/ProcessPhoenix.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2014 Jake Wharton
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.topjohnwu.magisk;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+
+import java.util.ArrayList;
+
+import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+
+/**
+ * Modified from JakeWharton/ProcessPhoenix
+ *
+ * Process Phoenix facilitates restarting your application process. This should only be used for
+ * things like fundamental state changes in your debug builds (e.g., changing from staging to
+ * production).
+ * <p>
+ * Trigger process recreation by calling {@link #triggerRebirth} with a {@link Context} instance.
+ */
+public class ProcessPhoenix extends Activity {
+    private static final String KEY_RESTART_INTENT = "phoenix_restart_intent";
+
+    public static void triggerRebirth(Context context, Intent intent) {
+        intent.addFlags(FLAG_ACTIVITY_NEW_TASK); // In case we are called with non-Activity context.
+        intent.putExtra(KEY_RESTART_INTENT, getRestartIntent(context));
+        context.startActivity(intent);
+        if (context instanceof Activity) {
+            ((Activity) context).finish();
+        }
+        Runtime.getRuntime().exit(0);
+    }
+
+    private static Intent getRestartIntent(Context context) {
+        String packageName = context.getPackageName();
+        Intent defaultIntent = context.getPackageManager().getLaunchIntentForPackage(packageName);
+        if (defaultIntent != null) {
+            defaultIntent.addFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK);
+            return defaultIntent;
+        }
+
+        throw new IllegalStateException();
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        Intent intent = getIntent().getParcelableExtra(KEY_RESTART_INTENT);
+        startActivity(intent);
+        finish();
+        Runtime.getRuntime().exit(0);
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/ProviderCallHandler.java

@@ -0,0 +1,8 @@
+package com.topjohnwu.magisk;
+
+import android.content.Context;
+import android.os.Bundle;
+
+public interface ProviderCallHandler {
+    Bundle call(Context context, String method, String arg, Bundle extras);
+}

app/shared/src/main/java/com/topjohnwu/magisk/net/BadRequest.java

@@ -0,0 +1,50 @@
+package com.topjohnwu.magisk.net;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
+class BadRequest extends Request {
+
+    private IOException ex;
+
+    BadRequest(IOException e) { super(null); ex = e; }
+
+    @Override
+    public Request addHeaders(String key, String value) { return this; }
+
+    @Override
+    public Result<InputStream> execForInputStream() { fail(); return new Result<>(); }
+
+    @Override
+    public void getAsFile(File out, ResponseListener<File> rs) { fail(); }
+
+    @Override
+    public void execForFile(File out) { fail(); }
+
+    @Override
+    public void getAsString(ResponseListener<String> rs) { fail(); }
+
+    @Override
+    public Result<String> execForString() { fail(); return new Result<>(); }
+
+    @Override
+    public void getAsJSONObject(ResponseListener<JSONObject> rs) { fail(); }
+
+    @Override
+    public Result<JSONObject> execForJSONObject() { fail(); return new Result<>(); }
+
+    @Override
+    public void getAsJSONArray(ResponseListener<JSONArray> rs) { fail(); }
+
+    @Override
+    public Result<JSONArray> execForJSONArray() { fail(); return new Result<>(); }
+
+    private void fail() {
+        if (err != null)
+            err.onError(null, ex);
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/net/ErrorHandler.java

@@ -0,0 +1,7 @@
+package com.topjohnwu.magisk.net;
+
+import java.net.HttpURLConnection;
+
+public interface ErrorHandler {
+    void onError(HttpURLConnection conn, Exception e);
+}

app/shared/src/main/java/com/topjohnwu/magisk/net/Networking.java

@@ -0,0 +1,64 @@
+package com.topjohnwu.magisk.net;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+import javax.net.ssl.HttpsURLConnection;
+
+public class Networking {
+
+    private static final int READ_TIMEOUT = 15000;
+    private static final int CONNECT_TIMEOUT = 15000;
+    static Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    private static Request request(String url, String method) {
+        try {
+            HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
+            conn.setRequestMethod(method);
+            conn.setReadTimeout(READ_TIMEOUT);
+            conn.setConnectTimeout(CONNECT_TIMEOUT);
+            return new Request(conn);
+        } catch (IOException e) {
+            return new BadRequest(e);
+        }
+    }
+
+    public static Request get(String url) {
+        return request(url, "GET");
+    }
+
+    public static boolean init(Context context) {
+        try {
+            // Try installing new SSL provider from Google Play Service
+            Context gms = context.createPackageContext("com.google.android.gms",
+                    Context.CONTEXT_INCLUDE_CODE | Context.CONTEXT_IGNORE_SECURITY);
+            gms.getClassLoader()
+                    .loadClass("com.google.android.gms.common.security.ProviderInstallerImpl")
+                    .getMethod("insertProvider", Context.class)
+                    .invoke(null, gms);
+        } catch (Exception e) {
+            if (Build.VERSION.SDK_INT < 21) {
+                // Failed to update SSL provider, use NoSSLv3SocketFactory on SDK < 21
+                // and return false to notify potential issues
+                HttpsURLConnection.setDefaultSSLSocketFactory(new NoSSLv3SocketFactory());
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean checkNetworkStatus(Context context) {
+        ConnectivityManager manager = (ConnectivityManager)
+                context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        NetworkInfo networkInfo = manager.getActiveNetworkInfo();
+        return networkInfo != null && networkInfo.isConnected();
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/net/NoSSLv3SocketFactory.java

@@ -0,0 +1,70 @@
+package com.topjohnwu.magisk.net;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+public class NoSSLv3SocketFactory extends SSLSocketFactory {
+
+    private final static SSLSocketFactory delegate = HttpsURLConnection.getDefaultSSLSocketFactory();
+
+    @Override
+    public String[] getDefaultCipherSuites() {
+        return delegate.getDefaultCipherSuites();
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites() {
+        return delegate.getSupportedCipherSuites();
+    }
+
+    private Socket createSafeSocket(Socket socket) {
+        if (socket instanceof SSLSocket)
+            return new SSLSocketWrapper((SSLSocket) socket) {
+                @Override
+                public void setEnabledProtocols(String[] protocols) {
+                    List<String> proto = new ArrayList<>(Arrays.asList(getSupportedProtocols()));
+                    proto.remove("SSLv3");
+                    super.setEnabledProtocols(proto.toArray(new String[0]));
+                }
+            };
+        return socket;
+    }
+
+    @Override
+    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
+        return createSafeSocket(delegate.createSocket(s, host, port, autoClose));
+    }
+
+    @Override
+    public Socket createSocket() throws IOException {
+        return createSafeSocket(delegate.createSocket());
+    }
+
+    @Override
+    public Socket createSocket(String host, int port) throws IOException {
+        return createSafeSocket(delegate.createSocket(host, port));
+    }
+
+    @Override
+    public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException {
+        return createSafeSocket(delegate.createSocket(host, port, localHost, localPort));
+    }
+
+    @Override
+    public Socket createSocket(InetAddress host, int port) throws IOException {
+        return createSafeSocket(delegate.createSocket(host, port));
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
+        return createSafeSocket(delegate.createSocket(address, port, localAddress, localPort));
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/net/Request.java

@@ -0,0 +1,215 @@
+package com.topjohnwu.magisk.net;
+
+import android.os.AsyncTask;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.util.Scanner;
+import java.util.concurrent.Executor;
+
+public class Request implements Closeable {
+    private HttpURLConnection conn;
+    private Executor executor = null;
+    private int code = -1;
+
+    ErrorHandler err = null;
+
+    private interface Requestor<T> {
+        T request() throws Exception;
+    }
+
+    public class Result<T> {
+        T result;
+
+        public T getResult() {
+            return result;
+        }
+
+        public int getCode() {
+            return code;
+        }
+
+        public boolean isSuccess() {
+            return code >= 200 && code <= 299;
+        }
+
+        public HttpURLConnection getConnection() {
+            return conn;
+        }
+    }
+
+    Request(HttpURLConnection c) {
+        conn = c;
+    }
+
+    @Override
+    public void close() {
+        conn.disconnect();
+    }
+
+    public Request addHeaders(String key, String value) {
+        conn.setRequestProperty(key, value);
+        return this;
+    }
+
+    public Request setErrorHandler(ErrorHandler handler) {
+        err = handler;
+        return this;
+    }
+
+    public Request setExecutor(Executor e) {
+        executor = e;
+        return this;
+    }
+
+    public Result<Void> connect() {
+        try {
+            connect0();
+        } catch (IOException e) {
+            if (err != null)
+                err.onError(conn, e);
+        }
+        return new Result<>();
+    }
+
+    public Result<InputStream> execForInputStream() {
+        return exec(this::getInputStream);
+    }
+
+    public void getAsFile(File out, ResponseListener<File> rs) {
+        submit(() -> dlFile(out), rs);
+    }
+
+    public void execForFile(File out) {
+        exec(() -> dlFile(out));
+    }
+
+    public void getAsBytes(ResponseListener<byte[]> rs) {
+        submit(this::dlBytes, rs);
+    }
+
+    public Result<byte[]> execForBytes() {
+        return exec(this::dlBytes);
+    }
+
+    public void getAsString(ResponseListener<String> rs) {
+        submit(this::dlString, rs);
+    }
+
+    public Result<String> execForString() {
+        return exec(this::dlString);
+    }
+
+    public void getAsJSONObject(ResponseListener<JSONObject> rs) {
+        submit(this::dlJSONObject, rs);
+    }
+
+    public Result<JSONObject> execForJSONObject() {
+        return exec(this::dlJSONObject);
+    }
+
+    public void getAsJSONArray(ResponseListener<JSONArray> rs) {
+        submit(this::dlJSONArray, rs);
+    }
+
+    public Result<JSONArray> execForJSONArray() {
+        return exec(this::dlJSONArray);
+    }
+
+    private void connect0() throws IOException {
+        conn.connect();
+        code = conn.getResponseCode();
+    }
+
+    private <T> Result<T> exec(Requestor<T> req) {
+        Result<T> res = new Result<>();
+        try {
+            res.result = req.request();
+        } catch (Exception e) {
+            if (err != null)
+                err.onError(conn, e);
+        }
+        return res;
+    }
+
+    private <T> void submit(Requestor<T> req, ResponseListener<T> rs) {
+        AsyncTask.THREAD_POOL_EXECUTOR.execute(() -> {
+            try {
+                T t = req.request();
+                Runnable cb = () -> rs.onResponse(t);
+                if (executor == null)
+                    Networking.mainHandler.post(cb);
+                else
+                    executor.execute(cb);
+            } catch (Exception e) {
+                if (err != null)
+                    err.onError(conn, e);
+            }
+        });
+    }
+
+    private BufferedInputStream getInputStream() throws IOException {
+        connect0();
+        InputStream in = new FilterInputStream(conn.getInputStream()) {
+            @Override
+            public void close() throws IOException {
+                super.close();
+                conn.disconnect();
+            }
+        };
+        return new BufferedInputStream(in);
+    }
+
+    private String dlString() throws IOException {
+        try (Scanner s = new Scanner(getInputStream(), "UTF-8")) {
+            s.useDelimiter("\\A");
+            return s.next();
+        }
+    }
+
+    private JSONObject dlJSONObject() throws IOException, JSONException {
+        return new JSONObject(dlString());
+    }
+
+    private JSONArray dlJSONArray() throws IOException, JSONException {
+        return new JSONArray(dlString());
+    }
+
+    private File dlFile(File f) throws IOException {
+        try (InputStream in  = getInputStream();
+             OutputStream out = new BufferedOutputStream(new FileOutputStream(f))) {
+            int len;
+            byte[] buf = new byte[4096];
+            while ((len = in.read(buf)) != -1) {
+                out.write(buf, 0, len);
+            }
+        }
+        return f;
+    }
+
+    private byte[] dlBytes() throws IOException {
+        int len = conn.getContentLength();
+        len = len > 0 ? len : 32;
+        ByteArrayOutputStream out = new ByteArrayOutputStream(len);
+        try (InputStream in  = getInputStream()) {
+            byte[] buf = new byte[4096];
+            while ((len = in.read(buf)) != -1) {
+                out.write(buf, 0, len);
+            }
+        }
+        return out.toByteArray();
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/net/ResponseListener.java

@@ -0,0 +1,5 @@
+package com.topjohnwu.magisk.net;
+
+public interface ResponseListener<T> {
+    void onResponse(T response);
+}

app/shared/src/main/java/com/topjohnwu/magisk/net/SSLSocketWrapper.java

@@ -0,0 +1,333 @@
+package com.topjohnwu.magisk.net;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.SocketAddress;
+import java.net.SocketException;
+import java.nio.channels.SocketChannel;
+
+import javax.net.ssl.HandshakeCompletedListener;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
+
+class SSLSocketWrapper extends SSLSocket {
+
+    private SSLSocket mBase;
+
+    SSLSocketWrapper(SSLSocket socket) {
+        mBase = socket;
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites() {
+        return mBase.getSupportedCipherSuites();
+    }
+
+    @Override
+    public String[] getEnabledCipherSuites() {
+        return mBase.getEnabledCipherSuites();
+    }
+
+    @Override
+    public void setEnabledCipherSuites(String[] suites) {
+        mBase.setEnabledCipherSuites(suites);
+    }
+
+    @Override
+    public String[] getSupportedProtocols() {
+        return mBase.getSupportedProtocols();
+    }
+
+    @Override
+    public String[] getEnabledProtocols() {
+        return mBase.getEnabledProtocols();
+    }
+
+    @Override
+    public void setEnabledProtocols(String[] protocols) {
+        mBase.setEnabledProtocols(protocols);
+    }
+
+    @Override
+    public SSLSession getSession() {
+        return mBase.getSession();
+    }
+
+    @Override
+    public SSLSession getHandshakeSession() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void addHandshakeCompletedListener(HandshakeCompletedListener listener) {
+        mBase.addHandshakeCompletedListener(listener);
+    }
+
+    @Override
+    public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) {
+        mBase.removeHandshakeCompletedListener(listener);
+    }
+
+    @Override
+    public void startHandshake() throws IOException {
+        mBase.startHandshake();
+    }
+
+    @Override
+    public void setUseClientMode(boolean mode) {
+        mBase.setUseClientMode(mode);
+    }
+
+    @Override
+    public boolean getUseClientMode() {
+        return mBase.getUseClientMode();
+    }
+
+    @Override
+    public void setNeedClientAuth(boolean need) {
+        mBase.setNeedClientAuth(need);
+    }
+
+    @Override
+    public boolean getNeedClientAuth() {
+        return mBase.getNeedClientAuth();
+    }
+
+    @Override
+    public void setWantClientAuth(boolean want) {
+        mBase.setWantClientAuth(want);
+    }
+
+    @Override
+    public boolean getWantClientAuth() {
+        return mBase.getWantClientAuth();
+    }
+
+    @Override
+    public void setEnableSessionCreation(boolean flag) {
+        mBase.setEnableSessionCreation(flag);
+    }
+
+    @Override
+    public boolean getEnableSessionCreation() {
+        return mBase.getEnableSessionCreation();
+    }
+
+    @Override
+    public SSLParameters getSSLParameters() {
+        return mBase.getSSLParameters();
+    }
+
+    @Override
+    public void setSSLParameters(SSLParameters params) {
+        mBase.setSSLParameters(params);
+    }
+
+    @Override
+    public String toString() {
+        return mBase.toString();
+    }
+
+    @Override
+    public void connect(SocketAddress endpoint) throws IOException {
+        mBase.connect(endpoint);
+    }
+
+    @Override
+    public void connect(SocketAddress endpoint, int timeout) throws IOException {
+        mBase.connect(endpoint, timeout);
+    }
+
+    @Override
+    public void bind(SocketAddress bindpoint) throws IOException {
+        mBase.bind(bindpoint);
+    }
+
+    @Override
+    public InetAddress getInetAddress() {
+        return mBase.getInetAddress();
+    }
+
+    @Override
+    public InetAddress getLocalAddress() {
+        return mBase.getLocalAddress();
+    }
+
+    @Override
+    public int getPort() {
+        return mBase.getPort();
+    }
+
+    @Override
+    public int getLocalPort() {
+        return mBase.getLocalPort();
+    }
+
+    @Override
+    public SocketAddress getRemoteSocketAddress() {
+        return mBase.getRemoteSocketAddress();
+    }
+
+    @Override
+    public SocketAddress getLocalSocketAddress() {
+        return mBase.getLocalSocketAddress();
+    }
+
+    @Override
+    public SocketChannel getChannel() {
+        return mBase.getChannel();
+    }
+
+    @Override
+    public InputStream getInputStream() throws IOException {
+        return mBase.getInputStream();
+    }
+
+    @Override
+    public OutputStream getOutputStream() throws IOException {
+        return mBase.getOutputStream();
+    }
+
+    @Override
+    public void setTcpNoDelay(boolean on) throws SocketException {
+        mBase.setTcpNoDelay(on);
+    }
+
+    @Override
+    public boolean getTcpNoDelay() throws SocketException {
+        return mBase.getTcpNoDelay();
+    }
+
+    @Override
+    public void setSoLinger(boolean on, int linger) throws SocketException {
+        mBase.setSoLinger(on, linger);
+    }
+
+    @Override
+    public int getSoLinger() throws SocketException {
+        return mBase.getSoLinger();
+    }
+
+    @Override
+    public void sendUrgentData(int data) throws IOException {
+        mBase.sendUrgentData(data);
+    }
+
+    @Override
+    public void setOOBInline(boolean on) throws SocketException {
+        mBase.setOOBInline(on);
+    }
+
+    @Override
+    public boolean getOOBInline() throws SocketException {
+        return mBase.getOOBInline();
+    }
+
+    @Override
+    public void setSoTimeout(int timeout) throws SocketException {
+        mBase.setSoTimeout(timeout);
+    }
+
+    @Override
+    public int getSoTimeout() throws SocketException {
+        return mBase.getSoTimeout();
+    }
+
+    @Override
+    public void setSendBufferSize(int size) throws SocketException {
+        mBase.setSendBufferSize(size);
+    }
+
+    @Override
+    public int getSendBufferSize() throws SocketException {
+        return mBase.getSendBufferSize();
+    }
+
+    @Override
+    public void setReceiveBufferSize(int size) throws SocketException {
+        mBase.setReceiveBufferSize(size);
+    }
+
+    @Override
+    public int getReceiveBufferSize() throws SocketException {
+        return mBase.getReceiveBufferSize();
+    }
+
+    @Override
+    public void setKeepAlive(boolean on) throws SocketException {
+        mBase.setKeepAlive(on);
+    }
+
+    @Override
+    public boolean getKeepAlive() throws SocketException {
+        return mBase.getKeepAlive();
+    }
+
+    @Override
+    public void setTrafficClass(int tc) throws SocketException {
+        mBase.setTrafficClass(tc);
+    }
+
+    @Override
+    public int getTrafficClass() throws SocketException {
+        return mBase.getTrafficClass();
+    }
+
+    @Override
+    public void setReuseAddress(boolean on) throws SocketException {
+        mBase.setReuseAddress(on);
+    }
+
+    @Override
+    public boolean getReuseAddress() throws SocketException {
+        return mBase.getReuseAddress();
+    }
+
+    @Override
+    public void close() throws IOException {
+        mBase.close();
+    }
+
+    @Override
+    public void shutdownInput() throws IOException {
+        mBase.shutdownInput();
+    }
+
+    @Override
+    public void shutdownOutput() throws IOException {
+        mBase.shutdownOutput();
+    }
+
+    @Override
+    public boolean isConnected() {
+        return mBase.isConnected();
+    }
+
+    @Override
+    public boolean isBound() {
+        return mBase.isBound();
+    }
+
+    @Override
+    public boolean isClosed() {
+        return mBase.isClosed();
+    }
+
+    @Override
+    public boolean isInputShutdown() {
+        return mBase.isInputShutdown();
+    }
+
+    @Override
+    public boolean isOutputShutdown() {
+        return mBase.isOutputShutdown();
+    }
+
+    @Override
+    public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) {
+        mBase.setPerformancePreferences(connectionTime, latency, bandwidth);
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/utils/APKInstall.java

@@ -0,0 +1,29 @@
+package com.topjohnwu.magisk.utils;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+
+import com.topjohnwu.magisk.FileProvider;
+
+import java.io.File;
+
+public class APKInstall {
+    public static void install(Context c, File apk) {
+        c.startActivity(installIntent(c, apk));
+    }
+
+    public static Intent installIntent(Context c, File apk) {
+        Intent install = new Intent(Intent.ACTION_INSTALL_PACKAGE);
+        install.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        install.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            install.setData(FileProvider.getUriForFile(c, c.getPackageName() + ".provider", apk));
+        } else {
+            apk.setReadable(true, false);
+            install.setData(Uri.fromFile(apk));
+        }
+        return install;
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/utils/CompoundEnumeration.java

@@ -0,0 +1,35 @@
+package com.topjohnwu.magisk.utils;
+
+import java.util.Enumeration;
+import java.util.NoSuchElementException;
+
+public class CompoundEnumeration<E> implements Enumeration<E> {
+    private Enumeration<E>[] enums;
+    private int index = 0;
+
+    @SafeVarargs
+    public CompoundEnumeration(Enumeration<E> ...enums) {
+        this.enums = enums;
+    }
+
+    private boolean next() {
+        while (index < enums.length) {
+            if (enums[index] != null && enums[index].hasMoreElements()) {
+                return true;
+            }
+            index++;
+        }
+        return false;
+    }
+
+    public boolean hasMoreElements() {
+        return next();
+    }
+
+    public E nextElement() {
+        if (!next()) {
+            throw new NoSuchElementException();
+        }
+        return enums[index].nextElement();
+    }
+}

app/shared/src/main/java/com/topjohnwu/magisk/utils/DynamicClassLoader.java

@@ -0,0 +1,60 @@
+package com.topjohnwu.magisk.utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Enumeration;
+
+import dalvik.system.DexClassLoader;
+
+public class DynamicClassLoader extends DexClassLoader {
+
+    private ClassLoader base = Object.class.getClassLoader();
+
+    public DynamicClassLoader(File apk, ClassLoader parent) {
+        super(apk.getPath(), apk.getParent(), null, parent);
+    }
+
+    @Override
+    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        // First check if already loaded
+        Class cls = findLoadedClass(name);
+        if (cls != null)
+            return cls;
+
+        try {
+            // Then check boot classpath
+            return base.loadClass(name);
+        } catch (ClassNotFoundException ignored) {
+            try {
+                // Next try current dex
+                return findClass(name);
+            } catch (ClassNotFoundException fromSuper) {
+                try {
+                    // Finally try parent
+                    return getParent().loadClass(name);
+                } catch (ClassNotFoundException e) {
+                    throw fromSuper;
+                }
+            }
+        }
+    }
+
+    @Override
+    public URL getResource(String name) {
+        URL resource = base.getResource(name);
+        if (resource != null)
+            return resource;
+        resource = findResource(name);
+        if (resource != null)
+            return resource;
+        resource = getParent().getResource(name);
+        return resource;
+    }
+
+    @Override
+    public Enumeration<URL> getResources(String name) throws IOException {
+        return new CompoundEnumeration<>(base.getResources(name),
+                findResources(name), getParent().getResources(name));
+    }
+}

app/shared/src/main/res/drawable/ic_logo.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <shape android:shape="oval">
+            <solid android:color="#00AF9C"/>
+        </shape>
+    </item>
+
+    <item android:drawable="@drawable/ic_magisk" />
+
+</layer-list>

app/shared/src/main/res/drawable/ic_magisk.xml

@@ -0,0 +1,18 @@
+<vector android:height="48dp" android:viewportHeight="720"
+    android:viewportWidth="720" android:width="48dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#303030" android:pathData="M332.48,421.18c0,0 3.77,22.45 -0.82,71.95c-5.76,62.06 23.64,160.64 23.64,160.64c0,0 40.1,-98.78 33.1,-162.59c-5.75,-52.45 2.6,-70.79 0.82,-68.33c-30.81,42.57 -56.75,-1.67 -56.75,-1.67z"/>
+    <path android:fillColor="#ffffff" android:pathData="M407.6,474.45c5.01,38.77 -0.57,60.01 -7.81,101.51c-3.66,20.99 74.78,-63.1 104.86,-113.23c5.02,-8.36 -28.77,32.6 -62.19,3.35c-23.18,-20.28 -27.16,-26.44 -45.18,-44.06c-6.08,-5.94 6.74,24.72 10.32,52.43z"/>
+    <path android:fillColor="#ffffff" android:pathData="M321.99,425.09c-18.02,17.62 -22,23.78 -45.18,44.06c-33.42,29.25 -67.21,-11.71 -62.19,-3.35c30.08,50.13 108.52,134.22 104.86,113.23c-7.24,-41.5 -12.82,-62.74 -7.81,-101.51c3.58,-27.71 16.4,-58.37 10.32,-52.43z"/>
+    <path android:fillColor="#303030" android:pathData="M399.15,355.87c36.67,10.57 50.89,61.5 87.91,67.8c7.65,1.3 16.27,3.6 26.31,3.12c18.77,-0.9 42.51,-11.51 74.22,-56.5c9.38,-13.3 -23.27,85.66 -105.13,86.86c-59.96,0.88 -66.97,-58.7 -106.93,-60.51c-14.43,-0.65 -15.34,-28.17 -15.34,-28.17c0,0 17.22,-18.86 38.96,-12.6z"/>
+    <path android:fillColor="#303030" android:pathData="M321.51,355.59c-36.67,10.57 -50.89,61.5 -87.91,67.8c-7.65,1.3 -16.27,3.6 -26.31,3.12c-18.77,-0.9 -42.51,-11.51 -74.22,-56.5c-9.38,-13.3 23.27,85.66 105.13,86.86c59.96,0.88 66.97,-58.7 106.93,-60.51c14.43,-0.65 15.34,-28.17 15.34,-28.17c0,0 -17.22,-18.86 -38.96,-12.6z"/>
+    <path android:fillColor="#fbbcc9" android:pathData="M458.64,355.09c36.87,27.94 25.88,58.7 46.57,49.92c69.7,-29.55 57.51,-181.21 51.87,-162.87c-31.77,103.41 -100.99,109.2 -167.61,61.63c-13.01,-9.29 48.38,35.57 69.16,51.31z"/>
+    <path android:fillColor="#fbbcc9" android:pathData="M330.91,303.77c-66.62,47.56 -135.84,41.78 -167.61,-61.63c-5.63,-18.34 -17.82,133.31 51.87,162.87c20.7,8.78 9.7,-21.98 46.57,-49.92c20.78,-15.75 82.17,-60.6 69.16,-51.31z"/>
+    <path android:fillColor="#3747a9" android:pathData="M465.61,318c80.43,-3.32 95.29,-135.17 88.96,-119.08c-28.39,72.22 -135.86,45.05 -146.13,90.64c-2.02,8.94 18.2,30.06 57.17,28.45z"/>
+    <path android:fillColor="#3747a9" android:pathData="M311.95,289.55c-10.27,-45.59 -117.75,-18.41 -146.13,-90.64c-6.32,-16.09 8.53,115.76 88.96,119.08c38.97,1.61 59.19,-19.5 57.17,-28.45z"/>
+    <path android:fillColor="#ff6e40" android:pathData="M403.42,269.47c0,0 43.73,-23.5 81.16,-33.74c34.99,-9.58 61.22,-33.13 64.14,-58.01c2.18,-18.53 -27.05,-53.55 -27.05,-53.55c0,0 -20.51,56.9 -47.41,85.34c-29.28,30.96 -18.15,26.78 -70.84,59.96z"/>
+    <path android:fillColor="#ff6e40" android:pathData="M246.13,209.51c-26.9,-28.44 -47.41,-85.34 -47.41,-85.34c0,0 -29.23,35.01 -27.05,53.55c2.93,24.88 29.16,48.43 64.14,58.01c37.43,10.25 81.16,33.74 81.16,33.74c-52.69,-33.18 -41.55,-29 -70.84,-59.96z"/>
+    <path android:fillColor="#ffffff" android:pathData="M398.12,265.85c47.36,-38.85 72.53,-89.54 113.51,-145.02c7.73,-10.46 -34.58,-35.7 -51.31,-37.37c-16.73,-1.67 -30.77,59.79 -32.35,95.94c-1.44,33.01 -36.21,91.68 -29.84,86.45z"/>
+    <path android:fillColor="#ffffff" android:pathData="M292.42,179.39c-1.58,-36.15 -15.62,-97.61 -32.35,-95.94c-16.73,1.67 -59.04,26.91 -51.31,37.37c40.98,55.48 66.14,106.17 113.51,145.02c6.37,5.22 -28.4,-53.45 -29.84,-86.45z"/>
+    <path android:fillColor="#ffb327" android:pathData="M402.86,140.35c3.34,-26.76 15.37,-46.32 39.32,-62.75c-21.17,-7.08 -38.77,-12.83 -47.97,-5.3c-9.2,7.53 -34.2,32.7 -30.85,73.68c3.34,40.98 0.18,194.09 7.43,191.25c3.9,-104.87 37.09,-135 32.07,-196.89z"/>
+    <path android:fillColor="#ffb327" android:pathData="M349.59,337.24c7.24,2.83 4.08,-150.27 7.43,-191.25c3.34,-40.98 -21.65,-66.16 -30.85,-73.68c-9.2,-7.53 -26.8,-1.78 -47.97,5.3c23.95,16.43 35.98,35.98 39.32,62.75c-5.02,61.89 28.17,92.02 32.07,196.89z"/>
+</vector>

app/shared/src/main/res/values-anydpi-v21/drawable.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <drawable name="ic_launcher">@drawable/ic_logo</drawable>
+</resources>