react-native-stallion 2.3.0-alpha.4 → 2.3.0-alpha.5

package/android/build.gradle

@@ -1,3 +1,5 @@
+import groovy.json.JsonSlurper
+
 buildscript {
   repositories {
     google()
@@ -30,6 +32,22 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Stallion_" + name]).toInteger()
 }
 
+def getSdkVersionFromPackageJson() {
+  try {
+    def pkgFile = new File(projectDir.parentFile, "package.json")
+    if (!pkgFile.exists()) {
+      logger.lifecycle("Stallion: package.json not found at ${pkgFile.absolutePath}, defaulting to 0.0.0")
+      return "0.0.0"
+    }
+    def json = new JsonSlurper().parseText(pkgFile.text)
+    def version = (json?.version ?: "0.0.0").toString()
+    logger.lifecycle("Stallion: Resolved SDK version ${version} from ${pkgFile.absolutePath}")
+    return version
+  } catch (Throwable ignored) {
+    return "0.0.0"
+  }
+}
+
 def stallionEnabled = true
 
 android {
@@ -48,6 +66,7 @@ android {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    buildConfigField "String", "STALLION_SDK_VERSION", "\"${getSdkVersionFromPackageJson()}\""
   }
   buildTypes {
     release {
@@ -64,6 +83,12 @@ android {
     targetCompatibility JavaVersion.VERSION_1_8
   }
 
+  externalNativeBuild {
+    cmake {
+      path file("src/main/cpp/CMakeLists.txt")
+    }
+  }
+
 }
 
 repositories {

package/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.10.2)
+
+project(stallion_crash)
+
+add_library(
+  stallion-crash
+  SHARED
+  stallion_signal_handler.cpp
+)
+
+find_library(
+  log-lib
+  log
+)
+
+target_link_libraries(
+  stallion-crash
+  ${log-lib}
+)

package/android/src/main/cpp/stallion_signal_handler.cpp

@@ -0,0 +1,62 @@
+#include <jni.h>
+#include <signal.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdio.h>
+
+static char g_marker_path[512];
+static char g_mount_marker_path[512];
+
+// Async-signal-safe function to check if mount marker exists
+static int is_mounted() {
+  int fd = open(g_mount_marker_path, O_RDONLY);
+  if (fd >= 0) {
+    close(fd);
+    return 1; // Mounted
+  }
+  return 0; // Not mounted
+}
+
+// Async-signal-safe JSON writing (minimal JSON for crash marker)
+static void write_crash_marker_json(int signal, int mounted) {
+  int fd = open(g_marker_path, O_CREAT | O_WRONLY | O_TRUNC, 0600);
+  if (fd >= 0) {
+    // Write JSON: {"signal":X,"isAutoRollback":true/false,"crashLog":"signal=X\n"}
+    // isAutoRollback = !mounted (auto rollback if not mounted)
+    int autoRollback = !mounted;
+    char json[512];
+    int len = snprintf(json, sizeof(json),
+      "{\"signal\":%d,\"isAutoRollback\":%s,\"crashLog\":\"signal=%d\\n\"}",
+      signal, autoRollback ? "true" : "false", signal);
+    if (len > 0 && len < (int)sizeof(json)) {
+      (void)write(fd, json, len);
+    }
+    close(fd);
+  }
+}
+
+static void stallion_signal_handler(int sig) {
+  // Read mount state at crash time (async-signal-safe)
+  int mounted = is_mounted();
+  // Write JSON marker with crash info and autoRollback flag
+  write_crash_marker_json(sig, mounted);
+  signal(sig, SIG_DFL);
+  raise(sig);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_stallion_utils_StallionExceptionHandler_initNativeSignalHandler(
+  JNIEnv* env, jclass, jstring filesDir) {
+  const char* path = env->GetStringUTFChars(filesDir, nullptr);
+  snprintf(g_marker_path, sizeof(g_marker_path), "%s/%s", path, "stallion_crash.marker");
+  snprintf(g_mount_marker_path, sizeof(g_mount_marker_path), "%s/%s", path, "stallion_mount.marker");
+  env->ReleaseStringUTFChars(filesDir, path);
+
+  signal(SIGABRT, stallion_signal_handler);
+  signal(SIGSEGV, stallion_signal_handler);
+  signal(SIGILL,  stallion_signal_handler);
+  signal(SIGBUS,  stallion_signal_handler);
+  signal(SIGFPE,  stallion_signal_handler);
+}

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

@@ -29,8 +29,6 @@ public class Stallion {
 
     validateAppVersion(stateManager.getStallionConfig().getAppVersion());
 
-    StallionEventManager.init(stateManager);
-
     String baseFolderPath = stateManager.getStallionConfig().getFilesDirectory();
     StallionMeta stallionMeta = stateManager.stallionMeta;
     StallionMetaConstants.SwitchState switchState = stallionMeta.getSwitchState();

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

@@ -10,6 +10,7 @@ import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.stallion.events.StallionEventConstants;
 import com.stallion.events.StallionEventManager;
 import com.stallion.networkmanager.StallionStageManager;
 import com.stallion.networkmanager.StallionSyncHandler;
@@ -21,6 +22,7 @@ import com.stallion.utils.ProcessPhoenix;
 
 import org.json.JSONArray;
 import org.json.JSONException;
+import org.json.JSONObject;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -34,7 +36,6 @@ public class StallionModule extends ReactContextBaseJavaModule implements Lifecy
     super(reactContext);
     StallionStateManager.init(reactContext);
     this.stallionStateManager = StallionStateManager.getInstance();
-    StallionEventManager.init(this.stallionStateManager);
     reactContext.addLifecycleEventListener(this);
   }
 
@@ -60,12 +61,23 @@ public class StallionModule extends ReactContextBaseJavaModule implements Lifecy
 
   @ReactMethod
   public void onLaunch(String launchData) {
+    // try {
+    //  JSONObject launchDataJson = new JSONObject(launchData);
+    // } catch (Exception e) {
+    //   e.printStackTrace();
+    // }
     stallionStateManager.setIsMounted(true);
     DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter = getReactApplicationContext().getJSModule(
       DeviceEventManagerModule.RCTDeviceEventEmitter.class
     );
     StallionEventManager.getInstance().setEmitter(eventEmitter);
     checkPendingDownloads();
+    String currentReleaseHash = stallionStateManager.stallionMeta.getHashAtCurrentProdSlot();
+    if(!currentReleaseHash.isEmpty() && stallionStateManager.stallionMeta.getSuccessfulLaunchCount(currentReleaseHash) == 0) {
+      emitInstallEvent(currentReleaseHash);
+    }
+    stallionStateManager.stallionMeta.markSuccessfulLaunch(currentReleaseHash);
+    stallionStateManager.syncStallionMeta();
   }
 
   private void checkPendingDownloads() {
@@ -167,4 +179,28 @@ public class StallionModule extends ReactContextBaseJavaModule implements Lifecy
   public void restart() {
     ProcessPhoenix.triggerRebirth(getReactApplicationContext());
   }
+
+  @ReactMethod
+  public void addListener(String eventName) {
+    // No-op: required for RN event emitter contract
+  }
+
+  @ReactMethod
+  public void removeListeners(double count) {
+    // No-op: required for RN event emitter contract
+  }
+
+  private void emitInstallEvent(String releaseHash) {
+    try {
+      JSONObject eventPayload = new JSONObject();
+      eventPayload.put("releaseHash", releaseHash);
+
+      StallionEventManager.getInstance().sendEventWithoutCaching(
+        StallionEventConstants.NativeProdEventTypes.INSTALLED_PROD.toString(),
+        eventPayload
+      );
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
 }

package/android/src/main/java/com/stallion/events/StallionEventConstants.java

@@ -3,6 +3,7 @@ package com.stallion.events;
 public class StallionEventConstants {
   public enum NativeProdEventTypes {
     DOWNLOAD_STARTED_PROD,
+    DOWNLOAD_PROGRESS_PROD,
     DOWNLOAD_RESUME_PROD,
     DOWNLOAD_ERROR_PROD,
     DOWNLOAD_COMPLETE_PROD,

package/android/src/main/java/com/stallion/events/StallionEventManager.java

@@ -1,6 +1,7 @@
 package com.stallion.events;
 
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.stallion.BuildConfig;
 import com.stallion.storage.StallionConfig;
 import com.stallion.storage.StallionConfigConstants;
 import com.stallion.storage.StallionStateManager;
@@ -18,21 +19,20 @@ public class StallionEventManager {
   public  static final String STALLION_NATIVE_EVENT_NAME = "STALLION_NATIVE_EVENT";
   private static final String EVENTS_KEY = "stored_events";
   private static final int MAX_BATCH_COUNT_SIZE = 9;
-  private static final int MAX_EVENT_STORAGE_LIMIT = 20;
+  private static final int MAX_EVENT_STORAGE_LIMIT = 60;
 
   private static StallionEventManager instance;
-  private final StallionStateManager stallionStateManager;
   private final AtomicReference<DeviceEventManagerModule.RCTDeviceEventEmitter> eventEmitterRef = new AtomicReference<>();
 
   // Private constructor for Singleton
-  private StallionEventManager(StallionStateManager stateManager) {
-    this.stallionStateManager = stateManager;
+  private StallionEventManager() {
+
   }
 
   // Singleton initialization method
-  public static synchronized void init(StallionStateManager stateManager) {
+  public static synchronized void init() {
     if (instance == null) {
-      instance = new StallionEventManager(stateManager);
+      instance = new StallionEventManager();
     }
   }
 
@@ -57,7 +57,8 @@ public class StallionEventManager {
       eventPayload.put("type", eventName);
       DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter = eventEmitterRef.get();
       // Emit the event to React Native
-      if (eventEmitter != null && stallionStateManager.getIsMounted()) {
+      StallionStateManager stateManager = StallionStateManager.getInstance();
+      if (eventEmitter != null && stateManager.getIsMounted()) {
         eventEmitter.emit(STALLION_NATIVE_EVENT_NAME, eventPayload.toString());
       }
 
@@ -69,7 +70,8 @@ public class StallionEventManager {
   // Method to send an event
   public void sendEvent(String eventName, JSONObject eventPayload) {
     try {
-      StallionConfig stallionConfig = this.stallionStateManager.getStallionConfig();
+      StallionStateManager stateManager = StallionStateManager.getInstance();
+      StallionConfig stallionConfig = stateManager.getStallionConfig();
       // Generate a unique ID for the event
       String uniqueId = UUID.randomUUID().toString();
 
@@ -77,10 +79,11 @@ public class StallionEventManager {
 
       DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter = eventEmitterRef.get();
       // Emit the event to React Native
-      if (eventEmitter != null && stallionStateManager.getIsMounted()) {
+      if (eventEmitter != null && stateManager.getIsMounted()) {
         eventEmitter.emit(STALLION_NATIVE_EVENT_NAME, eventPayload.toString());
       }
 
+
       // change type for sending to server
       eventPayload.remove("type");
       eventPayload.put("eventType", eventName);
@@ -92,6 +95,7 @@ public class StallionEventManager {
       eventPayload.put("platform", StallionConfigConstants.PLATFORM);
       eventPayload.put("appVersion", stallionConfig.getAppVersion());
       eventPayload.put("uid", stallionConfig.getUid());
+      eventPayload.put("sdkVersion", BuildConfig.STALLION_SDK_VERSION);
 
       // Store the event locally
       storeEventLocally(uniqueId, eventPayload);
@@ -104,7 +108,8 @@ public class StallionEventManager {
   // Store the event locally in SharedPreferences
   private void storeEventLocally(String uniqueId, JSONObject eventPayload) {
     try {
-      String eventsString = stallionStateManager.getString(EVENTS_KEY, "{}");
+      StallionStateManager stateManager = StallionStateManager.getInstance();
+      String eventsString = stateManager.getString(EVENTS_KEY, "{}");
       JSONObject eventsObject = new JSONObject(eventsString);
 
       // Flush all if limit reached
@@ -113,7 +118,7 @@ public class StallionEventManager {
       }
 
       eventsObject.put(uniqueId, eventPayload.toString());
-      stallionStateManager.setString(EVENTS_KEY, eventsObject.toString());
+      stateManager.setString(EVENTS_KEY, eventsObject.toString());
     } catch (JSONException e) {
       cleanupEventStorage();
       e.printStackTrace();
@@ -121,13 +126,15 @@ public class StallionEventManager {
   }
 
   private void cleanupEventStorage() {
-    stallionStateManager.setString(EVENTS_KEY, "{}");
+    StallionStateManager stateManager = StallionStateManager.getInstance();
+    stateManager.setString(EVENTS_KEY, "{}");
   }
 
   // Method to pop events as a batch
   public String popEvents() {
     try {
-      String eventsString = stallionStateManager.getString(EVENTS_KEY, "{}");
+      StallionStateManager stateManager = StallionStateManager.getInstance();
+      String eventsString = stateManager.getString(EVENTS_KEY, "{}");
       JSONObject eventsObject = new JSONObject(eventsString);
 
       JSONArray batch = new JSONArray();
@@ -153,7 +160,8 @@ public class StallionEventManager {
   // Acknowledge events by deleting them from local storage
   public void acknowledgeEvents(List<String> eventIds) {
     try {
-      String eventsString = stallionStateManager.getString(EVENTS_KEY, "{}");
+      StallionStateManager stateManager = StallionStateManager.getInstance();
+      String eventsString = stateManager.getString(EVENTS_KEY, "{}");
       JSONObject eventsObject = new JSONObject(eventsString);
 
       // Remove each event by its unique ID
@@ -164,7 +172,7 @@ public class StallionEventManager {
       }
 
       // Update the SharedPreferences with the modified events
-      stallionStateManager.setString(EVENTS_KEY, eventsObject.toString());
+      stateManager.setString(EVENTS_KEY, eventsObject.toString());
 
     } catch (JSONException e) {
       e.printStackTrace();

package/android/src/main/java/com/stallion/networkmanager/StallionFileDownloader.java

@@ -3,10 +3,8 @@ package com.stallion.networkmanager;
 import android.os.StatFs;
 
 import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.net.HttpURLConnection;
@@ -25,6 +23,7 @@ public class StallionFileDownloader {
 
   private static final String TAG = "StallionFileDownloader";
   private static final ExecutorService executor = Executors.newSingleThreadExecutor();
+  private static final long DEFAULT_PROGRESS_THROTTLE_INTERVAL_MS = 300L;
 
   public static void downloadBundle(
     String downloadUrl,
@@ -125,7 +124,7 @@ public class StallionFileDownloader {
       long totalBytes = connection.getContentLength() + alreadyDownloaded;
       long receivedBytes = alreadyDownloaded;
       int bytesRead;
-      double lastProgress = (double) receivedBytes / totalBytes;
+      long lastProgressEmitTimeMs = 0L;
 
       // Ensure totalBytes is valid
       if (totalBytes <= 0) {
@@ -145,8 +144,8 @@ public class StallionFileDownloader {
           return;
         }
 
-        if (progress - lastProgress >= 0.1) {
-          lastProgress = progress;
+        if (shouldEmitProgress(lastProgressEmitTimeMs, DEFAULT_PROGRESS_THROTTLE_INTERVAL_MS)) {
+          lastProgressEmitTimeMs = System.currentTimeMillis();
           callback.onProgress(progress);
         }
       }
@@ -194,6 +193,10 @@ public class StallionFileDownloader {
     return connection;
   }
 
+  private static boolean shouldEmitProgress(long lastEmitTimeMs, long intervalMs) {
+    return System.currentTimeMillis() - lastEmitTimeMs >= intervalMs;
+  }
+
   private static void validateAndUnzip(
     File downloadedZip,
     String destDirectory,

package/android/src/main/java/com/stallion/networkmanager/StallionSyncHandler.java

@@ -1,10 +1,12 @@
 package com.stallion.networkmanager;
 
+import com.stallion.events.StallionEventConstants;
 import com.stallion.events.StallionEventManager;
 import com.stallion.storage.StallionConfigConstants;
 import com.stallion.storage.StallionMetaConstants;
 import com.stallion.storage.StallionStateManager;
 import com.stallion.storage.StallionConfig;
+import com.stallion.utils.StallionDeviceInfo;
 import com.stallion.utils.StallionFileManager;
 import com.stallion.utils.StallionSignatureVerification;
 import com.stallion.utils.StallionSlotManager;
@@ -43,6 +45,8 @@ public class StallionSyncHandler {
         requestPayload.put("platform", "android");
         requestPayload.put("projectId", projectId);
         requestPayload.put("appliedBundleHash", appliedBundleHash);
+        // Attach device metadata for analytics
+        requestPayload.put("deviceMeta", StallionDeviceInfo.getDeviceMetaJson(config));
 
         // Make API call using StallionApiManager
         JSONObject releaseMeta = StallionApiManager.post(
@@ -52,7 +56,7 @@ public class StallionSyncHandler {
 
         // Process API response
         processReleaseMeta(releaseMeta, appVersion);
-
+        stateManager.setIsSyncSuccessful(true);
       } catch (Exception e) {
         emitSyncError(e);
       } finally {
@@ -167,6 +171,7 @@ public class StallionSyncHandler {
           @Override
           public void onProgress(double downloadFraction) {
             // Optional: Handle progress updates
+            emitDownloadProgressProd(newReleaseHash, downloadFraction);
           }
         }
       );
@@ -175,6 +180,18 @@ public class StallionSyncHandler {
     }
   }
 
+  private static void emitDownloadProgressProd(String releaseHash, double newProgress) {
+    JSONObject successPayload = new JSONObject();
+    try {
+      successPayload.put("releaseHash", releaseHash);
+      successPayload.put("progress", String.valueOf(newProgress));
+    } catch (Exception ignored) { }
+    StallionEventManager.getInstance().sendEventWithoutCaching(
+      StallionEventConstants.NativeProdEventTypes.DOWNLOAD_PROGRESS_PROD.toString(),
+      successPayload
+    );
+  }
+
   private static void emitSyncError(Exception e) {
     JSONObject syncErrorPayload = new JSONObject();
     try {

package/android/src/main/java/com/stallion/storage/StallionMeta.java

@@ -14,6 +14,12 @@ public class StallionMeta {
   private String prodNewHash;
   private String prodStableHash;
   private String lastRolledBackHash;
+  private long lastRolledBackAt;
+  private int successfulLaunchCount;
+  private String lastSuccessfulLaunchHash;
+
+  public static final int MAX_SUCCESS_LAUNCH_THRESHOLD = 3;
+  public static final long LAST_ROLLED_BACK_TTL_MS = 6L * 60L * 60L * 1000L; // 6 hours
 
   public StallionMeta() {
     this.reset();
@@ -29,6 +35,9 @@ public class StallionMeta {
     this.prodNewHash = "";
     this.prodStableHash = "";
     this.lastRolledBackHash = "";
+    this.lastRolledBackAt = 0L;
+    this.successfulLaunchCount = 0;
+    this.lastSuccessfulLaunchHash = "";
   }
 
   // Getters and Setters
@@ -121,11 +130,13 @@ public class StallionMeta {
   }
 
   public String getLastRolledBackHash() {
+    enforceLastRolledBackExpiry();
     return lastRolledBackHash;
   }
 
   public void setLastRolledBackHash(String lastRolledBackHash) {
-    this.lastRolledBackHash = lastRolledBackHash;
+    this.lastRolledBackHash = lastRolledBackHash == null ? "" : lastRolledBackHash;
+    this.lastRolledBackAt = this.lastRolledBackHash.isEmpty() ? 0L : System.currentTimeMillis();
   }
 
   // Convert to JSON
@@ -148,6 +159,9 @@ public class StallionMeta {
       metaJson.put("prodSlot", prodJson);
 
       metaJson.put("lastRolledBackHash", lastRolledBackHash);
+      metaJson.put("lastRolledBackAt", lastRolledBackAt);
+      metaJson.put("successfulLaunchCount", successfulLaunchCount);
+      metaJson.put("lastSuccessfulLaunchHash", lastSuccessfulLaunchHash);
 
     } catch (JSONException e) {
       return new JSONObject();
@@ -169,6 +183,9 @@ public class StallionMeta {
       );
 
       stallionMeta.setLastRolledBackHash(jsonObject.optString("lastRolledBackHash", ""));
+      stallionMeta.lastRolledBackAt = jsonObject.optLong("lastRolledBackAt", 0L);
+      stallionMeta.successfulLaunchCount = jsonObject.optInt("successfulLaunchCount", 0);
+      stallionMeta.lastSuccessfulLaunchHash = jsonObject.optString("lastSuccessfulLaunchHash", "");
 
       JSONObject stageJson = jsonObject.optJSONObject("stageSlot");
       if(stageJson != null) {
@@ -203,4 +220,38 @@ public class StallionMeta {
       return stallionMeta;
     }
   }
+
+  public void markSuccessfulLaunch(String releaseHash) {
+    if(releaseHash == null || releaseHash.isEmpty()) {
+      return;
+    }
+    if (!releaseHash.equals(this.lastSuccessfulLaunchHash)) {
+      this.successfulLaunchCount = 0;
+      this.lastSuccessfulLaunchHash = releaseHash;
+    }
+    if (this.successfulLaunchCount < MAX_SUCCESS_LAUNCH_THRESHOLD) {
+      this.successfulLaunchCount += 1;
+    }
+  }
+
+  public int getSuccessfulLaunchCount(String releaseHash) {
+    String currentHash = releaseHash == null ? "" : releaseHash;
+    if (!currentHash.equals(this.lastSuccessfulLaunchHash)) {
+      return 0;
+    } else return this.successfulLaunchCount;
+  }
+
+  private void enforceLastRolledBackExpiry() {
+    if (this.lastRolledBackHash == null || this.lastRolledBackHash.isEmpty()) {
+      return;
+    }
+    if (this.lastRolledBackAt <= 0L) {
+      return;
+    }
+    long now = System.currentTimeMillis();
+    if (now - this.lastRolledBackAt >= LAST_ROLLED_BACK_TTL_MS) {
+      this.lastRolledBackHash = "";
+      this.lastRolledBackAt = 0L;
+    }
+  }
 }

package/android/src/main/java/com/stallion/storage/StallionStateManager.java

@@ -3,6 +3,7 @@ package com.stallion.storage;
 import android.content.Context;
 import android.content.SharedPreferences;
 
+import com.stallion.events.StallionEventManager;
 import com.stallion.utils.StallionExceptionHandler;
 
 import org.json.JSONException;
@@ -20,7 +21,7 @@ public class StallionStateManager {
   private boolean isMounted;
   private String pendingReleaseUrl;
   private String pendingReleaseHash;
-
+  private boolean isSyncSuccessful;
 
   private StallionStateManager(Context context) {
     this.sharedPreferences = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
@@ -29,11 +30,15 @@ public class StallionStateManager {
     this.isMounted = false;
     this.pendingReleaseUrl = "";
     this.pendingReleaseHash = "";
+    
+    // Reset mount state on initialization (ensures mount marker file is deleted for new session)
+    setIsMounted(false);
   }
 
   public static synchronized void init(Context context) {
     if (instance == null) {
       instance = new StallionStateManager(context);
+      StallionEventManager.init();
       StallionExceptionHandler.initErrorBoundary();
     }
   }
@@ -78,6 +83,18 @@ public class StallionStateManager {
 
   public void setIsMounted(Boolean isMounted) {
     this.isMounted = isMounted;
+    // Write mount state to a simple file that C++ can read
+    String filesDir = getStallionConfig().getFilesDirectory();
+    java.io.File mountMarker = new java.io.File(filesDir + "/stallion_mount.marker");
+    if (isMounted) {
+      try {
+        // Create file to indicate mounted (file existence = mounted)
+        mountMarker.createNewFile();
+      } catch (Exception ignored) {}
+    } else {
+      // Delete file to indicate not mounted (no file = not mounted)
+      mountMarker.delete();
+    }
   }
 
   public boolean getIsMounted() {
@@ -110,4 +127,8 @@ public class StallionStateManager {
   public String getPendingReleaseHash() {
     return this.pendingReleaseHash;
   }
+
+  public boolean getIsSyncSuccessful() { return this.isSyncSuccessful; }
+
+  public void setIsSyncSuccessful(boolean isSyncSuccessful) { this.isSyncSuccessful = isSyncSuccessful; }
 }