diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index aaffdf2..13db0f9 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -1,12 +1,20 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
           package="masquerade.substratum"
-          android:versionCode="20"
-          android:versionName="twenty - procyon">
+          android:versionCode="21"
+          android:versionName="twentyone - something"
+          coreApp="true"
+          android:sharedUserId="android.uid.system">
 
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
     <uses-permission android:name="android.permission.CHANGE_CONFIGURATION"/>
+    <uses-permission android:name="android.permission.INTERACT_ACROSS_USERS_FULL" />
+    <uses-permission android:name="android.permission.FORCE_STOP_PACKAGES"/>
+    <uses-permission android:name="android.permission.DELETE_PACKAGES"/>
+    <uses-permission android:name="android.permission.INSTALL_PACKAGES"/>
+    <uses-permission android:name="android.permission.INSTALL_GRANT_RUNTIME_PERMISSIONS"/>
+    <uses-permission android:name="android.permission.MODIFY_OVERLAYS"/>
 
     <application
         android:allowBackup="true"
@@ -14,30 +22,19 @@
         android:label="@string/app_name"
         android:supportsRtl="true"
         android:theme="@style/AppTheme">
-        <receiver android:name="masquerade.substratum.services.BootDetector">
+        <receiver android:name=".receivers.BootReceiver">
             <intent-filter>
                 <action android:name="android.intent.action.BOOT_COMPLETED"/>
             </intent-filter>
         </receiver>
-        <receiver android:name=".services.UninstallDetector">
+        <receiver android:name=".receivers.UninstallReceiver">
             <intent-filter>
                 <action android:name="android.intent.action.PACKAGE_REMOVED"/>
                 <data android:scheme="package"/>
             </intent-filter>
         </receiver>
-        <receiver android:name=".util.Helper">
-            <intent-filter>
-                <action android:name="masquerade.substratum.COMMANDS"/>
-            </intent-filter>
-        </receiver>
-
-        <activity android:name="masquerade.substratum.activities.LoaderActivity">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN"/>
-                <action android:name="masquerade.substratum.INITIALIZE"/>
-
-                <category android:name="android.intent.category.DEFAULT"/>
-            </intent-filter>
-        </activity>
+        <service android:name=".services.JobService"
+            android:exported="true"
+            android:permission="android.permission.MODIFY_OVERLAYS" />
     </application>
 </manifest>
diff --git a/app/src/main/java/masquerade/substratum/activities/LoaderActivity.java b/app/src/main/java/masquerade/substratum/activities/LoaderActivity.java
deleted file mode 100644
index 3af5ec3..0000000
--- a/app/src/main/java/masquerade/substratum/activities/LoaderActivity.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package masquerade.substratum.activities;
-
-import android.app.Activity;
-import android.os.Bundle;
-import android.util.Log;
-
-import masquerade.substratum.util.Root;
-
-public class LoaderActivity extends Activity {
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        Log.d("Masquerade", "Masquerade is now securing superuser permissions!");
-        Root.requestRootAccess();
-        finish();
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/masquerade/substratum/receivers/BootReceiver.java b/app/src/main/java/masquerade/substratum/receivers/BootReceiver.java
new file mode 100644
index 0000000..ebc0c8b
--- /dev/null
+++ b/app/src/main/java/masquerade/substratum/receivers/BootReceiver.java
@@ -0,0 +1,13 @@
+package masquerade.substratum.receivers;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+
+public class BootReceiver extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        // do something
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/masquerade/substratum/services/UninstallDetector.java b/app/src/main/java/masquerade/substratum/receivers/UninstallReceiver.java
similarity index 87%
rename from app/src/main/java/masquerade/substratum/services/UninstallDetector.java
rename to app/src/main/java/masquerade/substratum/receivers/UninstallReceiver.java
index 7af387b..b377e27 100644
--- a/app/src/main/java/masquerade/substratum/services/UninstallDetector.java
+++ b/app/src/main/java/masquerade/substratum/receivers/UninstallReceiver.java
@@ -1,4 +1,4 @@
-package masquerade.substratum.services;
+package masquerade.substratum.receivers;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -11,20 +11,18 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import masquerade.substratum.util.ReadOverlaysFile;
-import masquerade.substratum.util.Root;
 
-public class UninstallDetector extends BroadcastReceiver {
+public class UninstallReceiver extends BroadcastReceiver {
     @Override
     public void onReceive(Context context, Intent intent) {
         if ("android.intent.action.PACKAGE_REMOVED".equals(intent.getAction())) {
             Uri packageName = intent.getData();
             if (packageName.toString().substring(8).equals("projekt.substratum")) {
-                new performUninstalls().execute("");
+//                new performUninstalls().execute("");
             }
         }
     }
-
+/*
     public class performUninstalls extends AsyncTask<String, Integer, String> {
         @Override
         protected String doInBackground(String... sUrl) {
@@ -45,4 +43,5 @@
             return null;
         }
     }
+    */
 }
\ No newline at end of file
diff --git a/app/src/main/java/masquerade/substratum/services/BootDetector.java b/app/src/main/java/masquerade/substratum/services/BootDetector.java
deleted file mode 100644
index 3981487..0000000
--- a/app/src/main/java/masquerade/substratum/services/BootDetector.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package masquerade.substratum.services;
-
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-
-import masquerade.substratum.util.Helper;
-
-public class BootDetector extends BroadcastReceiver {
-    @Override
-    public void onReceive(Context context, Intent intent) {
-        Intent pushIntent = new Intent(context, Helper.class);
-        context.startService(pushIntent);
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/masquerade/substratum/services/JobService.java b/app/src/main/java/masquerade/substratum/services/JobService.java
new file mode 100644
index 0000000..3c1b859
--- /dev/null
+++ b/app/src/main/java/masquerade/substratum/services/JobService.java
@@ -0,0 +1,1005 @@
+
+package masquerade.substratum.services;
+
+import android.app.ActivityManager;
+import android.app.ActivityManagerNative;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.IIntentReceiver;
+import android.content.IIntentSender;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.IntentSender;
+import android.content.om.IOverlayManager;
+import android.content.om.OverlayInfo;
+import android.content.pm.IPackageInstallObserver2;
+import android.content.pm.IPackageManager;
+import android.content.pm.PackageInstaller;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.res.AssetManager;
+import android.content.res.Configuration;
+import android.graphics.Typeface;
+import android.media.RingtoneManager;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.FileUtils;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Message;
+import android.os.Process;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.SystemProperties;
+import android.os.UserHandle;
+import android.provider.Settings;
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import masquerade.substratum.utils.IOUtils;
+import masquerade.substratum.utils.SoundUtils;
+
+import com.android.internal.statusbar.IStatusBarService;
+
+public class JobService extends Service {
+    private static final String TAG = JobService.class.getSimpleName();
+    private static final boolean DEBUG = true;
+
+    private static final String MASQUERADE_TOKEN = "masquerade_token";
+    private static final String SUBSTRATUM_PACKAGE = "projekt.substratum";
+    private static final String[] AUTHORIZED_CALLERS = new String[] {
+            SUBSTRATUM_PACKAGE,
+            "masquerade.substratum"
+    };
+
+    public static final String INTENT_STATUS_CHANGED = "masquerade.substratum.STATUS_CHANGED";
+
+    public static final String PRIMARY_COMMAND_KEY = "primary_command_key";
+    public static final String JOB_TIME_KEY = "job_time_key";
+    public static final String INSTALL_LIST_KEY = "install_list";
+    public static final String UNINSTALL_LIST_KEY = "uninstall_list";
+    public static final String WITH_RESTART_UI_KEY = "with_restart_ui";
+    public static final String BOOTANIMATION_FILE_NAME = "bootanimation_file_name";
+    public static final String FONTS_PID = "fonts_pid";
+    public static final String FONTS_FILENAME = "fonts_filename";
+    public static final String AUDIO_PID = "audio_pid";
+    public static final String AUDIO_FILENAME = "audio_filename";
+    public static final String COMMAND_VALUE_JOB_COMPLETE = "job_complete";
+    public static final String COMMAND_VALUE_INSTALL = "install";
+    public static final String COMMAND_VALUE_UNINSTALL = "uninstall";
+    public static final String COMMAND_VALUE_RESTART_UI = "restart_ui";
+    public static final String COMMAND_VALUE_CONFIGURATION_SHIM = "configuration_shim";
+    public static final String COMMAND_VALUE_BOOTANIMATION = "bootanimation";
+    public static final String COMMAND_VALUE_FONTS = "fonts";
+    public static final String COMMAND_VALUE_AUDIO = "audio";
+
+    private static IOverlayManager mOMS;
+    private static IPackageManager mPM;
+
+    private HandlerThread mWorker;
+    private JobHandler mJobHandler;
+    private MainHandler mMainHandler;
+    private final List<Runnable> mJobQueue = new ArrayList<>(0);
+    private long mLastJobTime;
+
+    @Override
+    public void onCreate() {
+        mWorker = new HandlerThread("BackgroundWorker", Process.THREAD_PRIORITY_BACKGROUND);
+        mWorker.start();
+        mJobHandler = new JobHandler(mWorker.getLooper());
+        mMainHandler = new MainHandler(Looper.getMainLooper());
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        // verify identity
+        if (!isCallerAuthorized(intent)) {
+            log("caller not authorized, aborting");
+            return START_NOT_STICKY;
+        }
+
+        // one job at a time please
+        // if (isProcessing()) {
+        // log("Got start command while still processing last job, aborting");
+        // return START_NOT_STICKY;
+        // }
+        // filter out duplicate intents
+        long jobTime = intent.getLongExtra(JOB_TIME_KEY, 1);
+        if (jobTime == 1 || jobTime == mLastJobTime) {
+            log("got empty jobtime or duplicate job time, aborting");
+            return START_NOT_STICKY;
+        }
+        mLastJobTime = jobTime;
+
+        // must have a primary command
+        String command = intent.getStringExtra(PRIMARY_COMMAND_KEY);
+        if (TextUtils.isEmpty(command)) {
+            log("Got empty primary command, aborting");
+            return START_NOT_STICKY;
+        }
+
+        // queue up the job
+
+        List<Runnable> jobs_to_add = new ArrayList<>(0);
+
+        log("Starting job with primary command " + command + " With job time " + jobTime);
+        if (TextUtils.equals(command, COMMAND_VALUE_INSTALL)) {
+            List<String> paths = intent.getStringArrayListExtra(INSTALL_LIST_KEY);
+            for (String path : paths) {
+                jobs_to_add.add(new Installer(path));
+            }
+        } else if (TextUtils.equals(command, COMMAND_VALUE_UNINSTALL)) {
+            List<String> packages = intent.getStringArrayListExtra(UNINSTALL_LIST_KEY);
+            for (String _package : packages) {
+                jobs_to_add.add(new Remover(_package));
+            }
+            if (intent.getBooleanExtra(WITH_RESTART_UI_KEY, false)) {
+                jobs_to_add.add(new UiResetJob());
+            }
+        } else if (TextUtils.equals(command, COMMAND_VALUE_RESTART_UI)) {
+            jobs_to_add.add(new UiResetJob());
+        } else if (TextUtils.equals(command, COMMAND_VALUE_CONFIGURATION_SHIM)) {
+            jobs_to_add.add(new LocaleChanger(getApplicationContext(), mMainHandler));
+        } else if (TextUtils.equals(command, COMMAND_VALUE_BOOTANIMATION)) {
+            String fileName = intent.getStringExtra(BOOTANIMATION_FILE_NAME);
+            if (TextUtils.isEmpty(fileName)) {
+                jobs_to_add.add(new BootAnimationJob(true));
+            } else {
+                jobs_to_add.add(new BootAnimationJob(fileName));
+            }
+        } else if (TextUtils.equals(command, COMMAND_VALUE_FONTS)) {
+            String pid = intent.getStringExtra(FONTS_PID);
+            String fileName = intent.getStringExtra(FONTS_FILENAME);
+            jobs_to_add.add(new FontsJob(pid, fileName));
+            jobs_to_add.add(new UiResetJob());
+        } else if (TextUtils.equals(command, COMMAND_VALUE_AUDIO)) {
+            String pid = intent.getStringExtra(AUDIO_PID);
+            String fileName = intent.getStringExtra(AUDIO_FILENAME);
+            jobs_to_add.add(new SoundsJob(pid, fileName));
+            jobs_to_add.add(new UiResetJob());
+        }
+
+        if (jobs_to_add.size() > 0) {
+            log("Adding new jobs to job queue");
+            synchronized (mJobQueue) {
+                mJobQueue.addAll(jobs_to_add);
+            }
+            if (!mJobHandler.hasMessages(JobHandler.MESSAGE_CHECK_QUEUE)) {
+                mJobHandler.sendEmptyMessage(JobHandler.MESSAGE_CHECK_QUEUE);
+            }
+        }
+
+        return START_NOT_STICKY;
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public void onDestroy() {
+
+    }
+
+    private boolean isProcessing() {
+        return mJobQueue.size() > 0;
+    }
+
+    private class LocalService extends Binder {
+        public JobService getService() {
+            return JobService.this;
+        }
+    }
+
+    private static IOverlayManager getOMS() {
+        if (mOMS == null) {
+            mOMS = IOverlayManager.Stub.asInterface(
+                    ServiceManager.getService("overlay"));
+        }
+        return mOMS;
+    }
+
+    private static IPackageManager getPM() {
+        if (mPM == null) {
+            mPM = IPackageManager.Stub.asInterface(
+                    ServiceManager.getService("package"));
+        }
+        return mPM;
+    }
+
+    private void install(String path, IPackageInstallObserver2 observer) {
+        try {
+            getPM().installPackageAsUser(path, observer, PackageManager.INSTALL_REPLACE_EXISTING,
+                    null,
+                    UserHandle.USER_SYSTEM);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void uninstall(String packageName) {
+        try {
+            final LocalIntentReceiver receiver = new LocalIntentReceiver();
+            getPM().getPackageInstaller().uninstall(packageName, null /* callerPackageName */, 0,
+                    receiver.getIntentSender(), UserHandle.USER_SYSTEM);
+            final Intent result = receiver.getResult();
+            final int status = result.getIntExtra(PackageInstaller.EXTRA_STATUS,
+                    PackageInstaller.STATUS_FAILURE);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void disableOverlay(String packageName) {
+        try {
+            getOMS().setEnabled(packageName, false, UserHandle.USER_SYSTEM, false);
+        } catch (RemoteException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private boolean isOverlayEnabled(String packageName) {
+        boolean enabled = false;
+        try {
+            OverlayInfo info = getOMS().getOverlayInfo(packageName, UserHandle.USER_ALL);
+            enabled = info.isEnabled();
+        } catch (RemoteException e) {
+            e.printStackTrace();
+        }
+        return enabled;
+    }
+
+    private void copyFonts(String pid, String zipFileName) {
+        // prepare local cache dir for font package assembly
+        log("Copy Fonts - Package ID = " + pid + " filename = " + zipFileName);
+        File cacheDir = new File(getCacheDir(), "/FontCache/");
+        if (cacheDir.exists()) {
+            IOUtils.deleteRecursive(cacheDir);
+        }
+        cacheDir.mkdir();
+
+        // copy system fonts into our cache dir
+        IOUtils.copyFolder("/system/fonts", cacheDir.getAbsolutePath());
+
+        // append zip to filename since it is probably removed
+        // for list presentation
+        if (!zipFileName.endsWith(".zip")) {
+            zipFileName = zipFileName + ".zip";
+        }
+
+        // copy target themed fonts zip to our cache dir
+        Context themeContext = getAppContext(pid);
+        AssetManager am = themeContext.getAssets();
+        try {
+            InputStream inputStream = am.open("fonts/" + zipFileName);
+            OutputStream outputStream = new FileOutputStream(getCacheDir()
+                    .getAbsolutePath() + "/FontCache/" + zipFileName);
+            IOUtils.bufferedCopy(inputStream, outputStream);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        // unzip new fonts and delete zip file, overwriting any system fonts
+        File fontZip = new File(getCacheDir(), "/FontCache/" + zipFileName);
+        IOUtils.unzip(fontZip.getAbsolutePath(), cacheDir.getAbsolutePath());
+        fontZip.delete();
+
+        // check if theme zip included a fonts.xml. If not, Substratum
+        // is kind enough to provide one for us in it's assets
+        try {
+            File testConfig = new File(getCacheDir(), "/FontCache/" + "fonts.xml");
+            if (!testConfig.exists()) {
+                Context subContext = getSubsContext();
+                AssetManager subsAm = subContext.getAssets();
+                InputStream inputStream = subsAm.open("fonts.xml");
+                OutputStream outputStream = new FileOutputStream(testConfig);
+                IOUtils.bufferedCopy(inputStream, outputStream);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        // prepare system theme fonts folder and copy new fonts folder from our cache
+        IOUtils.deleteThemedFonts();
+        IOUtils.createFontDirIfNotExists();
+        IOUtils.copyFolder(cacheDir.getAbsolutePath(), IOUtils.SYSTEM_THEME_FONT_PATH);
+
+        // set permissions on font files and config xml
+        File themeFonts = new File(IOUtils.SYSTEM_THEME_FONT_PATH);
+        for (File f : themeFonts.listFiles()) {
+            FileUtils.setPermissions(f,
+                    FileUtils.S_IRWXU | FileUtils.S_IRGRP | FileUtils.S_IRWXO, -1, -1);
+        }
+
+        // let system know it's time for a font change
+        SystemProperties.set("sys.refresh_theme", "1");
+        float fontSize = Float.valueOf(Settings.System.getString(
+                getContentResolver(), Settings.System.FONT_SCALE));
+        Settings.System.putString(getContentResolver(),
+                Settings.System.FONT_SCALE, String.valueOf(fontSize + 0.0000001));
+    }
+
+    private void clearFonts() {
+        IOUtils.deleteThemedFonts();
+        SystemProperties.set("sys.refresh_theme", "1");
+        Typeface.recreateDefaults();
+        float fontSize = Float.valueOf(Settings.System.getString(
+                getContentResolver(), Settings.System.FONT_SCALE));
+        Settings.System.putString(getContentResolver(),
+                Settings.System.FONT_SCALE, String.valueOf(fontSize + 0.0000001));
+    }
+
+    private void applyThemedSounds(String pid, String zipFileName) {
+        // prepare local cache dir for font package assembly
+        log("Copy sounds - Package ID = " + pid + " filename = " + zipFileName);
+        File cacheDir = new File(getCacheDir(), "/SoundsCache/");
+        if (cacheDir.exists()) {
+            IOUtils.deleteRecursive(cacheDir);
+        }
+        cacheDir.mkdir();
+
+        // append zip to filename since it is probably removed
+        // for list presentation
+        if (!zipFileName.endsWith(".zip")) {
+            zipFileName = zipFileName + ".zip";
+        }
+
+        // copy target themed sounds zip to our cache dir
+        Context themeContext = getAppContext(pid);
+        AssetManager am = themeContext.getAssets();
+        try {
+            InputStream inputStream = am.open("audio/" + zipFileName);
+            OutputStream outputStream = new FileOutputStream(getCacheDir()
+                    .getAbsolutePath() + "/SoundsCache/" + zipFileName);
+            IOUtils.bufferedCopy(inputStream, outputStream);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        // unzip new sounds and delete zip file
+        File soundsZip = new File(getCacheDir(), "/SoundsCache/" + zipFileName);
+        IOUtils.unzip(soundsZip.getAbsolutePath(), cacheDir.getAbsolutePath());
+        soundsZip.delete();
+
+        clearSounds(this);
+        IOUtils.createAudioDirIfNotExists();
+
+        File uiSoundsCache = new File(getCacheDir(), "/SoundsCache/ui/");
+        if (uiSoundsCache.exists() && uiSoundsCache.isDirectory()) {
+            IOUtils.createUiSoundsDirIfNotExists();
+            File effect_tick_mp3 = new File(getCacheDir(), "/SoundsCache/ui/Effect_Tick.mp3");
+            File effect_tick_ogg = new File(getCacheDir(), "/SoundsCache/ui/Effect_Tick.ogg");
+            if (effect_tick_ogg.exists()) {
+                IOUtils.bufferedCopy(effect_tick_ogg, new File(IOUtils.SYSTEM_THEME_UI_SOUNDS_PATH + File.separator + "Effect_Tick.ogg"));
+                SoundUtils.setUIAudible(this, effect_tick_ogg, new File
+                        ("/data/system/theme/audio/ui/Effect_Tick.ogg"), RingtoneManager
+                        .TYPE_RINGTONE, "Effect_Tick");
+            } else if (effect_tick_mp3.exists()) {
+                IOUtils.bufferedCopy(effect_tick_mp3, new File(IOUtils.SYSTEM_THEME_UI_SOUNDS_PATH + File.separator + "Effect_Tick.mp3"));
+                SoundUtils.setUIAudible(this, effect_tick_mp3, new File
+                        ("/data/system/theme/audio/ui/Effect_Tick.mp3"), RingtoneManager
+                        .TYPE_RINGTONE, "Effect_Tick");
+            } else {
+                SoundUtils.setDefaultUISounds(getContentResolver(), "lock_sound", "Lock.ogg");
+            }
+            File new_lock_mp3 = new File(getCacheDir(), "/SoundsCache/ui/Lock.mp3");
+            File new_lock_ogg = new File(getCacheDir(), "/SoundsCache/ui/Lock.ogg");
+            if (new_lock_ogg.exists()) {
+                IOUtils.bufferedCopy(new_lock_ogg, new File(IOUtils.SYSTEM_THEME_UI_SOUNDS_PATH + File.separator + "Lock.ogg"));
+                SoundUtils.setUISounds(getContentResolver(), "lock_sound", "/data/system/theme/audio/ui/Lock.ogg");
+            } else if (new_lock_mp3.exists()) {
+                IOUtils.bufferedCopy(new_lock_mp3, new File(IOUtils.SYSTEM_THEME_UI_SOUNDS_PATH + File.separator + "Lock.mp3"));
+                SoundUtils.setUISounds(getContentResolver(), "lock_sound", "/data/system/theme/audio/ui/Lock.mp3");
+            } else {
+                SoundUtils.setDefaultUISounds(getContentResolver(), "lock_sound", "Lock.ogg");
+            }
+            File new_unlock_mp3 = new File(getCacheDir(), "/SoundsCache/ui/Unlock.mp3");
+            File new_unlock_ogg = new File(getCacheDir(), "/SoundsCache/ui/Unlock.ogg");
+            if (new_unlock_ogg.exists()) {
+                IOUtils.bufferedCopy(new_unlock_ogg, new File(IOUtils.SYSTEM_THEME_UI_SOUNDS_PATH + File.separator + "Unlock.ogg"));
+                SoundUtils.setUISounds(getContentResolver(), "unlock_sound", "/data/system/theme/audio/ui/Unlock.ogg");
+            } else if (new_unlock_mp3.exists()) {
+                IOUtils.bufferedCopy(new_unlock_mp3, new File(IOUtils.SYSTEM_THEME_UI_SOUNDS_PATH + File.separator + "Unlock.mp3"));
+                SoundUtils.setUISounds(getContentResolver(), "unlock_sound", "/data/system/theme/audio/ui/Unlock.mp3");
+            } else {
+                SoundUtils.setDefaultUISounds(getContentResolver(), "unlock_sound", "Unlock.ogg");
+            }
+            File new_lowbattery_mp3 = new File(getCacheDir(), "/SoundsCache/ui/LowBattery.mp3");
+            File new_lowbattery_ogg = new File(getCacheDir(), "/SoundsCache/ui/LowBattery.ogg");
+            if (new_lowbattery_ogg.exists()) {
+                IOUtils.bufferedCopy(new_lowbattery_ogg, new File(IOUtils.SYSTEM_THEME_UI_SOUNDS_PATH + File.separator + "LowBattery.ogg"));
+                SoundUtils.setUISounds(getContentResolver(), "low_battery_sound", "/data/system/theme/audio/ui/LowBattery.ogg");
+            } else if (new_lowbattery_mp3.exists()) {
+                IOUtils.bufferedCopy(new_lowbattery_mp3, new File(IOUtils.SYSTEM_THEME_UI_SOUNDS_PATH + File.separator + "LowBattery.mp3"));
+                SoundUtils.setUISounds(getContentResolver(), "low_battery_sound", "/data/system/theme/audio/ui/LowBattery.mp3");
+            } else {
+                SoundUtils.setDefaultUISounds(getContentResolver(), "low_battery_sound", "LowBattery.ogg");
+            }
+            File uiSounds = new File(IOUtils.SYSTEM_THEME_UI_SOUNDS_PATH);
+            if (uiSounds.exists() && uiSounds.isDirectory()) {
+                for (File f : uiSounds.listFiles()) {
+                    FileUtils.setPermissions(f,
+                            FileUtils.S_IRWXU | FileUtils.S_IRGRP | FileUtils.S_IRWXO, -1, -1);
+                }
+            }
+        }
+        File alarmCache = new File(getCacheDir(), "/SoundsCache/alarms/");
+        if (alarmCache.exists() && alarmCache.isDirectory()) {
+            IOUtils.createAlarmDirIfNotExists();
+            File new_alarm_mp3 = new File(getCacheDir(), "/SoundsCache/alarms/alarm.mp3");
+            File new_alarm_ogg = new File(getCacheDir(), "/SoundsCache/alarms/alarm.ogg");
+            if (new_alarm_ogg.exists()) {
+                IOUtils.bufferedCopy(new_alarm_ogg, new File(IOUtils.SYSTEM_THEME_ALARM_PATH + File.separator + "alarm.ogg"));
+                int metaDataId = getSubsContext().getResources().getIdentifier("content_resolver_alarm_metadata", "string", SUBSTRATUM_PACKAGE);
+                SoundUtils.setAudible(this, new File("/data/system/theme/audio/alarms/alarm.ogg"),
+                        new File(alarmCache.getAbsolutePath(), "alarm.ogg"),
+                        RingtoneManager.TYPE_ALARM,
+                        getSubsContext().getString(metaDataId));
+            } else if (new_alarm_mp3.exists()) {
+                IOUtils.bufferedCopy(new_alarm_mp3, new File(IOUtils.SYSTEM_THEME_ALARM_PATH + File.separator + "alarm.mp3"));
+                int metaDataId = getSubsContext().getResources().getIdentifier("content_resolver_alarm_metadata", "string", SUBSTRATUM_PACKAGE);
+                SoundUtils.setAudible(this, new File("/data/system/theme/audio/alarms/alarm.mp3"),
+                        new File(alarmCache.getAbsolutePath(), "alarm.mp3"),
+                        RingtoneManager.TYPE_ALARM,
+                        getSubsContext().getString(metaDataId));
+            } else {
+                SoundUtils.setDefaultAudible(this, RingtoneManager.TYPE_ALARM);
+            }
+            File alarms = new File(IOUtils.SYSTEM_THEME_ALARM_PATH);
+            if (alarms.exists() && alarms.isDirectory()) {
+                for (File f : alarms.listFiles()) {
+                    FileUtils.setPermissions(f,
+                            FileUtils.S_IRWXU | FileUtils.S_IRGRP | FileUtils.S_IRWXO, -1, -1);
+                }
+            }
+        }
+        File notifCache = new File(getCacheDir(), "/SoundsCache/notifications/");
+        if (notifCache.exists() && notifCache.isDirectory()) {
+            IOUtils.createNotificationDirIfNotExists();
+            File new_notif_mp3 = new File(getCacheDir(), "/SoundsCache/notifications/notification.mp3");
+            File new_notif_ogg = new File(getCacheDir(), "/SoundsCache/notifications/notification.ogg");
+            if (new_notif_ogg.exists()) {
+                IOUtils.bufferedCopy(new_notif_ogg, new File(IOUtils.SYSTEM_THEME_NOTIFICATION_PATH + File.separator + "notification.ogg"));
+                int metaDataId = getSubsContext().getResources().getIdentifier("content_resolver_notification_metadata", "string", SUBSTRATUM_PACKAGE);
+                SoundUtils.setAudible(this, new File("/data/system/theme/audio/notifications/notification.ogg"),
+                        new File(notifCache.getAbsolutePath(), "notification.ogg"),
+                        RingtoneManager.TYPE_NOTIFICATION,
+                        getSubsContext().getString(metaDataId));
+            } else if (new_notif_mp3.exists()) {
+                IOUtils.bufferedCopy(new_notif_mp3, new File(IOUtils.SYSTEM_THEME_NOTIFICATION_PATH + File.separator + "notification.mp3"));
+                int metaDataId = getSubsContext().getResources().getIdentifier("content_resolver_notification_metadata", "string", SUBSTRATUM_PACKAGE);
+                SoundUtils.setAudible(this, new File("/data/system/theme/audio/notifications/notification.mp3"),
+                        new File(notifCache.getAbsolutePath(), "notification.mp3"),
+                        RingtoneManager.TYPE_NOTIFICATION,
+                        getSubsContext().getString(metaDataId));
+            } else {
+                SoundUtils.setDefaultAudible(this, RingtoneManager.TYPE_NOTIFICATION);
+            }
+            File notifs = new File(IOUtils.SYSTEM_THEME_NOTIFICATION_PATH);
+            if (notifs.exists() && notifs.isDirectory()) {
+                for (File f : notifs.listFiles()) {
+                    FileUtils.setPermissions(f,
+                            FileUtils.S_IRWXU | FileUtils.S_IRGRP | FileUtils.S_IRWXO, -1, -1);
+                }
+            }
+        }
+        File ringtoneCache = new File(getCacheDir(), "/SoundsCache/ringtones/");
+        if (ringtoneCache.exists() && ringtoneCache.isDirectory()) {
+            IOUtils.createRingtoneDirIfNotExists();
+            File new_ring_mp3 = new File(getCacheDir(), "/SoundsCache/ringtones/ringtone.mp3");
+            File new_ring_ogg = new File(getCacheDir(), "/SoundsCache/ringtones/ringtone.ogg");
+            if (new_ring_ogg.exists()) {
+                IOUtils.bufferedCopy(new_ring_ogg, new File(IOUtils.SYSTEM_THEME_RINGTONE_PATH + File.separator + "ringtone.ogg"));
+                int metaDataId = getSubsContext().getResources().getIdentifier("content_resolver_ringtone_metadata", "string", SUBSTRATUM_PACKAGE);
+                SoundUtils.setAudible(this, new File("/data/system/theme/audio/ringtones/ringtone.ogg"),
+                        new File(notifCache.getAbsolutePath(), "ringtone.ogg"),
+                        RingtoneManager.TYPE_RINGTONE,
+                        getSubsContext().getString(metaDataId));
+            } else if (new_ring_mp3.exists()) {
+                IOUtils.bufferedCopy(new_ring_mp3, new File(IOUtils.SYSTEM_THEME_RINGTONE_PATH + File.separator + "ringtone.mp3"));
+                int metaDataId = getSubsContext().getResources().getIdentifier("content_resolver_ringtone_metadata", "string", SUBSTRATUM_PACKAGE);
+                SoundUtils.setAudible(this, new File("/data/system/theme/audio/ringtones/ringtone.mp3"),
+                        new File(notifCache.getAbsolutePath(), "ringtone.mp3"),
+                        RingtoneManager.TYPE_RINGTONE,
+                        getSubsContext().getString(metaDataId));
+            } else {
+                SoundUtils.setDefaultAudible(this, RingtoneManager.TYPE_RINGTONE);
+            }
+            File rings = new File(IOUtils.SYSTEM_THEME_RINGTONE_PATH);
+            if (rings.exists() && rings.isDirectory()) {
+                for (File f : rings.listFiles()) {
+                    FileUtils.setPermissions(f,
+                            FileUtils.S_IRWXU | FileUtils.S_IRGRP | FileUtils.S_IRWXO, -1, -1);
+                }
+            }
+        }
+    }
+
+    private void clearSounds(Context ctx) {
+        IOUtils.deleteThemedAudio();
+        SoundUtils.setDefaultAudible(JobService.this, RingtoneManager.TYPE_ALARM);
+        SoundUtils.setDefaultAudible(JobService.this, RingtoneManager.TYPE_NOTIFICATION);
+        SoundUtils.setDefaultAudible(JobService.this, RingtoneManager.TYPE_RINGTONE);
+        SoundUtils.setDefaultUISounds(getContentResolver(), "lock_sound", "Lock.ogg");
+        SoundUtils.setDefaultUISounds(getContentResolver(), "unlock_sound", "Unlock.ogg");
+        SoundUtils.setDefaultUISounds(getContentResolver(), "low_battery_sound",
+                "LowBattery.ogg");
+    }
+
+    private void copyBootAnimation(String fileName) {
+        try {
+            clearBootAnimation();
+            File source = new File(fileName);
+            File dest = new File(IOUtils.SYSTEM_THEME_BOOTANIMATION_PATH);
+            IOUtils.bufferedCopy(source, dest);
+            source.delete();
+            FileUtils.setPermissions(IOUtils.SYSTEM_THEME_BOOTANIMATION_PATH,
+                    FileUtils.S_IRWXU | FileUtils.S_IRGRP | FileUtils.S_IROTH, -1, -1);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void clearBootAnimation() {
+        try {
+            File f = new File(IOUtils.SYSTEM_THEME_BOOTANIMATION_PATH);
+            if (f.exists()) {
+                f.delete();
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void restartUi() {
+        try {
+            ActivityManager am = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
+            Class ActivityManagerNative = Class.forName("android.app.ActivityManagerNative");
+            Method getDefault = ActivityManagerNative.getDeclaredMethod("getDefault", null);
+            Object amn = getDefault.invoke(null, null);
+            Method killApplicationProcess = amn.getClass().getDeclaredMethod("killApplicationProcess", String.class, int.class);
+            stopService(new Intent().setComponent(new ComponentName("com.android.systemui", "com.android.systemui.SystemUIService")));
+            am.killBackgroundProcesses("com.android.systemui");
+            for (ActivityManager.RunningAppProcessInfo app : am.getRunningAppProcesses()) {
+                if ("com.android.systemui".equals(app.processName)) {
+                    killApplicationProcess.invoke(amn, app.processName, app.uid);
+                    break;
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void killPackage(String packageName) {
+        try {
+            ActivityManagerNative.getDefault().forceStopPackage(packageName,
+                    UserHandle.USER_SYSTEM);
+        } catch (RemoteException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private Context getSubsContext() {
+        return getAppContext(SUBSTRATUM_PACKAGE);
+    }
+
+    private Context getAppContext(String packageName) {
+        Context ctx = null;
+        try {
+            ctx = getApplicationContext().createPackageContext(packageName,
+                    Context.CONTEXT_IGNORE_SECURITY);
+        } catch (NameNotFoundException e) {
+            e.printStackTrace();
+        }
+        return ctx;
+    }
+
+    public static void log(String msg) {
+        if (DEBUG) {
+            Log.e(TAG, msg);
+        }
+    }
+
+    private boolean isCallerAuthorized(Intent intent) {
+        PendingIntent token = null;
+        try {
+            token = (PendingIntent) intent.getParcelableExtra(MASQUERADE_TOKEN);
+        } catch (Exception e) {
+            log("Attempt to start serivce without a token, unauthorized");
+        }
+        if (token == null) {
+            return false;
+        }
+        // SECOND: we got a token, validate originating package
+        // if not in our whitelist, return null
+        String callingPackage = token.getCreatorPackage();
+        boolean isValidPackage = false;
+        for (int i = 0; i < AUTHORIZED_CALLERS.length; i++) {
+            if (TextUtils.equals(callingPackage, AUTHORIZED_CALLERS[i])) {
+                log(callingPackage
+                        + " is an authorized calling package, next validate calling package perms");
+                isValidPackage = true;
+                break;
+            }
+        }
+        if (!isValidPackage) {
+            log(callingPackage + " is not an authorized calling package");
+            return false;
+        }
+        return true;
+    }
+
+    private class MainHandler extends Handler {
+        public static final int MSG_JOB_QUEUE_EMPTY = 1;
+
+        public MainHandler(Looper looper) {
+            super(looper);
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case MSG_JOB_QUEUE_EMPTY:
+                    Intent intent = new Intent(INTENT_STATUS_CHANGED);
+                    intent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_JOB_COMPLETE);
+                    sendBroadcastAsUser(intent, UserHandle.ALL);
+                    break;
+            }
+        }
+    }
+
+    private class JobHandler extends Handler {
+        private static final int MESSAGE_CHECK_QUEUE = 1;
+        private static final int MESSAGE_DEQUEUE = 2;
+
+        public JobHandler(Looper looper) {
+            super(looper);
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case MESSAGE_CHECK_QUEUE:
+                    Runnable job;
+                    synchronized (mJobQueue) {
+                        job = mJobQueue.get(0);
+                    }
+                    if (job != null) {
+                        job.run();
+                    }
+                    break;
+                case MESSAGE_DEQUEUE:
+                    Runnable toRemove = (Runnable) msg.obj;
+                    synchronized (mJobQueue) {
+                        mJobQueue.remove(toRemove);
+                        if (mJobQueue.size() > 0) {
+                            this.sendEmptyMessage(MESSAGE_CHECK_QUEUE);
+                        } else {
+                            log("Job queue empty! All done");
+                            mMainHandler.sendEmptyMessage(MainHandler.MSG_JOB_QUEUE_EMPTY);
+                        }
+                    }
+                    break;
+                default:
+                    log("Unknown message " + msg.what);
+                    break;
+            }
+        }
+    }
+
+    private class StopPackageJob implements Runnable {
+        String mPackage;
+
+        public void StopPackageJob(String _package) {
+            mPackage = _package;
+        }
+
+        @Override
+        public void run() {
+            killPackage(mPackage);
+            log("Killed package " + mPackage);
+            Message message = mJobHandler.obtainMessage(JobHandler.MESSAGE_DEQUEUE,
+                    StopPackageJob.this);
+            mJobHandler.sendMessage(message);
+        }
+    }
+
+    private class UiResetJob implements Runnable {
+        @Override
+        public void run() {
+            restartUi();
+            log("Restarting SystemUI...");
+            Message message = mJobHandler.obtainMessage(JobHandler.MESSAGE_DEQUEUE,
+                    UiResetJob.this);
+            mJobHandler.sendMessage(message);
+        }
+    }
+
+    private class FontsJob implements Runnable {
+        boolean mClear;
+        String mPid;
+        String mFileName;
+
+        public FontsJob(String pid, String fileName) {
+            if (pid == null) {
+                mClear = true;
+            } else {
+                mPid = pid;
+                mFileName = fileName;
+            }
+        }
+
+        @Override
+        public void run() {
+            if (mClear) {
+                log("Resetting system font");
+                clearFonts();
+            } else {
+                log("Setting theme font");
+                copyFonts(mPid, mFileName);
+            }
+            Intent intent = new Intent(INTENT_STATUS_CHANGED);
+            intent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_FONTS);
+            sendBroadcastAsUser(intent, UserHandle.ALL);
+            Message message = mJobHandler.obtainMessage(JobHandler.MESSAGE_DEQUEUE,
+                    FontsJob.this);
+            mJobHandler.sendMessage(message);
+        }
+    }
+
+    private class SoundsJob implements Runnable {
+        boolean mClear;
+        String mPid;
+        String mFileName;
+
+        public SoundsJob(String pid, String fileName) {
+            if (pid == null) {
+                mClear = true;
+            } else {
+                mPid = pid;
+                mFileName = fileName;
+            }
+        }
+
+        @Override
+        public void run() {
+            if (mClear) {
+                log("Resetting system sounds");
+                clearSounds(JobService.this);
+            } else {
+                log("Setting theme sounds");
+                applyThemedSounds(mPid, mFileName);
+            }
+            Intent intent = new Intent(INTENT_STATUS_CHANGED);
+            intent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_AUDIO);
+            sendBroadcastAsUser(intent, UserHandle.ALL);
+            Message message = mJobHandler.obtainMessage(JobHandler.MESSAGE_DEQUEUE,
+                    SoundsJob.this);
+            mJobHandler.sendMessage(message);
+        }
+    }
+
+    private class BootAnimationJob implements Runnable {
+        String mFileName;
+        final boolean mClear;
+
+        public BootAnimationJob(boolean clear) {
+            mClear = true;
+        }
+
+        public BootAnimationJob(String fileName) {
+            mFileName = fileName;
+            mClear = false;
+        }
+
+        @Override
+        public void run() {
+            if (mClear) {
+                log("Resetting system boot animation");
+                clearBootAnimation();
+            } else {
+                log("Setting themed boot animation");
+                copyBootAnimation(mFileName);
+            }
+            Intent intent = new Intent(INTENT_STATUS_CHANGED);
+            intent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_BOOTANIMATION);
+            sendBroadcastAsUser(intent, UserHandle.ALL);
+            Message message = mJobHandler.obtainMessage(JobHandler.MESSAGE_DEQUEUE,
+                    BootAnimationJob.this);
+            mJobHandler.sendMessage(message);
+        }
+    }
+
+    private class Installer implements Runnable, IPackageInstallObserver2 {
+        String mPath;
+
+        public Installer(String path) {
+            mPath = path;
+        }
+
+        @Override
+        public IBinder asBinder() {
+            return null;
+        }
+
+        @Override
+        public void onUserActionRequired(Intent intent) throws RemoteException {
+            log("Installer - user action required callback with " + mPath);
+        }
+
+        @Override
+        public void onPackageInstalled(String basePackageName, int returnCode, String msg,
+                Bundle extras) throws RemoteException {
+            log("Installer - successfully installed " + basePackageName + " from " + mPath);
+            Message message = mJobHandler.obtainMessage(JobHandler.MESSAGE_DEQUEUE, Installer.this);
+            mJobHandler.sendMessage(message);
+        }
+
+        @Override
+        public void run() {
+            log("Installer - installing " + mPath);
+            install(mPath, this);
+        }
+    }
+
+    private class Remover implements Runnable {
+        String mPackage;
+
+        public Remover(String _package) {
+            mPackage = _package;
+        }
+
+        @Override
+        public void run() {
+            if (isOverlayEnabled(mPackage)) {
+                log("Remover - disabling overlay for " + mPackage);
+                disableOverlay(mPackage);
+            }
+            log("Remover - uninstalling " + mPackage);
+            uninstall(mPackage);
+        }
+    }
+
+    private class LocaleChanger extends BroadcastReceiver implements Runnable {
+        private boolean mIsRegistered;
+        private boolean mDoRestore;
+        private Context mContext;
+        private Handler mHandler;
+        private Locale mCurrentLocale;
+
+        public LocaleChanger(Context context, Handler mainHandler) {
+            mContext = context;
+            mHandler = mainHandler;
+        }
+
+        @Override
+        public void run() {
+            Intent i = new Intent(Intent.ACTION_MAIN);
+            i.addCategory(Intent.CATEGORY_HOME);
+            mContext.startActivity(i);
+            mHandler.postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    spoofLocale();
+                }
+            }, 500);
+        }
+
+        private void register() {
+            if (!mIsRegistered) {
+                IntentFilter filter = new IntentFilter();
+                filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);
+                mContext.registerReceiver(LocaleChanger.this, filter);
+                mIsRegistered = true;
+            }
+        }
+
+        private void unregister() {
+            if (mIsRegistered) {
+                mContext.unregisterReceiver(LocaleChanger.this);
+                mIsRegistered = false;
+            }
+        }
+
+        private void spoofLocale() {
+            Configuration config;
+            log("LocaleChanger - spoofing locale for configuation change shim");
+            try {
+                register();
+                config = ActivityManagerNative.getDefault().getConfiguration();
+                mCurrentLocale = config.locale;
+                Locale toSpoof = Locale.JAPAN;
+                if (mCurrentLocale == Locale.JAPAN) {
+                    toSpoof = Locale.CHINA;
+                }
+                config.setLocale(toSpoof);
+                config.userSetLocale = true;
+                ActivityManagerNative.getDefault().updateConfiguration(config);
+            } catch (RemoteException e) {
+                e.printStackTrace();
+                return;
+            }
+        }
+
+        private void restoreLocale() {
+            Configuration config;
+            log("LocaleChanger - restoring original locale for configuation change shim");
+            try {
+                unregister();
+                config = ActivityManagerNative.getDefault().getConfiguration();
+                config.setLocale(mCurrentLocale);
+                config.userSetLocale = true;
+                ActivityManagerNative.getDefault().updateConfiguration(config);
+            } catch (RemoteException e) {
+                e.printStackTrace();
+                return;
+            }
+            Message message = mJobHandler.obtainMessage(JobHandler.MESSAGE_DEQUEUE,
+                    LocaleChanger.this);
+            mJobHandler.sendMessage(message);
+        }
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            mHandler.postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    restoreLocale();
+                }
+            }, 500);
+        }
+    }
+
+    private static class LocalIntentReceiver {
+        private final SynchronousQueue<Intent> mResult = new SynchronousQueue<>();
+
+        private IIntentSender.Stub mLocalSender = new IIntentSender.Stub() {
+            @Override
+            public void send(int code, Intent intent, String resolvedType,
+                    IIntentReceiver finishedReceiver, String requiredPermission, Bundle options) {
+                try {
+                    mResult.offer(intent, 5, TimeUnit.SECONDS);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        };
+
+        public IntentSender getIntentSender() {
+            return new IntentSender((IIntentSender) mLocalSender);
+        }
+
+        public Intent getResult() {
+            try {
+                return mResult.take();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/masquerade/substratum/services/MasqDemo.java b/app/src/main/java/masquerade/substratum/services/MasqDemo.java
new file mode 100644
index 0000000..b00d6e0
--- /dev/null
+++ b/app/src/main/java/masquerade/substratum/services/MasqDemo.java
@@ -0,0 +1,137 @@
+
+package masquerade.substratum.services;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.text.TextUtils;
+
+public class MasqDemo {
+    public static final String MASQUERADE_TOKEN = "masquerade_token";
+    public static final String PRIMARY_COMMAND_KEY = "primary_command_key";
+    public static final String JOB_TIME_KEY = "job_time_key";
+    public static final String INSTALL_LIST_KEY = "install_list";
+    public static final String UNINSTALL_LIST_KEY = "uninstall_list";
+    public static final String WITH_RESTART_UI_KEY = "with_restart_ui";
+    public static final String BOOTANIMATION_PID_KEY = "bootanimation_pid";
+    public static final String BOOTANIMATION_FILE_NAME = "bootanimation_file_name";
+    public static final String FONTS_PID = "fonts_pid";
+    public static final String FONTS_FILENAME = "fonts_filename";
+    public static final String AUDIO_PID = "audio_pid";
+    public static final String AUDIO_FILENAME = "audio_filename";
+    public static final String COMMAND_VALUE_INSTALL = "install";
+    public static final String COMMAND_VALUE_UNINSTALL = "uninstall";
+    public static final String COMMAND_VALUE_RESTART_UI = "restart_ui";
+    public static final String COMMAND_VALUE_CONFIGURATION_SHIM = "configuration_shim";
+    public static final String COMMAND_VALUE_BOOTANIMATION = "bootanimation";
+    public static final String COMMAND_VALUE_FONTS = "fonts";
+    public static final String COMMAND_VALUE_AUDIO = "audio";
+    public static final String INTENT_STATUS_CHANGED = "masquerade.substratum.STATUS_CHANGED";
+    public static final String COMMAND_VALUE_JOB_COMPLETE = "job_complete";
+
+    class MasqReceiver extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (TextUtils.equals(intent.getAction(), INTENT_STATUS_CHANGED)) {
+                String command = intent.getStringExtra(PRIMARY_COMMAND_KEY);
+                if (TextUtils.equals(command, COMMAND_VALUE_FONTS)) {
+                    // update ui, dismiss progress dialog, etc
+                } else if (TextUtils.equals(command, COMMAND_VALUE_BOOTANIMATION)) {
+
+                } else if (TextUtils.equals(command, COMMAND_VALUE_AUDIO)) {
+
+                } else if (TextUtils.equals(command, COMMAND_VALUE_JOB_COMPLETE)) {
+
+                }
+            }
+        }
+    }
+
+    // demo code for building a base intent for JobService commands
+    public static Intent getMasqIntent(Context ctx) {
+        Intent intent = new Intent();
+        intent.setClassName("masquerade.substratum", "masquerade.substratum.services.JobService");
+        // Credit StackOverflow http://stackoverflow.com/a/28132098
+        // Use dummy PendingIntent for service to validate caller at onBind
+        PendingIntent pending = PendingIntent.getActivity(ctx, 0, new Intent(), 0);
+        intent.putExtra(MASQUERADE_TOKEN, pending);
+        intent.putExtra(JOB_TIME_KEY, System.currentTimeMillis());
+        return intent;
+    }
+
+    public static void install(Context context, ArrayList<String> overlay_apks) {
+        // populate list however
+        Intent masqIntent = getMasqIntent(context);
+        masqIntent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_INSTALL);
+        masqIntent.putExtra(INSTALL_LIST_KEY, overlay_apks);
+        context.startService(masqIntent);
+    }
+
+    public static void uninstall(Context context, ArrayList<String> packages_to_remove) {
+        Intent masqIntent = getMasqIntent(context);
+        masqIntent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_UNINSTALL);
+        masqIntent.putExtra(UNINSTALL_LIST_KEY, packages_to_remove);
+        // only need to set if true, will restart SystemUI when done processing packages
+        masqIntent.putExtra(WITH_RESTART_UI_KEY, true);
+        context.startService(masqIntent);
+    }
+
+    public static void restartSystemUI(Context context) {
+        Intent masqIntent = getMasqIntent(context);
+        masqIntent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_RESTART_UI);
+        context.startService(masqIntent);
+    }
+
+    public static void configurationChangeShim(Context context) {
+        Intent masqIntent = getMasqIntent(context);
+        masqIntent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_CONFIGURATION_SHIM);
+        context.startService(masqIntent);
+    }
+    
+    public static void clearThemedBootAnimation(Context context) {
+        applyThemedBootAnimation(context, null);
+    }
+    
+    public static void applyThemedBootAnimation(Context context, String fileName) {
+        Intent masqIntent = getMasqIntent(context);
+        masqIntent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_BOOTANIMATION);
+        if (fileName != null) {
+            masqIntent.putExtra(BOOTANIMATION_FILE_NAME, fileName);
+        } else {
+            // nothing. to reset to stock, just don't add PID and FILE
+        }
+        context.startService(masqIntent);
+    }
+    
+    public static void clearThemedFont(Context context) {
+        applyThemedFont(context, null, null);
+    }
+
+    public static void applyThemedFont(Context context, String pid, String fileName) {
+        Intent masqIntent = getMasqIntent(context);
+        masqIntent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_FONTS);
+        if (pid != null) {
+            masqIntent.putExtra(FONTS_PID, pid);
+            masqIntent.putExtra(FONTS_FILENAME, fileName);
+        }
+        context.startService(masqIntent);
+    }
+
+    public static void clearThemedSounds(Context context) {
+        applyThemedSounds(context, null, null);
+    }
+
+    public static void applyThemedSounds(Context context, String pid, String fileName) {
+        Intent masqIntent = getMasqIntent(context);
+        masqIntent.putExtra(PRIMARY_COMMAND_KEY, COMMAND_VALUE_AUDIO);
+        if (pid != null) {
+            masqIntent.putExtra(AUDIO_PID, pid);
+            masqIntent.putExtra(AUDIO_FILENAME, fileName);
+        }
+        context.startService(masqIntent);
+    }
+}
diff --git a/app/src/main/java/masquerade/substratum/util/Helper.java b/app/src/main/java/masquerade/substratum/util/Helper.java
deleted file mode 100644
index cccf493..0000000
--- a/app/src/main/java/masquerade/substratum/util/Helper.java
+++ /dev/null
@@ -1,113 +0,0 @@
-package masquerade.substratum.util;
-
-import android.app.PendingIntent;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.os.Handler;
-import android.text.TextUtils;
-import android.util.Log;
-
-public class Helper extends BroadcastReceiver {
-
-    private static final String SUBSTRATUM_PACKAGE = "projekt.substratum";
-    private static final String MASQUERADE_TOKEN = "masquerade_token";
-    private static final String[] AUTHORIZED_CALLERS = new String[]{
-            SUBSTRATUM_PACKAGE,
-            "masquerade.substratum"
-    };
-
-    @Override
-    public void onReceive(Context context, Intent intent) {
-        if (!isCallerAuthorized(intent)) {
-            Log.d("Masquerade", "Caller not authorized");
-            return;
-        }
-        Log.d("Masquerade",
-                "BroadcastReceiver has accepted Substratum's commands and is running now...");
-        Root.requestRootAccess();
-
-        if (intent.getStringExtra("substratum-check") != null) {
-            if (intent.getStringExtra("substratum-check").equals("masquerade-ball")) {
-                Intent runCommand = new Intent();
-                runCommand.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
-                runCommand.setAction("projekt.substratum.MASQUERADE_BALL");
-                runCommand.putExtra("substratum-check", "masquerade-ball");
-                context.sendBroadcast(runCommand);
-                Log.d("Masquerade", "BroadcastReceiver was triggered to check for system " +
-                        "integrity and service activation.");
-            }
-        } else if (intent.getStringArrayListExtra("pm-uninstall") != null) {
-            new Uninstaller().uninstall(intent, "pm-uninstall", false,
-                    intent.getBooleanExtra("restart_systemui", false));
-        } else if (intent.getStringArrayListExtra("pm-uninstall-specific") != null) {
-            new Uninstaller().uninstall(intent, "pm-uninstall-specific", true,
-                    intent.getBooleanExtra("restart_systemui", false));
-        } else if (intent.getStringArrayListExtra("icon-handler") != null) {
-            String icon_pack_name = intent.getStringArrayListExtra("icon-handler").get(0);
-            String main_delay = intent.getStringArrayListExtra("icon-handler").get(2);
-            String delay_one = intent.getStringArrayListExtra("icon-handler").get(3);
-            String delay_two = intent.getStringArrayListExtra("icon-handler").get(4);
-            final String bypass = intent.getStringArrayListExtra("icon-handler").get(5);
-            if (bypass == null) {
-                if (intent.getStringArrayListExtra("icon-handler").get(1).contains("pm") ||
-                        intent.getStringArrayListExtra("icon-handler").get(1).contains("om") ||
-                        intent.getStringArrayListExtra("icon-handler").get(1).contains("overlay")) {
-                    Log.d("Masquerade", "Running command: \"" +
-                            intent.getStringArrayListExtra("icon-handler").get(1) + "\"");
-                    Root.runCommand(intent.getStringArrayListExtra("icon-handler").get(1));
-                }
-            }
-            final Context mContext = context;
-            final String icon_pack = icon_pack_name;
-            final String delay_one_time = delay_one;
-            final String delay_two_time = delay_two;
-            final Handler handle = new Handler();
-            handle.postDelayed(new Runnable() {
-                @Override
-                public void run() {
-                    new IconPackApplicator().apply(
-                            mContext, icon_pack, delay_one_time, delay_two_time, bypass == null);
-                }
-            }, Integer.parseInt(main_delay));
-        } else if (intent.getStringExtra("om-commands") != null) {
-            if (intent.getStringExtra("om-commands").contains("pm") ||
-                    intent.getStringExtra("om-commands").contains("om") ||
-                    intent.getStringExtra("om-commands").contains("overlay")) {
-                Log.d("Masquerade", "Running command: \"" +
-                        intent.getStringExtra("om-commands") + "\"");
-                Root.runCommand(intent.getStringExtra("om-commands"));
-            }
-        }
-    }
-
-    private boolean isCallerAuthorized(Intent intent) {
-        PendingIntent token = null;
-        try {
-            token = intent.getParcelableExtra(MASQUERADE_TOKEN);
-        } catch (Exception e) {
-            Log.d("Masquerade", "Attempt to start service without a token, unauthorized");
-        }
-        if (token == null) {
-            return false;
-        }
-        // SECOND: we got a token, validate originating package
-        // if not in our white list, return null
-        String callingPackage = token.getCreatorPackage();
-        boolean isValidPackage = false;
-        for (int i = 0; i < AUTHORIZED_CALLERS.length; i++) {
-            if (TextUtils.equals(callingPackage, AUTHORIZED_CALLERS[i])) {
-                Log.d("Masquerade", callingPackage
-                        + " is an authorized calling package, next validate calling package perms");
-                isValidPackage = true;
-                break;
-            }
-        }
-        if (!isValidPackage) {
-            Log.d("Masquerade", callingPackage
-                    + " is not an authorized calling package");
-            return false;
-        }
-        return true;
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/masquerade/substratum/util/IconPackApplicator.java b/app/src/main/java/masquerade/substratum/util/IconPackApplicator.java
deleted file mode 100644
index fb5d682..0000000
--- a/app/src/main/java/masquerade/substratum/util/IconPackApplicator.java
+++ /dev/null
@@ -1,136 +0,0 @@
-package masquerade.substratum.util;
-
-import android.content.Context;
-import android.content.Intent;
-import android.content.pm.PackageManager;
-import android.content.res.Resources;
-import android.os.Handler;
-import android.util.Log;
-import android.widget.Toast;
-
-import java.util.Locale;
-
-class IconPackApplicator {
-
-    private Context mContext;
-    private String iconPackName;
-    private String toast_text = null;
-    private int delayOne, delayTwo;
-    private Boolean bypass;
-
-    private static void grantPermission(final String packager, final String permission) {
-        Root.runCommand("pm grant " + packager + " " + permission);
-    }
-
-    void apply(Context mContext, String iconPackName, String delayOne, String delayTwo,
-               Boolean bypass) {
-        this.mContext = mContext;
-        this.iconPackName = iconPackName;
-        this.delayOne = Integer.parseInt(delayOne);
-        this.delayTwo = Integer.parseInt(delayTwo);
-        this.bypass = bypass;
-        iconInjector();
-    }
-
-    private boolean checkChangeConfigurationPermissions() {
-        String permission = "android.permission.CHANGE_CONFIGURATION";
-        int res = mContext.checkCallingOrSelfPermission(permission);
-        return (res == PackageManager.PERMISSION_GRANTED);
-    }
-
-    private void iconInjector() {
-        if (!checkChangeConfigurationPermissions()) {
-            Log.e("Masquerade", "Masquerade was not granted " +
-                    "CHANGE_CONFIGURATION permissions, allowing now...");
-            grantPermission("masquerade.substratum",
-                    "android.permission.CHANGE_CONFIGURATION");
-        } else {
-            Log.d("Masquerade",
-                    "Masquerade already granted CHANGE_CONFIGURATION permissions!");
-        }
-        try {
-            // Move home, since this is where we want our config code affected
-            Intent i = new Intent(Intent.ACTION_MAIN);
-            i.addCategory(Intent.CATEGORY_HOME);
-            mContext.startActivity(i);
-
-            // Take a fragment of memory to remember what the user's default config is
-            final Locale current_locale = mContext.getResources().getConfiguration().locale;
-            Locale to_be_changed = Locale.JAPAN;
-            // There are definitely Japanese locale users using our app, so we should take
-            // account for these people and switch to Chinese for 2 seconds.
-            if (current_locale == Locale.JAPAN) {
-                to_be_changed = Locale.CHINA;
-            }
-            final Locale changer = to_be_changed;
-
-            // Reflect back to framework and cause the language to change, we need this!
-            Class<?> activityManagerNative = Class.forName("android.app.ActivityManagerNative");
-            final Object am = activityManagerNative.getMethod("getDefault").invoke
-                    (activityManagerNative);
-            final Object config = am.getClass().getMethod("getConfiguration").invoke(am);
-
-            // Sniff Substratum's Resources
-            try {
-                Context otherContext = mContext.createPackageContext("projekt.substratum", 0);
-                Resources resources = otherContext.getResources();
-                if (bypass) {
-                    int toast = resources.getIdentifier("studio_applied_toast", "string",
-                            "projekt.substratum");
-                    toast_text = String.format(resources.getString(toast), iconPackName);
-                } else {
-                    int toast = resources.getIdentifier("studio_configuration_changed", "string",
-                            "projekt.substratum");
-                    toast_text = resources.getString(toast);
-                }
-            } catch (Exception e) {
-                // Suppress warning
-            }
-
-            // First window refresh to kick the change on the home screen
-            final Handler handle = new Handler();
-            handle.postDelayed(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        config.getClass().getDeclaredField(
-                                "locale").set(config, changer);
-                        config.getClass().getDeclaredField(
-                                "userSetLocale").setBoolean(config, true);
-
-                        am.getClass().getMethod("updateConfiguration",
-                                android.content.res.Configuration.class).invoke(am, config);
-
-                        // Change the locale back to pre-icon pack application
-                        final Handler handler = new Handler();
-                        handler.postDelayed(new Runnable() {
-                            @Override
-                            public void run() {
-                                try {
-                                    config.getClass().getDeclaredField("locale").set(
-                                            config, current_locale);
-                                    config.getClass().getDeclaredField("userSetLocale")
-                                            .setBoolean(config, true);
-
-                                    am.getClass().getMethod("updateConfiguration",
-                                            android.content.res.Configuration
-                                                    .class).invoke(am, config);
-
-                                    if (toast_text != null)
-                                        Toast.makeText(
-                                                mContext, toast_text, Toast.LENGTH_SHORT).show();
-                                } catch (Exception e) {
-                                    // Suppress warning
-                                }
-                            }
-                        }, delayTwo); // 2 second delay for Home refresh
-                    } catch (Exception e) {
-                        // Suppress warning
-                    }
-                }
-            }, delayOne); // 1 second delay for Home refresh
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/masquerade/substratum/util/ReadOverlaysFile.java b/app/src/main/java/masquerade/substratum/util/ReadOverlaysFile.java
deleted file mode 100644
index 2909ea9..0000000
--- a/app/src/main/java/masquerade/substratum/util/ReadOverlaysFile.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package masquerade.substratum.util;
-
-import android.os.Environment;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
-public class ReadOverlaysFile {
-
-    public static List<String> main(String argv[]) {
-
-        File current_overlays = new File(Environment
-                .getExternalStorageDirectory().getAbsolutePath() +
-                "/.substratum/current_overlays.xml");
-        if (current_overlays.exists()) {
-            Root.runCommand("rm " + Environment
-                    .getExternalStorageDirectory().getAbsolutePath() +
-                    "/.substratum/current_overlays.xml");
-        }
-        Root.runCommand("cp /data/system/overlays.xml " +
-                Environment
-                        .getExternalStorageDirectory().getAbsolutePath() +
-                "/.substratum/current_overlays.xml");
-
-        File file = new File(argv[0]);
-        int state_count = Integer.parseInt(argv[1]);
-
-        List<String> list = new ArrayList<>();
-
-        try (BufferedReader br = new BufferedReader(new FileReader(file))) {
-            for (String line; (line = br.readLine()) != null; ) {
-                if (line.contains("state=\"" + state_count + "\"")) {
-                    String[] split = line.substring(21).split("\\s+");
-                    list.add(split[0].substring(1, split[0].length() - 1));
-                }
-            }
-        } catch (IOException ioe) {
-            // Exception
-        }
-        return list;
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/masquerade/substratum/util/Root.java b/app/src/main/java/masquerade/substratum/util/Root.java
deleted file mode 100644
index 7c80720..0000000
--- a/app/src/main/java/masquerade/substratum/util/Root.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package masquerade.substratum.util;
-
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-
-public class Root {
-
-    private static SU su;
-
-    public static boolean requestRootAccess() {
-        SU su = getSU();
-        su.runCommand("echo /testRoot/");
-        return !su.denied;
-    }
-
-    public static String runCommand(String command) {
-        return getSU().runCommand(command);
-    }
-
-    private static SU getSU() {
-        if (su == null) su = new SU();
-        else if (su.closed || su.denied) su = new SU();
-        return su;
-    }
-
-    private static class SU {
-
-        private Process process;
-        private BufferedWriter bufferedWriter;
-        private BufferedReader bufferedReader;
-        private boolean closed;
-        private boolean denied;
-        private boolean firstTry;
-
-        SU() {
-            try {
-                firstTry = true;
-                process = Runtime.getRuntime().exec("su");
-                bufferedWriter = new BufferedWriter(new OutputStreamWriter(process
-                        .getOutputStream()));
-                bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream
-                        ()));
-            } catch (IOException e) {
-                denied = true;
-                closed = true;
-            }
-        }
-
-        synchronized String runCommand(final String command) {
-            try {
-                StringBuilder sb = new StringBuilder();
-                String callback = "/shellCallback/";
-                bufferedWriter.write(command + "\necho " + callback + "\n");
-                bufferedWriter.flush();
-
-                int i;
-                char[] buffer = new char[256];
-                while (true) {
-                    sb.append(buffer, 0, bufferedReader.read(buffer));
-                    if ((i = sb.indexOf(callback)) > -1) {
-                        sb.delete(i, i + callback.length());
-                        break;
-                    }
-                }
-                firstTry = false;
-                return sb.toString().trim();
-            } catch (IOException e) {
-                closed = true;
-                e.printStackTrace();
-                if (firstTry) denied = true;
-            } catch (ArrayIndexOutOfBoundsException e) {
-                denied = true;
-            } catch (Exception e) {
-                e.printStackTrace();
-                denied = true;
-            }
-            return null;
-        }
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/masquerade/substratum/util/Uninstaller.java b/app/src/main/java/masquerade/substratum/util/Uninstaller.java
deleted file mode 100644
index 4b1b056..0000000
--- a/app/src/main/java/masquerade/substratum/util/Uninstaller.java
+++ /dev/null
@@ -1,107 +0,0 @@
-package masquerade.substratum.util;
-
-import android.content.Intent;
-import android.os.AsyncTask;
-import android.os.Environment;
-import android.util.Log;
-
-import java.util.ArrayList;
-import java.util.List;
-
-class Uninstaller {
-
-    private Intent mIntent;
-    private String uninstallString;
-    private boolean specific;
-    private boolean restartSystemUI;
-
-    void uninstall(Intent mIntent, String uninstallString,
-                   boolean specific, boolean restartSystemUI) {
-        this.mIntent = mIntent;
-        this.uninstallString = uninstallString;
-        this.specific = specific;
-        this.restartSystemUI = restartSystemUI;
-        new UninstallAsync().execute("");
-    }
-
-    private class UninstallAsync extends AsyncTask<String, Integer, String> {
-
-        @Override
-        protected String doInBackground(String... sUrl) {
-            uninstall_handler(mIntent, uninstallString, specific, restartSystemUI);
-            return null;
-        }
-
-        private void uninstall_handler(Intent intent, String inheritor,
-                                       boolean specific, boolean restartSystemUI) {
-            try {
-                String final_commands_disable = "";
-                String final_commands_uninstall = "";
-
-                Root.runCommand(
-                        "pm grant masquerade.substratum android.permission.READ_EXTERNAL_STORAGE");
-                Root.runCommand(
-                        "pm grant masquerade.substratum android.permission.WRITE_EXTERNAL_STORAGE");
-
-                ArrayList<String> packages_to_uninstall =
-                        new ArrayList<>(intent.getStringArrayListExtra(inheritor));
-                String[] state5initial = {Environment.getExternalStorageDirectory()
-                        .getAbsolutePath() +
-                        "/.substratum/current_overlays.xml", "5"};
-                List<String> state5overlays = ReadOverlaysFile.main(state5initial);
-
-                for (int i = 0; i < packages_to_uninstall.size(); i++) {
-                    String current = packages_to_uninstall.get(i);
-
-                    Log.d("Masquerade", "Intent received to purge referendum package file \"" +
-                            current + "\"");
-                    if (state5overlays.contains(packages_to_uninstall.get(i))) {
-                        Log.d("Masquerade", "Package file \"" + current +
-                                "\" requires an overlay disable prior to uninstall...");
-                        if (final_commands_disable.length() == 0) {
-                            final_commands_disable = "om disable " + current;
-                        } else {
-                            final_commands_disable = final_commands_disable + " " + current;
-                        }
-
-                        if (final_commands_uninstall.length() == 0) {
-                            final_commands_uninstall = "pm uninstall " + current;
-                        } else {
-                            final_commands_uninstall = final_commands_uninstall +
-                                    " && pm uninstall " + current;
-                        }
-                    } else {
-                        Log.d("Masquerade", "\"" + current +
-                                "\" has been redirected to the package manager in " +
-                                "preparations of removal...");
-                        Root.runCommand("pm uninstall " + current);
-                    }
-                }
-
-                if (final_commands_disable.length() > 0) {
-                    Log.d("Masquerade", "Disable commands: " + final_commands_disable);
-                    Root.runCommand(final_commands_disable);
-                }
-                if (final_commands_uninstall.length() > 0) {
-                    Log.d("Masquerade", "Uninstall commands: " + final_commands_uninstall);
-                    Root.runCommand(final_commands_uninstall);
-                }
-
-                if (restartSystemUI) {
-                    Root.runCommand("pkill com.android.systemui");
-                }
-
-                if (!specific) {
-                    // Clear the resource idmapping files generated by OMS
-                    Log.d("Masquerade", "Cleaning up resource-cache directory...");
-                    Root.runCommand("rm /data/resource-cache/*");
-                    // Now clear the persistent overlays database
-                    Log.d("Masquerade", "Finalizing clean up of persistent overlays database...");
-                    Root.runCommand("rm -rf /data/system/overlays.xml");
-                }
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/masquerade/substratum/utils/IOUtils.java b/app/src/main/java/masquerade/substratum/utils/IOUtils.java
new file mode 100644
index 0000000..092c58c
--- /dev/null
+++ b/app/src/main/java/masquerade/substratum/utils/IOUtils.java
@@ -0,0 +1,170 @@
+
+package masquerade.substratum.utils;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import android.os.FileUtils;
+
+public class IOUtils {
+    public static final String SYSTEM_THEME_PATH = "/data/system/theme";
+    public static final String SYSTEM_THEME_FONT_PATH = SYSTEM_THEME_PATH + File.separator
+            + "fonts";
+    public static final String SYSTEM_THEME_AUDIO_PATH = SYSTEM_THEME_PATH + File.separator
+            + "audio";
+    public static final String SYSTEM_THEME_RINGTONE_PATH = SYSTEM_THEME_AUDIO_PATH
+            + File.separator + "ringtones";
+    public static final String SYSTEM_THEME_NOTIFICATION_PATH = SYSTEM_THEME_AUDIO_PATH
+            + File.separator + "notifications";
+    public static final String SYSTEM_THEME_ALARM_PATH = SYSTEM_THEME_AUDIO_PATH
+            + File.separator + "alarms";
+    public static final String SYSTEM_THEME_UI_SOUNDS_PATH = SYSTEM_THEME_AUDIO_PATH
+            + File.separator + "ui";
+    public static final String SYSTEM_THEME_BOOTANIMATION_PATH = SYSTEM_THEME_PATH + File.separator
+            + "bootanimation.zip";
+
+    public static boolean dirExists(String dirPath) {
+        final File dir = new File(dirPath);
+        return dir.exists() && dir.isDirectory();
+    }
+
+    public static void createDirIfNotExists(String dirPath) {
+        if (!dirExists(dirPath)) {
+            File dir = new File(dirPath);
+            if (dir.mkdir()) {
+                FileUtils.setPermissions(dir, FileUtils.S_IRWXU |
+                        FileUtils.S_IRWXG | FileUtils.S_IROTH | FileUtils.S_IXOTH, -1, -1);
+            }
+        }
+    }
+
+    public static void createFontDirIfNotExists() {
+        createDirIfNotExists(SYSTEM_THEME_FONT_PATH);
+    }
+
+    public static void createAudioDirIfNotExists() {
+        createDirIfNotExists(SYSTEM_THEME_AUDIO_PATH);
+    }
+
+    public static void createRingtoneDirIfNotExists() {
+        createDirIfNotExists(SYSTEM_THEME_RINGTONE_PATH);
+    }
+
+    public static void createNotificationDirIfNotExists() {
+        createDirIfNotExists(SYSTEM_THEME_NOTIFICATION_PATH);
+    }
+
+    public static void createAlarmDirIfNotExists() {
+        createDirIfNotExists(SYSTEM_THEME_ALARM_PATH);
+    }
+
+    public static void createUiSoundsDirIfNotExists() {
+        createDirIfNotExists(SYSTEM_THEME_UI_SOUNDS_PATH);
+    }
+
+    public static void deleteThemedFonts() {
+        try {
+            deleteRecursive(new File(SYSTEM_THEME_FONT_PATH));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    
+    public static void deleteThemedAudio() {
+        try {
+            deleteRecursive(new File(SYSTEM_THEME_UI_SOUNDS_PATH));
+            deleteRecursive(new File(SYSTEM_THEME_RINGTONE_PATH));
+            deleteRecursive(new File(SYSTEM_THEME_NOTIFICATION_PATH));
+            deleteRecursive(new File(SYSTEM_THEME_ALARM_PATH));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void copyFolder(String source, String dest) {
+        File dir = new File(source);
+        File[] files = dir.listFiles();
+        for (File file : files) {
+            try {
+                String sourceFile = dir + File.separator + file.getName();
+                String destinationFile = dest + File.separator + file.getName();
+                bufferedCopy(new File(sourceFile), new File(destinationFile));
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static void unzip(String source, String destination) {
+        try (ZipInputStream inputStream = new ZipInputStream(
+                new BufferedInputStream(new FileInputStream(source)))) {
+            ZipEntry zipEntry;
+            int count;
+            byte[] buffer = new byte[8192];
+            while ((zipEntry = inputStream.getNextEntry()) != null) {
+                File file = new File(destination, zipEntry.getName());
+                File dir = zipEntry.isDirectory() ? file : file.getParentFile();
+                if (!dir.isDirectory() && !dir.mkdirs())
+                    throw new FileNotFoundException("Failed to ensure directory: " +
+                            dir.getAbsolutePath());
+                if (zipEntry.isDirectory())
+                    continue;
+                try (FileOutputStream outputStream = new FileOutputStream(file)) {
+                    while ((count = inputStream.read(buffer)) != -1)
+                        outputStream.write(buffer, 0, count);
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void bufferedCopy(String source, String dest) {
+        try {
+            bufferedCopy(new FileInputStream(source), new FileOutputStream(dest));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void bufferedCopy(File source, File dest) {
+        try {
+            bufferedCopy(new FileInputStream(source), new FileOutputStream(dest));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void bufferedCopy(InputStream source, OutputStream dest) {
+        try {
+            BufferedInputStream in = new BufferedInputStream(source);
+            BufferedOutputStream out = new BufferedOutputStream(dest);
+            byte[] buff = new byte[32 * 1024];
+            int len;
+            while ((len = in.read(buff)) > 0) {
+                out.write(buff, 0, len);
+            }
+            in.close();
+            out.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void deleteRecursive(File fileOrDirectory) {
+        if (fileOrDirectory.isDirectory())
+            for (File child : fileOrDirectory.listFiles())
+                deleteRecursive(child);
+
+        fileOrDirectory.delete();
+    }
+
+}
diff --git a/app/src/main/java/masquerade/substratum/utils/SoundUtils.java b/app/src/main/java/masquerade/substratum/utils/SoundUtils.java
new file mode 100644
index 0000000..72c6052
--- /dev/null
+++ b/app/src/main/java/masquerade/substratum/utils/SoundUtils.java
@@ -0,0 +1,210 @@
+
+package masquerade.substratum.utils;
+
+import java.io.File;
+import java.util.Arrays;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.SystemProperties;
+import android.os.UserHandle;
+import android.provider.MediaStore;
+import android.util.Log;
+import android.provider.Settings;
+
+public class SoundUtils {
+    private static final String SYSTEM_MEDIA_PATH = "/system/media/audio";
+    private static final String SYSTEM_ALARMS_PATH =
+            SYSTEM_MEDIA_PATH + File.separator + "alarms";
+    private static final String SYSTEM_RINGTONES_PATH =
+            SYSTEM_MEDIA_PATH + File.separator + "ringtones";
+    private static final String SYSTEM_NOTIFICATIONS_PATH =
+            SYSTEM_MEDIA_PATH + File.separator + "notifications";
+    private static final String MEDIA_CONTENT_URI = "content://media/internal/audio/media";
+
+    public static void updateGlobalSettings(ContentResolver resolver, String uri, String val) {
+        Settings.Global.putStringForUser(resolver, uri, val, UserHandle.USER_ALL);
+    }
+
+    public static boolean setUISounds(ContentResolver resolver, String sound_name, String location) {
+        if (allowedUISound(sound_name)) {
+            updateGlobalSettings(resolver, sound_name, location);
+            return true;
+        }
+        return false;
+    }
+
+    public static void setDefaultUISounds(ContentResolver resolver, String sound_name,
+            String sound_file) {
+        updateGlobalSettings(resolver, sound_name, "/system/media/audio/ui/" + sound_file);
+    }
+
+    // This string array contains all the SystemUI acceptable sound files
+    public static Boolean allowedUISound(String targetValue) {
+        String[] allowed_themable = {
+                "lock_sound",
+                "unlock_sound",
+                "low_battery_sound"
+        };
+        return Arrays.asList(allowed_themable).contains(targetValue);
+    }
+
+    public static String getDefaultAudiblePath(int type) {
+        final String name;
+        final String path;
+        switch (type) {
+            case RingtoneManager.TYPE_ALARM:
+                name = SystemProperties.get("ro.config.alarm_alert");
+                path = name != null ? SYSTEM_ALARMS_PATH + File.separator + name : null;
+                break;
+            case RingtoneManager.TYPE_NOTIFICATION:
+                name = SystemProperties.get("ro.config.notification_sound");
+                path = name != null ? SYSTEM_NOTIFICATIONS_PATH + File.separator + name : null;
+                break;
+            case RingtoneManager.TYPE_RINGTONE:
+                name = SystemProperties.get("ro.config.ringtone");
+                path = name != null ? SYSTEM_RINGTONES_PATH + File.separator + name : null;
+                break;
+            default:
+                path = null;
+                break;
+        }
+        return path;
+    }
+
+    public static void clearAudibles(Context context, String audiblePath) {
+        final File audibleDir = new File(audiblePath);
+        if (audibleDir.exists() && audibleDir.isDirectory()) {
+            String[] files = audibleDir.list();
+            final ContentResolver resolver = context.getContentResolver();
+            for (String s : files) {
+                final String filePath = audiblePath + File.separator + s;
+                Uri uri = MediaStore.Audio.Media.getContentUriForPath(filePath);
+                resolver.delete(uri, MediaStore.MediaColumns.DATA + "=\""
+                        + filePath + "\"", null);
+                boolean deleted = (new File(filePath)).delete();
+                if (deleted)
+                    Log.e("SoundsHandler", "Database cleared");
+            }
+        }
+    }
+
+    public static boolean setAudible(Context context, File ringtone, File ringtoneCache, int type,
+            String name) {
+        final String path = ringtone.getAbsolutePath();
+        final String mimeType = name.endsWith(".ogg") ? "application/ogg" : "application/mp3";
+        ContentValues values = new ContentValues();
+        values.put(MediaStore.MediaColumns.DATA, path);
+        values.put(MediaStore.MediaColumns.TITLE, name);
+        values.put(MediaStore.MediaColumns.MIME_TYPE, mimeType);
+        values.put(MediaStore.MediaColumns.SIZE, ringtoneCache.length());
+        values.put(MediaStore.Audio.Media.IS_RINGTONE, type == RingtoneManager.TYPE_RINGTONE);
+        values.put(MediaStore.Audio.Media.IS_NOTIFICATION,
+                type == RingtoneManager.TYPE_NOTIFICATION);
+        values.put(MediaStore.Audio.Media.IS_ALARM, type == RingtoneManager.TYPE_ALARM);
+        values.put(MediaStore.Audio.Media.IS_MUSIC, false);
+
+        Uri uri = MediaStore.Audio.Media.getContentUriForPath(path);
+        Uri newUri = null;
+        Cursor c = context.getContentResolver().query(uri,
+                new String[] {
+                    MediaStore.MediaColumns._ID
+                },
+                MediaStore.MediaColumns.DATA + "='" + path + "'",
+                null, null);
+        if (c != null && c.getCount() > 0) {
+            c.moveToFirst();
+            long id = c.getLong(0);
+            c.close();
+            newUri = Uri.withAppendedPath(Uri.parse(MEDIA_CONTENT_URI), "" + id);
+            context.getContentResolver().update(uri, values,
+                    MediaStore.MediaColumns._ID + "=" + id, null);
+        }
+        if (newUri == null)
+            newUri = context.getContentResolver().insert(uri, values);
+        try {
+            RingtoneManager.setActualDefaultRingtoneUri(context, type, newUri);
+        } catch (Exception e) {
+            return false;
+        }
+        return true;
+    }
+
+    public static boolean setUIAudible(Context context, File localized_ringtone,
+            File ringtone_file, int type, String name) {
+        final String path = ringtone_file.getAbsolutePath();
+
+        final String path_clone = "/system/media/audio/ui/" + name + ".ogg";
+
+        ContentValues values = new ContentValues();
+        values.put(MediaStore.MediaColumns.DATA, path);
+        values.put(MediaStore.MediaColumns.TITLE, name);
+        values.put(MediaStore.MediaColumns.MIME_TYPE, "application/ogg");
+        values.put(MediaStore.MediaColumns.SIZE, localized_ringtone.length());
+        values.put(MediaStore.Audio.Media.IS_RINGTONE, false);
+        values.put(MediaStore.Audio.Media.IS_NOTIFICATION, false);
+        values.put(MediaStore.Audio.Media.IS_ALARM, false);
+        values.put(MediaStore.Audio.Media.IS_MUSIC, true);
+
+        Uri uri = MediaStore.Audio.Media.getContentUriForPath(path);
+        Uri newUri = null;
+        Cursor c = context.getContentResolver().query(uri,
+                new String[] {
+                    MediaStore.MediaColumns._ID
+                },
+                MediaStore.MediaColumns.DATA + "='" + path_clone + "'",
+                null, null);
+        if (c != null && c.getCount() > 0) {
+            c.moveToFirst();
+            long id = c.getLong(0);
+            Log.e("ContentResolver", id + "");
+            c.close();
+            newUri = Uri.withAppendedPath(Uri.parse(MEDIA_CONTENT_URI), "" + id);
+            try {
+                context.getContentResolver().update(uri, values,
+                        MediaStore.MediaColumns._ID + "=" + id, null);
+            } catch (Exception e) {
+                Log.d("SoundsHandler", "The content provider does not need to be updated.");
+            }
+        }
+        if (newUri == null)
+            newUri = context.getContentResolver().insert(uri, values);
+        try {
+            RingtoneManager.setActualDefaultRingtoneUri(context, type, newUri);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+
+    public static boolean setDefaultAudible(Context context, int type) {
+        final String audiblePath = getDefaultAudiblePath(type);
+        if (audiblePath != null) {
+            Uri uri = MediaStore.Audio.Media.getContentUriForPath(audiblePath);
+            Cursor c = context.getContentResolver().query(uri,
+                    new String[] {
+                        MediaStore.MediaColumns._ID
+                    },
+                    MediaStore.MediaColumns.DATA + "='" + audiblePath + "'",
+                    null, null);
+            if (c != null && c.getCount() > 0) {
+                c.moveToFirst();
+                long id = c.getLong(0);
+                c.close();
+                uri = Uri.withAppendedPath(
+                        Uri.parse(MEDIA_CONTENT_URI), "" + id);
+            }
+            if (uri != null)
+                RingtoneManager.setActualDefaultRingtoneUri(context, type, uri);
+        } else {
+            return false;
+        }
+        return true;
+    }
+
+}