ilabs-flir 2.0.5 → 2.0.7

package/README.md

@@ -118,6 +118,8 @@ cd ios
 pod install
 ```
 
+Note: If you installed `ilabs-flir` via npm, `Podfile` autolinking will declare the `Flir` pod for your app automatically. To avoid duplicates, the published npm package will not contain `Flir.podspec` or in-repo podspecs; they are excluded with `.npmignore`. See `docs/MIGRATION_TO_NPM.md` for migration details if you previously used an in-repo `Flir.podspec`.
+
 ##### Building Without FLIR SDK (No Paid License)
 
 If you don't have a paid FLIR developer license, you can build the app without the FLIR SDK. The module will provide fallback stub implementations:

package/android/Flir/src/main/java/flir/android/FlirManager.kt

@@ -63,6 +63,23 @@ object FlirManager {
     }
     
     fun getLatestBitmap(): Bitmap? = latestBitmap
+
+    // Preference: ask SDK to deliver oriented/rotated frames (if SDK supports it)
+    fun setPreferSdkRotation(prefer: Boolean) {
+        sdkManager?.setPreferSdkRotation(prefer)
+    }
+
+    fun isPreferSdkRotation(): Boolean {
+        return sdkManager?.isPreferSdkRotation() ?: false
+    }
+
+    fun getBatteryLevel(): Int {
+        return sdkManager?.getBatteryLevel() ?: -1
+    }
+
+    fun isBatteryCharging(): Boolean {
+        return sdkManager?.isBatteryCharging() ?: false
+    }
     
     /**
      * Initialize the FLIR SDK
@@ -335,6 +352,11 @@ object FlirManager {
             Log.e(TAG, "Error: $message")
             emitError(message)
         }
+
+        override fun onBatteryUpdated(level: Int, isCharging: Boolean) {
+            Log.d(TAG, "onBatteryUpdated: level=$level charging=$isCharging")
+            emitBatteryState(level, isCharging)
+        }
     }
     
     // React Native event emitters
@@ -411,6 +433,24 @@ object FlirManager {
             Log.e(TAG, "Failed to emit devices found", e)
         }
     }
+
+    private fun emitBatteryState(level: Int, isCharging: Boolean) {
+        val ctx = reactContext
+        if (ctx == null) {
+            Log.w(TAG, "Cannot emit FlirBatteryUpdated - reactContext is null!")
+            return
+        }
+        try {
+            val params = Arguments.createMap().apply {
+                putInt("level", level)
+                putBoolean("isCharging", isCharging)
+            }
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("FlirBatteryUpdated", params)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to emit battery state", e)
+        }
+    }
     
     private fun emitError(message: String) {
         val ctx = reactContext ?: return

package/android/Flir/src/main/java/flir/android/FlirModule.kt

@@ -147,6 +147,46 @@ class FlirModule(private val reactContext: ReactApplicationContext) : ReactConte
             promise.reject("ERR_FLIR_DEVICES", e)
         }
     }
+
+    @ReactMethod
+    fun setPreferSdkRotation(prefer: Boolean, promise: Promise) {
+        try {
+            FlirManager.setPreferSdkRotation(prefer)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_SET_ROTATION_PREF", e)
+        }
+    }
+
+    @ReactMethod
+    fun isPreferSdkRotation(promise: Promise) {
+        try {
+            val v = FlirManager.isPreferSdkRotation()
+            promise.resolve(v)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_GET_ROTATION_PREF", e)
+        }
+    }
+
+    @ReactMethod
+    fun getBatteryLevel(promise: Promise) {
+        try {
+            val level = FlirManager.getBatteryLevel()
+            promise.resolve(level)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_GET_BATTERY", e)
+        }
+    }
+
+    @ReactMethod
+    fun isBatteryCharging(promise: Promise) {
+        try {
+            val v = FlirManager.isBatteryCharging()
+            promise.resolve(v)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_CHARGING", e)
+        }
+    }
     
     @ReactMethod
     fun startEmulator(emulatorType: String, promise: Promise) {

package/android/Flir/src/main/java/flir/android/FlirSdkManager.java

@@ -47,6 +47,10 @@ public class FlirSdkManager {
     private final Executor executor = Executors.newFixedThreadPool(2);
     // Single-threaded executor for frame processing to ensure ordered processing
     private final Executor frameExecutor = Executors.newSingleThreadExecutor();
+    // Battery poller scheduler - polls battery level & charging state periodically if supported
+    private final java.util.concurrent.ScheduledExecutorService batteryPoller = java.util.concurrent.Executors.newSingleThreadScheduledExecutor();
+    private volatile int lastPolledBatteryLevel = -1;
+    private volatile boolean lastPolledCharging = false;
     // Frame processing guard - skip frames if still processing previous one
     private volatile boolean isProcessingFrame = false;
     private long lastFrameProcessedMs = 0;
@@ -59,6 +63,8 @@ public class FlirSdkManager {
     private ThermalStreamer streamer;
     private Stream activeStream;
     private final List<Identity> discoveredDevices = Collections.synchronizedList(new ArrayList<>());
+    // When true, prefer getting SDK-provided rotated frames instead of rotating ourselves
+    private volatile boolean preferSdkRotation = false;
     
     // Listener
     private Listener listener;
@@ -73,6 +79,7 @@ public class FlirSdkManager {
         void onDisconnected();
         void onFrame(Bitmap bitmap);
         void onError(String message);
+        void onBatteryUpdated(int level, boolean isCharging);
     }
     
     // Private constructor for singleton
@@ -96,6 +103,34 @@ public class FlirSdkManager {
     public void setListener(Listener listener) {
         this.listener = listener;
     }
+
+    public void setPreferSdkRotation(boolean prefer) {
+        this.preferSdkRotation = prefer;
+        // Try to ask SDK streamer to provide rotated images if possible
+        if (streamer != null) {
+            try {
+                // Try common method names via reflection to avoid hard dependency on exact API signature
+                Object obj = streamer;
+                java.lang.reflect.Method m = null;
+                try { m = obj.getClass().getMethod("setImageRotation", int.class); } catch (Throwable ignored) {}
+                if (m == null) {
+                    try { m = obj.getClass().getMethod("setRotation", int.class); } catch (Throwable ignored) {}
+                }
+                if (m != null) {
+                    // If caller asked SDK to rotate, choose 0 = 'auto' or prefer flag; here we request SDK to respect device orientation
+                    int degrees = prefer ? 0 : 0; // SDK-specific - for now, 0 requests orientation-respected frames if method interprets so
+                    m.invoke(obj, degrees);
+                    Log.d(TAG, "setPreferSdkRotation: requested SDK rotation via reflection");
+                } else {
+                    Log.w(TAG, "setPreferSdkRotation: SDK does not expose rotation API (reflection check)");
+                }
+            } catch (Throwable t) {
+                Log.w(TAG, "setPreferSdkRotation failed (reflection)", t);
+            }
+        }
+    }
+
+    public boolean isPreferSdkRotation() { return preferSdkRotation; }
     
     /**
      * Initialize the FLIR Thermal SDK
@@ -214,6 +249,8 @@ public class FlirSdkManager {
                 if (listener != null) {
                     listener.onConnected(identity);
                 }
+                // Start battery poller for continuous updates
+                startBatteryPoller();
             } catch (Exception e) {
                 Log.e(TAG, "Connection failed", e);
                 camera = null;
@@ -236,6 +273,8 @@ public class FlirSdkManager {
             }
             camera = null;
         }
+        // stop battery poller
+        stopBatteryPoller();
         
         if (listener != null) {
             listener.onDisconnected();
@@ -476,6 +515,67 @@ public class FlirSdkManager {
         }
         return names;
     }
+
+    /**
+     * Best-effort: Fetch battery level from connected camera if SDK exposes battery APIs
+     * Returns -1 if unavailable
+     */
+    public int getBatteryLevel() {
+        if (camera == null) return -1;
+        try {
+            // Common SDK methods to try
+            try {
+                java.lang.reflect.Method m = camera.getClass().getMethod("getBatteryLevel");
+                Object r = m.invoke(camera);
+                if (r instanceof Number) return ((Number) r).intValue();
+            } catch (Throwable ignored) {}
+
+            try {
+                java.lang.reflect.Method m = camera.getClass().getMethod("getBattery");
+                Object batt = m.invoke(camera);
+                if (batt != null) {
+                    try {
+                        java.lang.reflect.Method levelMethod = batt.getClass().getMethod("getLevel");
+                        Object lv = levelMethod.invoke(batt);
+                        if (lv instanceof Number) return ((Number) lv).intValue();
+                    } catch (Throwable ignored) {}
+                }
+            } catch (Throwable ignored) {}
+        } catch (Throwable t) {
+            Log.w(TAG, "Error querying battery level", t);
+        }
+        return -1;
+    }
+
+    /**
+     * Best-effort: Check if the camera is charging
+     * Returns false if unknown
+     */
+    public boolean isBatteryCharging() {
+        if (camera == null) return false;
+        try {
+            try {
+                java.lang.reflect.Method m = camera.getClass().getMethod("isCharging");
+                Object r = m.invoke(camera);
+                if (r instanceof Boolean) return (Boolean) r;
+            } catch (Throwable ignored) {}
+
+            try {
+                java.lang.reflect.Method m = camera.getClass().getMethod("getBattery");
+                Object batt = m.invoke(camera);
+                if (batt != null) {
+                    try {
+                        java.lang.reflect.Method isCh = batt.getClass().getMethod("isCharging");
+                        Object cv = isCh.invoke(batt);
+                        if (cv instanceof Boolean) return (Boolean) cv;
+                    } catch (Throwable ignored) {}
+                }
+            } catch (Throwable ignored) {}
+        } catch (Throwable t) {
+            Log.w(TAG, "Error querying battery charging state", t);
+        }
+        return false;
+    }
     
     // Find palette by name
     private Palette findPalette(String name) {
@@ -580,4 +680,39 @@ public class FlirSdkManager {
         instance = null;
         Log.d(TAG, "Destroyed");
     }
+
+    /**
+     * Start a background poller to periodically check battery state and notify listener
+     */
+    private void startBatteryPoller() {
+        try {
+            batteryPoller.scheduleAtFixedRate(() -> {
+                if (camera == null) return;
+                try {
+                    int level = getBatteryLevel();
+                    boolean charging = isBatteryCharging();
+                    if (level != lastPolledBatteryLevel || charging != lastPolledCharging) {
+                        lastPolledBatteryLevel = level;
+                        lastPolledCharging = charging;
+                        if (listener != null) {
+                            try { listener.onBatteryUpdated(level, charging);} catch (Throwable t) {}
+                        }
+                    }
+                } catch (Throwable t) {
+                    Log.w(TAG, "Battery poller error", t);
+                }
+            }, 0, 5, java.util.concurrent.TimeUnit.SECONDS);
+        } catch (Throwable t) {
+            Log.w(TAG, "Failed to start battery poller", t);
+        }
+    }
+
+    /**
+     * Stop the battery poller.
+     */
+    private void stopBatteryPoller() {
+        try {
+            batteryPoller.shutdownNow();
+        } catch (Throwable ignored) {}
+    }
 }

package/ios/Flir/src/FlirEventEmitter.m

@@ -32,7 +32,7 @@ RCT_EXPORT_MODULE();
   return @[
     @"FlirDeviceConnected", @"FlirDeviceDisconnected", @"FlirDevicesFound",
     @"FlirFrameReceived", @"FlirFrame", @"FlirError", @"FlirStateChanged",
-    @"FlirTemperatureUpdate"
+    @"FlirTemperatureUpdate", @"FlirBatteryUpdated"
   ];
 }
 

package/ios/Flir/src/FlirModule.h

@@ -12,6 +12,9 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface FlirModule : RCTEventEmitter <RCTBridgeModule>
 
+// Utility for other native code to emit battery updates (level 0-100 or -1 if unknown)
++ (void)emitBatteryUpdateWithLevel:(NSInteger)level charging:(BOOL)charging;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Flir/src/FlirModule.m

@@ -77,6 +77,7 @@ RCT_EXPORT_MODULE(FlirModule);
         @"FlirFrameReceived",
         @"FlirError",
         @"FlirStateChanged"
+        , @"FlirBatteryUpdated"
     ];
 }
 
@@ -88,6 +89,15 @@ RCT_EXPORT_METHOD(removeListeners:(NSInteger)count) {
     // Required for RCTEventEmitter
 }
 
+// Provide a class helper so other native modules can post a battery update
++ (void)emitBatteryUpdateWithLevel:(NSInteger)level charging:(BOOL)charging {
+    NSDictionary *payload = @{
+        @"level": @(level),
+        @"isCharging": @(charging)
+    };
+    [[FlirEventEmitter shared] sendDeviceEvent:@"FlirBatteryUpdated" body:payload];
+}
+
 #pragma mark - Discovery Methods
 
 RCT_EXPORT_METHOD(startDiscovery:(RCTPromiseResolveBlock)resolve
@@ -334,10 +344,8 @@ RCT_EXPORT_METHOD(getTemperatureAt:(nonnull NSNumber *)x
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     dispatch_async(dispatch_get_main_queue(), ^{
-        double temp = [FlirState shared].lastTemperature;
-        if (isnan(temp)) {
-            temp = self.lastTemperature;
-        }
+        // Call into native FLIRManager to query temperature at point
+        double temp = [[FLIRManager shared] getTemperatureAtPoint:[x intValue] y:[y intValue]];
         if (isnan(temp)) {
             resolve([NSNull null]);
         } else {
@@ -501,6 +509,51 @@ RCT_EXPORT_METHOD(getLatestFramePath:(RCTPromiseResolveBlock)resolve
     });
 }
 
+RCT_EXPORT_METHOD(getBatteryLevel:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        #if FLIR_SDK_AVAILABLE
+        int level = [[FLIRManager shared] getBatteryLevel];
+        resolve(@(level));
+        #else
+        resolve(@(-1));
+        #endif
+    });
+}
+
+RCT_EXPORT_METHOD(isBatteryCharging:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        #if FLIR_SDK_AVAILABLE
+        BOOL ch = [[FLIRManager shared] isBatteryCharging];
+        resolve(@(ch));
+        #else
+        resolve(@(NO));
+        #endif
+    });
+}
+
+RCT_EXPORT_METHOD(setPreferSdkRotation:(BOOL)prefer
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        @try {
+            [[FLIRManager shared] setPreferSdkRotation:prefer];
+            resolve(@(YES));
+        } @catch (NSException *ex) {
+            reject(@"ERR_FLIR_SET_ROTATION_PREF", ex.reason, nil);
+        }
+    });
+}
+
+RCT_EXPORT_METHOD(isPreferSdkRotation:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        BOOL v = [[FLIRManager shared] isPreferSdkRotation];
+        resolve(@(v));
+    });
+}
+
 #pragma mark - Helper Methods
 
 - (void)emitDeviceConnected {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilabs-flir",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "FLIR Thermal SDK for React Native - iOS & Android (bundled at compile time via postinstall)",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -13,11 +13,9 @@
     "src/",
     "android/Flir/src/",
     "android/Flir/build.gradle.kts",
-    "android/Flir/libs/",
     "ios/Flir/src/",
     "ios/Flir/SDKLoader/",
-    "ios/Flir/Framework/",
-    "ios/Flir/Frameworks/",
+    
     "app.plugin.js",
     "Flir.podspec",
     "sdk-manifest.json",

package/scripts/fetch-binaries.js

@@ -96,7 +96,7 @@ function extractZip(zipPath, dest) {
 
   if (cmdExists('unzip')) {
     try {
-      execSync(`unzip -o '${zipPath}' -d '${TMP_DIR}'`, { stdio: 'inherit' });
+      execSync(`unzip -o "${zipPath}" -d "${TMP_DIR}"`, { stdio: 'inherit' });
       return;
     } catch (err) {
       throw new Error(`Failed to extract zip using 'unzip'. Consider installing 'unzip' or adding 'adm-zip' package. Original error: ${err.message}`);
@@ -106,7 +106,11 @@ function extractZip(zipPath, dest) {
   // 'tar' can sometimes extract zip files (via bsdtar). Try it as a last resort.
   if (cmdExists('tar')) {
     try {
-      execSync(`tar -xf '${zipPath}' -C '${TMP_DIR}'`, { stdio: 'inherit' });
+      if (process.platform === 'win32') {
+        execSync(`tar -xf "${zipPath}" -C "${TMP_DIR}"`, { stdio: 'inherit' });
+      } else {
+        execSync(`tar -xf '${zipPath}' -C '${TMP_DIR}'`, { stdio: 'inherit' });
+      }
       return;
     } catch (err) {
       throw new Error(`Failed to extract zip using 'tar'. Consider installing 'unzip' or add 'adm-zip' package. Original error: ${err.message}`);
@@ -172,27 +176,67 @@ async function run() {
       return;
     }
 
-    // Ensure target folders exist - but do NOT create them automatically.
-    if (!fs.existsSync(DEST_ANDROID)) {
-      throw new Error(`Android libs folder ${DEST_ANDROID} does not exist. Please create it (e.g. npm pack or ensure published package includes it).`);
-    }
-    if (!fs.existsSync(DEST_IOS)) {
-      throw new Error(`iOS Frameworks folder ${DEST_IOS} does not exist. Please create it before install.`);
-    }
+    // (previous 'ensure target folders exist' logic removed; handling now occurs after args parsing)
 
     ensureTmp();
 
     const argv = process.argv.slice(2);
-    const args = argv.reduce((acc, cur) => {
-      if (cur.startsWith('--')) acc[cur.replace(/^--/, '')] = true;
-      else acc[cur] = true;
-      return acc;
-    }, {});
+    const args = {};
+    for (let i = 0; i < argv.length; i++) {
+      const cur = argv[i];
+      if (cur.startsWith('--')) {
+        if (cur.includes('=')) {
+          const parts = cur.split('=');
+          const key = parts.shift().replace(/^--/, '');
+          const value = parts.join('=');
+          args[key] = value;
+        } else {
+          // if following arg exists and doesn't start with '-', use it as the value
+          const next = argv[i+1];
+          if (next && !next.startsWith('-')) {
+            args[cur.replace(/^--/, '')] = next;
+            i++;
+          } else {
+            args[cur.replace(/^--/, '')] = true;
+          }
+        }
+      } else if (cur.startsWith('-')) {
+        const key = cur.replace(/^-+/, '');
+        const next = argv[i+1];
+        if (next && !next.startsWith('-')) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = true;
+        }
+      } else {
+        args[cur] = true;
+      }
+    }
 
     // Skip if present per-platform
     const skipIfPresent = args['skip-if-present'] || args['skipIfPresent'] || false;
     const platformArg = args['platform'] || args['p'] || 'all';
 
+    // Determine whether to create missing dest directories automatically; default is true unless explicitly disabled
+    const noCreate = process.env.FLIR_SDK_NO_CREATE_DEST === '1' || process.env.FLIR_SDK_NO_CREATE_DEST === 'true' || args['no-create-dest'] || args['noCreateDest'];
+    if ((platformArg === 'all' || platformArg === 'android') && !fs.existsSync(DEST_ANDROID)) {
+      if (noCreate) {
+        throw new Error(`Android libs folder ${DEST_ANDROID} does not exist. Please create it (e.g. npm pack or ensure published package includes it).`);
+      } else {
+        console.log(`Android libs folder ${DEST_ANDROID} not found — creating it.`);
+        fs.mkdirSync(DEST_ANDROID, { recursive: true });
+      }
+    }
+    if ((platformArg === 'all' || platformArg === 'ios') && !fs.existsSync(DEST_IOS)) {
+      if (noCreate) {
+        throw new Error(`iOS Frameworks folder ${DEST_IOS} does not exist. Please create it before install.`);
+      } else {
+        console.log(`iOS Frameworks folder ${DEST_IOS} not found — creating it.`);
+        fs.mkdirSync(DEST_IOS, { recursive: true });
+      }
+    }
+
     // Short circuit checks: if skipIfPresent set and files exist, skip per platform
     if (skipIfPresent && platformArg !== 'ios' && hasAndroidAar(DEST_ANDROID)) {
       console.log('Android AAR(s) detected in libs folder; skipping Android fetch.');