ilabs-flir 2.0.6 → 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.6",
+  "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",