react-native-stallion 1.1.2 → 2.0.0-alpha.1

package/android/src/main/java/com/stallion/StallionFileUtil.java

@@ -0,0 +1,129 @@
+package com.stallion;
+
+import android.os.Build;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.Charset;
+import java.util.Enumeration;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class StallionFileUtil {
+    private static final int BUF_SIZE = 0x1000;
+
+  public static void unzipFile(final String zipFilePath, final String destDirectory) {
+
+    try {
+      if (!new File(zipFilePath).exists()) {
+        throw new IllegalArgumentException("File does not exist");
+      }
+    } catch (NullPointerException e) {
+      throw new RuntimeException(e);
+    }
+
+    try {
+      String charset = "UTF-8";
+
+      File destDir = new File(destDirectory);
+      if (!destDir.exists()) {
+        destDir.mkdirs();
+      }
+
+      ZipFile zipFile;
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        zipFile = new ZipFile(zipFilePath, Charset.forName(charset));
+      } else {
+        zipFile = new ZipFile(zipFilePath);
+      }
+
+      final Enumeration<? extends ZipEntry> entries = zipFile.entries();
+      while (entries.hasMoreElements()) {
+        final ZipEntry entry = entries.nextElement();
+        if (entry.isDirectory()) continue;
+
+        File fout = new File(destDirectory, entry.getName());
+        String canonicalPath = fout.getCanonicalPath();
+        String destDirCanonicalPath = new File(destDirectory).getCanonicalPath() + File.separator;
+
+        if (!canonicalPath.startsWith(destDirCanonicalPath)) {
+          throw new SecurityException(String.format("Found Zip Path Traversal Vulnerability with %s", canonicalPath));
+        }
+
+        if (!fout.exists()) {
+          (new File(fout.getParent())).mkdirs();
+        }
+
+        InputStream in = null;
+        BufferedOutputStream bout = null;
+        try {
+          in = zipFile.getInputStream(entry);
+          bout = new BufferedOutputStream(new FileOutputStream(fout));
+          copy(in, bout);
+          bout.close();
+          in.close();
+        } catch (IOException ex) {
+          if (in != null) {
+            try {
+              in.close();
+            } catch (Exception ignored) {
+            }
+          }
+          if (bout != null) {
+            try {
+              bout.close();
+            } catch (Exception ignored) {
+            }
+          }
+        }
+      }
+
+      zipFile.close();
+    } catch (Exception ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+
+  private static long copy(InputStream from, OutputStream to) throws IOException {
+        byte[] buf = new byte[BUF_SIZE];
+        long total = 0;
+        while (true) {
+            int r = from.read(buf);
+            if (r == -1) {
+                break;
+            }
+            to.write(buf, 0, r);
+            total += r;
+        }
+        return total;
+    }
+
+    public static void deleteFileOrFolderSilently(File file) {
+        if (file.isDirectory()) {
+            File[] files = file.listFiles();
+          assert files != null;
+          for (File fileEntry : files) {
+                if (fileEntry.isDirectory()) {
+                    deleteFileOrFolderSilently(fileEntry);
+                } else {
+                    fileEntry.delete();
+                }
+            }
+        }
+        if(!file.delete()) {
+            throw new RuntimeException("StallionException: Error deleting file");
+        }
+    }
+    public static void moveFile(File fromFile, File toFile) {
+      if(toFile.exists()) {
+        deleteFileOrFolderSilently(toFile);
+      }
+      toFile.getParentFile().mkdirs();
+      fromFile.renameTo(toFile);
+    }
+}

package/android/src/main/java/com/stallion/StallionModule.java

@@ -1,9 +1,12 @@
 package com.stallion;
 
+import android.content.res.Resources;
+
 import androidx.annotation.NonNull;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
@@ -13,36 +16,37 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
-import android.util.Log;
-
-import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.net.HttpURLConnection;
-import java.net.URL;
-import java.nio.ByteBuffer;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
 @ReactModule(name = StallionConstants.MODULE_NAME)
-public class StallionModule extends ReactContextBaseJavaModule {
-  private ReactApplicationContext currentReactContext;
-  private String baseDir;
-  private StallionStorage stallionStorage;
+public class StallionModule extends ReactContextBaseJavaModule implements LifecycleEventListener {
+  private final ReactApplicationContext currentReactContext;
+  private final StallionStorage stallionStorage;
   private DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter;
 
   public StallionModule(ReactApplicationContext reactContext) {
     super(reactContext);
     this.currentReactContext = reactContext;
-    this.baseDir = reactContext.getFilesDir().getAbsolutePath() + StallionConstants.STALLION_PACKAGE_PATH;
     StallionStorage.getInstance().Initialize(reactContext);
     this.stallionStorage = StallionStorage.getInstance();
     StallionErrorBoundary.initErrorBoundary(reactContext);
-    String switchState = this.stallionStorage.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER);
-    Boolean isStallionEnabled = switchState == null ? false : switchState.equals(StallionConstants.STALLION_SWITCH_ON);
-    StallionErrorBoundary.toggleExceptionHandler(isStallionEnabled);
+    StallionErrorBoundary.toggleExceptionHandler(true);
+    reactContext.addLifecycleEventListener(this);
+  }
+
+  @Override
+  public void onHostResume() {
+    StallionSynManager.sync();
+  }
+
+  @Override
+  public void onHostPause() {}
+
+  @Override
+  public void onHostDestroy() {}
+
+  @Override
+  public void onCatalystInstanceDestroy() {
+    super.onCatalystInstanceDestroy();
+    this.currentReactContext.removeLifecycleEventListener(this);
   }
 
   @Override
@@ -52,160 +56,102 @@ public class StallionModule extends ReactContextBaseJavaModule {
   }
 
   @ReactMethod
-  public void setApiKey(String apiKey) {
-    this.stallionStorage.set(StallionConstants.API_KEY_IDENTIFIER, apiKey);
+  public void setStorage(String key, String value) {
+    this.stallionStorage.set(key, value);
   }
 
+
   @ReactMethod
-  public void getApiKey(Callback callback) {
-    callback.invoke(
-      this.stallionStorage.get(StallionConstants.API_KEY_IDENTIFIER)
-    );
+  public void getStorage(String key, Callback callback) {
+    callback.invoke(this.stallionStorage.get(key));
   }
 
   @ReactMethod
-  public void getStallionMeta(Callback callback) {
-    WritableMap bundleMeta = Arguments.createMap();
-    String activeBucket = this.stallionStorage.get(StallionConstants.ACTIVE_BUCKET_IDENTIFIER);
-    String switchState = this.stallionStorage.get(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER);
-    int activeVersion = this.stallionStorage.getInt(StallionConstants.ACTIVE_VERSION_IDENTIFIER);
-
-    bundleMeta.putString(StallionConstants.ACTIVE_BUCKET_IDENTIFIER, activeBucket);
-    bundleMeta.putBoolean(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER,
-      switchState == null ? false : switchState.equals(StallionConstants.STALLION_SWITCH_ON)
-    );
-    bundleMeta.putString(StallionConstants.ACTIVE_VERSION_IDENTIFIER, String.valueOf(activeVersion));
-    callback.invoke(bundleMeta);
+  public void onLaunch(String launchData) {
+    StallionStorage.getInstance().setIsMounted();
+    StallionEventEmitter.triggerPendingEvents();
+  }
+
+  @ReactMethod
+  public  void  getUniqueId(Callback callback) {
+    callback.invoke(StallionCommonUtil.getUniqueId());
+  }
+
+  @ReactMethod
+  public void getProjectId(Callback callback) {
+    Resources res = currentReactContext.getResources();
+    String parentPackageName= currentReactContext.getPackageName();
+    int stallionProjectIdRes = res.getIdentifier(StallionConstants.STALLION_PROJECT_ID_IDENTIFIER, "string", parentPackageName);
+    String projectId = currentReactContext.getString(stallionProjectIdRes);
+    callback.invoke(projectId);
   }
 
   @ReactMethod
-  public void toggleStallionSwitch(Boolean stallionBundleIsOn) {
-    this.stallionStorage.set(StallionConstants.STALLION_SWITCH_STATE_IDENTIFIER, stallionBundleIsOn ? StallionConstants.STALLION_SWITCH_ON : StallionConstants.STALLION_SWITCH_OFF);
+  public void getAppToken(Callback callback) {
+    Resources res = currentReactContext.getResources();
+    String parentPackageName= currentReactContext.getPackageName();
+    int stallionAppTokenRes = res.getIdentifier(StallionConstants.STALLION_APP_TOKEN_IDENTIFIER, "string", parentPackageName);
+    String appToken = currentReactContext.getString(stallionAppTokenRes);
+    callback.invoke(appToken);
   }
 
-  private DeviceEventManagerModule.RCTDeviceEventEmitter getEventEmitter() {
-    if(this.eventEmitter == null) {
-      this.eventEmitter = this.currentReactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
-    }
-    return this.eventEmitter;
+  @ReactMethod
+  public  void  sync() {
+    StallionSynManager.sync();
   }
 
   @ReactMethod
   public void downloadPackage(ReadableMap bundleInfo, Promise promise) {
-    String receivedBucketId = bundleInfo.getString("bucketId");
     String receivedDownloadUrl = bundleInfo.getString("url");
-    Integer receivedVersion = bundleInfo.getInt("version");
-
-    ExecutorService executor = Executors.newSingleThreadExecutor();
-
-    executor.execute(() -> {
-      DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter =  getEventEmitter();
-
-      FileOutputStream fout = null;
-      BufferedOutputStream bout = null;
-      BufferedInputStream inputStream = null;
-      HttpURLConnection connection = null;
-      File downloadedZip = null;
-      boolean isZip = false;
-
-      try {
-        int DOWNLOAD_BUFFER_SIZE = StallionConstants.DOWNLOAD_BUFFER_SIZE;
-        URL url = new URL(receivedDownloadUrl);
-        connection = (HttpURLConnection) url.openConnection();
-        connection.setRequestMethod( "GET" );
-        connection.setRequestProperty("x-sdk-access-token", stallionStorage.get(StallionConstants.API_KEY_IDENTIFIER));
-        connection.setRequestProperty("Content-Type", "application/json");
-
-        connection.setDoInput(true);
-
-        connection.connect();
-        inputStream = new BufferedInputStream(connection.getInputStream());
-        File downloadFolder = new File(baseDir + StallionConstants.DOWNLOAD_FOLDER_DIR);
-        downloadFolder.getParentFile().mkdirs();
-
-        downloadedZip = new File(downloadFolder, StallionConstants.ZIP_FILE_NAME);
-        downloadedZip.getParentFile().mkdirs();
-
-        fout = new FileOutputStream(downloadedZip, false);
-        bout = new BufferedOutputStream(fout, DOWNLOAD_BUFFER_SIZE);
-        byte[] data = new byte[DOWNLOAD_BUFFER_SIZE];
-        byte[] header = new byte[4];
-
-        long totalBytes = connection.getContentLength();
-        long receivedBytes = 0;
-        int numBytesRead;
-        double prevDownloadFraction = 0;
-        double progressEventThreshold = 0.1;
-        while ((numBytesRead = inputStream.read(data, 0, DOWNLOAD_BUFFER_SIZE)) >= 0) {
-          if (receivedBytes < 4) {
-            for (int i = 0; i < numBytesRead; i++) {
-              int headerOffset = (int) (receivedBytes) + i;
-              if (headerOffset >= 4) {
-                break;
-              }
-              header[headerOffset] = data[i];
-            }
-          }
-
-          receivedBytes += numBytesRead;
-          bout.write(data, 0, numBytesRead);
-          double currentDownloadFraction = (double) receivedBytes / (double) totalBytes;
-          if(currentDownloadFraction - prevDownloadFraction > progressEventThreshold) {
-            prevDownloadFraction = currentDownloadFraction;
-            getReactApplicationContext().runOnUiQueueThread(() -> getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(StallionConstants.DOWNLOAD_PROGRESS_EVENT, currentDownloadFraction));
-          }
+    String receivedHash = bundleInfo.getString("hash");
+    String sdkToken = stallionStorage.get(StallionConstants.STALLION_SDK_TOKEN_KEY);
+    StallionDownloadManager.downloadBundle(
+      receivedDownloadUrl,
+      this.currentReactContext.getFilesDir().getAbsolutePath() + StallionConstants.STAGE_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT,
+      sdkToken,
+      "",
+      new StallionDownloadCallback() {
+        @Override
+        public void onReject(String prefix, String error) {
+          WritableMap errorEventPayload = Arguments.createMap();
+          errorEventPayload.putString("releaseHash", receivedHash);
+          StallionEventEmitter.sendEvent(
+            StallionEventEmitter.getEventPayload(
+              StallionConstants.NativeEventTypesStage.DOWNLOAD_ERROR_STAGE.toString(),
+              errorEventPayload
+            )
+          );
+          promise.reject(prefix, error);
         }
 
-        isZip = ByteBuffer.wrap(header).getInt() == 0x504b0304;
-        Log.d("", String.valueOf(isZip));
-
-      } catch (Exception e) {
-        promise.reject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_API_ERROR_MESSAGE);
-      } finally {
-        try {
-          if (bout != null) bout.close();
-          if (fout != null) fout.close();
-          if (inputStream != null) inputStream.close();
-          if (connection != null) connection.disconnect();
-        } catch (IOException e) {
-          promise.reject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_API_ERROR_MESSAGE);
+        @Override
+        public void onSuccess(String successPayload) {
+          stallionStorage.set(StallionConstants.CURRENT_STAGE_SLOT_KEY, StallionConstants.TEMP_FOLDER_SLOT);
+          stallionStorage.set(StallionConstants.STAGE_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT, receivedHash);
+          WritableMap successEventPayload = Arguments.createMap();
+          successEventPayload.putString("releaseHash", receivedHash);
+          StallionEventEmitter.sendEvent(
+            StallionEventEmitter.getEventPayload(
+              StallionConstants.NativeEventTypesStage.DOWNLOAD_COMPLETE_STAGE.toString(),
+              successEventPayload
+            )
+          );
+          promise.resolve(StallionConstants.DOWNLOAD_SUCCESS_MESSAGE);
         }
-      }
-
-      if (!isZip) {
-        promise.reject(StallionConstants.DOWNLOAD_ERROR_PREFIX, "Not a zip file");
-        return;
-      }
 
-      try {
-        int currentActiveSlot = stallionStorage.getInt(StallionConstants.ACTIVE_SLOT_IDENTIFIER);
-        int targetSlot;
-        if(currentActiveSlot == 1) {
-          targetSlot = 2;
-        } else if(currentActiveSlot == 2) {
-          targetSlot = 1;
-        } else {
-          targetSlot = 1;
+        @Override
+        public void onProgress(double downloadFraction) {
+          WritableMap progressEventPayload = Arguments.createMap();
+          progressEventPayload.putString("releaseHash", receivedHash);
+          progressEventPayload.putDouble("progress", downloadFraction);
+          StallionEventEmitter.sendEvent(
+            StallionEventEmitter.getEventPayload(
+              StallionConstants.NativeEventTypesStage.DOWNLOAD_PROGRESS_STAGE.toString(),
+              progressEventPayload
+            )
+          );
         }
-        StallionZip.unzipFile(downloadedZip.getAbsolutePath(), baseDir + StallionConstants.BUNDLE_DEST_FOLDER_DIR + StallionConstants.SLOT_FOLDER_DIR + targetSlot);
-        // setting active bucket ID, slot and version after downloading and all other jobs done
-        stallionStorage.setInt(StallionConstants.ACTIVE_SLOT_IDENTIFIER, targetSlot);
-        stallionStorage.set(StallionConstants.ACTIVE_BUCKET_IDENTIFIER, receivedBucketId);
-        if (receivedVersion != null) {
-          stallionStorage.setInt(StallionConstants.ACTIVE_VERSION_IDENTIFIER, receivedVersion);
-        }
-        promise.resolve(StallionConstants.DOWNLOAD_SUCCESS_MESSAGE);
-        getReactApplicationContext().runOnUiQueueThread(() -> getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(StallionConstants.DOWNLOAD_PROGRESS_EVENT, 1));
-      } catch (Exception e) {
-        promise.reject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_FILESYSTEM_ERROR_MESSAGE);
-      } finally {
-        try {
-          StallionZip.deleteFileOrFolderSilently(downloadedZip);
-        } catch (Exception e) {
-          promise.reject(StallionConstants.DOWNLOAD_ERROR_PREFIX, StallionConstants.DOWNLOAD_DELETE_ERROR);
-        }
-        return;
       }
-    });
+    );
   }
 }

package/android/src/main/java/com/stallion/StallionRollbackManager.java

@@ -0,0 +1,82 @@
+package com.stallion;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+import java.io.File;
+
+public class StallionRollbackManager {
+  public static void rollbackProd(Boolean isAutoRollback) {
+    StallionStorage stallionStorageInstance = StallionStorage.getInstance();
+    String currentProdSlot = stallionStorageInstance.get(StallionConstants.CURRENT_PROD_SLOT_KEY);
+    String stableReleaseHash = stallionStorageInstance.get(StallionConstants.PROD_DIRECTORY + StallionConstants.STABLE_FOLDER_SLOT);
+    switch (currentProdSlot) {
+      case StallionConstants.NEW_FOLDER_SLOT:
+        String newReleaseHash = stallionStorageInstance.get(StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT);
+        stallionStorageInstance.set(StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT, "");
+        if(stableReleaseHash.isEmpty()) {
+          stallionStorageInstance.set(StallionConstants.CURRENT_PROD_SLOT_KEY, StallionConstants.DEFAULT_FOLDER_SLOT);
+        } else {
+          stallionStorageInstance.set(StallionConstants.CURRENT_PROD_SLOT_KEY, StallionConstants.STABLE_FOLDER_SLOT);
+        }
+        emitRollbackEvent(isAutoRollback, newReleaseHash);
+        break;
+      case  StallionConstants.STABLE_FOLDER_SLOT:
+        stallionStorageInstance.set(StallionConstants.PROD_DIRECTORY + StallionConstants.STABLE_FOLDER_SLOT, "");
+        stallionStorageInstance.set(StallionConstants.CURRENT_PROD_SLOT_KEY, StallionConstants.DEFAULT_FOLDER_SLOT);
+        emitRollbackEvent(isAutoRollback, stableReleaseHash);
+        break;
+    }
+  }
+
+  public static void fallbackProd() {
+    StallionStorage stallionStorageInstance = StallionStorage.getInstance();
+    stallionStorageInstance.set(StallionConstants.CURRENT_PROD_SLOT_KEY, StallionConstants.DEFAULT_FOLDER_SLOT);
+    stallionStorageInstance.set(StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT, "");
+    stallionStorageInstance.set(StallionConstants.PROD_DIRECTORY + StallionConstants.STABLE_FOLDER_SLOT, "");
+    stallionStorageInstance.set(StallionConstants.PROD_DIRECTORY + StallionConstants.TEMP_FOLDER_SLOT, "");
+  }
+
+  private static void emitRollbackEvent(Boolean isAutoRollback, String rolledBackReleaseHash) {
+    WritableMap rollbackEventPayload = Arguments.createMap();
+    rollbackEventPayload.putString("releaseHash", rolledBackReleaseHash);
+    WritableMap rollbackEventObject = StallionEventEmitter.getEventPayload(
+      isAutoRollback ? StallionConstants.NativeEventTypesProd.AUTO_ROLLED_BACK_PROD.toString() : StallionConstants.NativeEventTypesProd.ROLLED_BACK_PROD.toString(),
+      rollbackEventPayload
+    );
+    if(isAutoRollback) {
+      StallionEventEmitter.cacheEvent(rollbackEventObject);
+      StallionStorage stallionStorageInstance = StallionStorage.getInstance();
+      stallionStorageInstance.set(StallionConstants.LAST_ROLLED_BACK_RELEASE_HASH_KEY, rolledBackReleaseHash);
+    } else {
+      StallionEventEmitter.sendEvent(rollbackEventObject);
+    }
+  }
+
+  public static void rollbackStage() {
+    StallionStorage stallionStorageInstance = StallionStorage.getInstance();
+    stallionStorageInstance.set(StallionConstants.CURRENT_STAGE_SLOT_KEY, StallionConstants.DEFAULT_FOLDER_SLOT);
+    stallionStorageInstance.set(StallionConstants.STAGE_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT, "");
+  }
+
+  public static void stabilizeRelease() {
+    StallionStorage stallionStorageInstance = StallionStorage.getInstance();
+
+    String baseFolderPath = stallionStorageInstance.mContext.getFilesDir().getAbsolutePath();
+    StallionFileUtil.moveFile(
+      new File(baseFolderPath, StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT),
+      new File(baseFolderPath, StallionConstants.PROD_DIRECTORY + StallionConstants.STABLE_FOLDER_SLOT)
+    );
+    String newReleaseHash = stallionStorageInstance.get(StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT);
+    stallionStorageInstance.set(StallionConstants.PROD_DIRECTORY + StallionConstants.STABLE_FOLDER_SLOT, newReleaseHash);
+    stallionStorageInstance.set(StallionConstants.PROD_DIRECTORY + StallionConstants.NEW_FOLDER_SLOT, "");
+    WritableMap stabilizeEventPayload = Arguments.createMap();
+    stabilizeEventPayload.putString("releaseHash", newReleaseHash);
+    StallionEventEmitter.sendEvent(
+      StallionEventEmitter.getEventPayload(
+        StallionConstants.NativeEventTypesProd.STABILIZED_PROD.toString(),
+        stabilizeEventPayload
+      )
+    );
+  }
+}

package/android/src/main/java/com/stallion/StallionStorage.java

@@ -6,7 +6,8 @@ import android.preference.PreferenceManager;
 
 public class StallionStorage {
   private static StallionStorage mInstance;
-  private Context mContext;
+  private Boolean isMounted = false;
+  public Context mContext;
 
   private SharedPreferences sharedPreference;
 
@@ -15,11 +16,23 @@ public class StallionStorage {
     return mInstance;
   }
 
+  public Boolean getIsMounted() {
+    return mInstance.isMounted;
+  }
+
+  public void setIsMounted() {
+    mInstance.isMounted = true;
+  }
+
   public void Initialize(Context context){
     mContext = context;
     sharedPreference = PreferenceManager.getDefaultSharedPreferences(mContext);
   }
 
+  public String get(String key) {
+    return sharedPreference.getString(key, "");
+  }
+
   public void set(String key, String value) {
     SharedPreferences.Editor editor = sharedPreference.edit();
     editor.putString(key, value);
@@ -36,18 +49,15 @@ public class StallionStorage {
     return sharedPreference.getInt(key, -1);
   }
 
-  public String get(String key) {
-    return sharedPreference.getString(key, null);
-  }
-
   public void delete(String key, Boolean deleteAll) {
     SharedPreferences.Editor editor = sharedPreference.edit();
-    if(deleteAll == true){
+    if(deleteAll){
       editor.clear();
       return;
     } else {
       editor.remove(key);
     }
+    editor.commit();
   }
 }