ilabs-flir 2.0.6 → 2.0.8

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/FLIRManager.h

@@ -0,0 +1,24 @@
+// ObjC shim to expose `FLIRManager` from the npm package and forward to `FlirManager` at runtime
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FLIRManager : NSObject
+
++ (instancetype)shared;
+
+- (BOOL)isAvailable;
+- (double)getTemperatureAtPoint:(int)x y:(int)y;
+- (double)getTemperatureAtNormalized:(double)nx y:(double)ny;
+- (int)getBatteryLevel;
+- (BOOL)isBatteryCharging;
+- (void)setPreferSdkRotation:(BOOL)prefer;
+- (BOOL)isPreferSdkRotation;
+- (nullable UIImage *)latestFrameImage;
+- (void)startDiscovery;
+- (void)stopDiscovery;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Flir/src/FLIRManager.m

@@ -0,0 +1,153 @@
+// ObjC shim implementation forwarding to Swift `FlirManager` via runtime selectors
+#import "FLIRManager.h"
+#import <objc/message.h>
+
+@implementation FLIRManager
+
++ (instancetype)shared {
+    Class cls = NSClassFromString(@"FlirManager");
+    if (!cls) return nil;
+    SEL sel = sel_registerName("shared");
+    if (![cls respondsToSelector:sel]) return nil;
+    id (*msgSend0)(id, SEL) = (id (*)(id, SEL))objc_msgSend;
+    return msgSend0((id)cls, sel);
+}
+
+- (BOOL)isAvailable {
+    Class cls = NSClassFromString(@"FlirManager");
+    SEL sel = sel_registerName("isSDKAvailable");
+    if (!cls || ![cls respondsToSelector:sel]) return NO;
+    BOOL (*msgSend0)(id, SEL) = (BOOL (*)(id, SEL))objc_msgSend;
+    return msgSend0((id)cls, sel);
+}
+
+- (double)getTemperatureAtPoint:(int)x y:(int)y {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("getTemperatureAt: y:");
+    // Swift method name mangling may differ; fall back to method used by FlirModule
+    SEL selAlt = sel_registerName("getTemperatureAtPoint:y:");
+    SEL use = NULL;
+    if (inst && [inst respondsToSelector:sel]) use = sel;
+    if (inst && [inst respondsToSelector:selAlt]) use = selAlt;
+    if (!inst || !use) return NAN;
+    double (*msgSend2)(id, SEL, int, int) = (double (*)(id, SEL, int, int))objc_msgSend;
+    return msgSend2(inst, use, x, y);
+}
+
+- (double)getTemperatureAtNormalized:(double)nx y:(double)ny {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("getTemperatureAtNormalized:y:");
+    if (!inst || ![inst respondsToSelector:sel]) return NAN;
+    double (*msgSend2)(id, SEL, double, double) = (double (*)(id, SEL, double, double))objc_msgSend;
+    return msgSend2(inst, sel, nx, ny);
+}
+
+- (int)getBatteryLevel {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("getBatteryLevel");
+    if (!inst || ![inst respondsToSelector:sel]) return -1;
+    int (*msgSend0)(id, SEL) = (int (*)(id, SEL))objc_msgSend;
+    return msgSend0(inst, sel);
+}
+
+- (BOOL)isBatteryCharging {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("isBatteryCharging");
+    if (!inst || ![inst respondsToSelector:sel]) return NO;
+    BOOL (*msgSend0)(id, SEL) = (BOOL (*)(id, SEL))objc_msgSend;
+    return msgSend0(inst, sel);
+}
+
+- (void)setPreferSdkRotation:(BOOL)prefer {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("setPreferSdkRotation:");
+    if (!inst || ![inst respondsToSelector:sel]) return;
+    void (*msgSend1)(id, SEL, BOOL) = (void (*)(id, SEL, BOOL))objc_msgSend;
+    msgSend1(inst, sel, prefer);
+}
+
+- (BOOL)isPreferSdkRotation {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("isPreferSdkRotation");
+    if (!inst || ![inst respondsToSelector:sel]) return NO;
+    BOOL (*msgSend0)(id, SEL) = (BOOL (*)(id, SEL))objc_msgSend;
+    return msgSend0(inst, sel);
+}
+
+- (nullable NSString *)latestFrameBase64 {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("latestFrameBase64");
+    if (!inst || ![inst respondsToSelector:sel]) return nil;
+    id (*msgSend0)(id, SEL) = (id (*)(id, SEL))objc_msgSend;
+    return (NSString *)msgSend0(inst, sel);
+}
+
+- (void)retainClient:(NSString *)clientId {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("retainClient:");
+    if (!inst || ![inst respondsToSelector:sel]) return;
+    void (*msgSend1)(id, SEL, id) = (void (*)(id, SEL, id))objc_msgSend;
+    msgSend1(inst, sel, clientId);
+}
+
+- (void)releaseClient:(NSString *)clientId {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("releaseClient:");
+    if (!inst || ![inst respondsToSelector:sel]) return;
+    void (*msgSend1)(id, SEL, id) = (void (*)(id, SEL, id))objc_msgSend;
+    msgSend1(inst, sel, clientId);
+}
+
+- (void)setPalette:(NSString *)paletteName {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("setPalette:");
+    if (!inst || ![inst respondsToSelector:sel]) return;
+    void (*msgSend1)(id, SEL, id) = (void (*)(id, SEL, id))objc_msgSend;
+    msgSend1(inst, sel, paletteName);
+}
+
+- (void)setPaletteFromAcol:(double)acol {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("setPaletteFromAcol:");
+    if (!inst || ![inst respondsToSelector:sel]) return;
+    void (*msgSend1)(id, SEL, double) = (void (*)(id, SEL, double))objc_msgSend;
+    msgSend1(inst, sel, acol);
+}
+
+- (nullable NSString *)getPaletteNameFromAcol:(double)acol {
+    Class cls = NSClassFromString(@"FlirManager");
+    SEL sel = sel_registerName("getPaletteNameFromAcol:");
+    if (!cls || ![cls respondsToSelector:sel]) return nil;
+    id (*msgSend1)(id, SEL, double) = (id (*)(id, SEL, double))objc_msgSend;
+    return (NSString *)msgSend1((id)cls, sel, acol);
+}
+
+- (nullable UIImage *)latestFrameImage {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("latestImage");
+    SEL selAlt = sel_registerName("latestFrameImage");
+    SEL use = NULL;
+    if (inst && [inst respondsToSelector:selAlt]) use = selAlt;
+    else if (inst && [inst respondsToSelector:sel]) use = sel;
+    if (!inst || !use) return nil;
+    id (*msgSend0)(id, SEL) = (id (*)(id, SEL))objc_msgSend;
+    return (UIImage *)msgSend0(inst, use);
+}
+
+- (void)startDiscovery {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("startDiscovery");
+    if (!inst || ![inst respondsToSelector:sel]) return;
+    void (*msgSend0)(id, SEL) = (void (*)(id, SEL))objc_msgSend;
+    msgSend0(inst, sel);
+}
+
+- (void)stopDiscovery {
+    id inst = [[self class] shared];
+    SEL sel = sel_registerName("stopDiscovery");
+    if (!inst || ![inst respondsToSelector:sel]) return;
+    void (*msgSend0)(id, SEL) = (void (*)(id, SEL))objc_msgSend;
+    msgSend0(inst, sel);
+}
+
+@end

package/ios/Flir/src/FLIRManagerShim.swift

@@ -0,0 +1,48 @@
+import Foundation
+import UIKit
+
+@objc public class FLIRManager: NSObject {
+    @objc public static let shared = FLIRManager()
+
+    @objc public func isAvailable() -> Bool {
+        return FlirManager.isSDKAvailable
+    }
+
+    @objc public func getTemperatureAtPoint(x: Int, y: Int) -> Double {
+        // FlirManager currently doesn't expose a direct getTemperatureAtPoint API.
+        // Return NaN for now (consumers should handle NaN) until full parity is implemented.
+        return Double.nan
+    }
+
+    @objc public func getTemperatureAtNormalized(_ nx: Double, y: Double) -> Double {
+        return Double.nan
+    }
+
+    @objc public func getBatteryLevel() -> Int {
+        return -1
+    }
+
+    @objc public func isBatteryCharging() -> Bool {
+        return false
+    }
+
+    @objc public func setPreferSdkRotation(_ prefer: Bool) {
+        // FlirManager doesn't currently support rotation preference; no-op
+    }
+
+    @objc public func isPreferSdkRotation() -> Bool {
+        return false
+    }
+
+    @objc public func latestFrameImage() -> UIImage? {
+        return FlirManager.shared.latestImage
+    }
+
+    @objc public func startDiscovery() {
+        FlirManager.shared.startDiscovery()
+    }
+
+    @objc public func stopDiscovery() {
+        FlirManager.shared.stopDiscovery()
+    }
+}

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/FlirManager.swift

@@ -70,6 +70,9 @@ import ThermalSDK
     
     // Discovered devices
     private var discoveredDevices: [FlirDeviceInfo] = []
+    // Client lifecycle for discovery/connection ownership
+    private var activeClients: Set<String> = []
+    private var shutdownWorkItem: DispatchWorkItem? = nil
     
 #if FLIR_ENABLED
     private var discovery: FLIRDiscovery?
@@ -100,6 +103,164 @@ import ThermalSDK
     @objc public func getDiscoveredDevices() -> [FlirDeviceInfo] {
         return discoveredDevices
     }
+
+    // MARK: - Temperature & Battery Access
+
+    /// Returns a temperature data dictionary for the given pixel, or nil if unavailable.
+    @objc public func getTemperatureData(x: Int = -1, y: Int = -1) -> [String: Any]? {
+#if FLIR_ENABLED
+        guard let streamer = streamer else { return nil }
+        var result: [String: Any]? = nil
+        streamer.withThermalImage { thermalImage in
+            // Attempt to extract per-pixel measurements if available
+            if let measurements = thermalImage.measurements as? [NSNumber],
+               measurements.count > 0,
+               let img = streamer.getImage() {
+                let width = Int(img.size.width)
+                let height = Int(img.size.height)
+                if width > 0 && height > 0 && x >= 0 && y >= 0 && x < width && y < height {
+                    let idx = y * width + x
+                    if idx < measurements.count {
+                        let temp = measurements[idx].doubleValue
+                        result = ["temperature": temp]
+                    }
+                }
+            }
+            // Fallback: use lastTemperature if set
+            if result == nil && !lastTemperature.isNaN {
+                result = ["temperature": lastTemperature]
+            }
+        }
+        return result
+#else
+        return nil
+#endif
+    }
+
+    @objc public func getTemperatureAtPoint(_ x: Int, y: Int) -> Double {
+        if let data = getTemperatureData(x: x, y: y), let t = data["temperature"] as? Double {
+            return t
+        }
+        return Double.nan
+    }
+
+    @objc public func getTemperatureAtNormalized(_ nx: Double, y: Double) -> Double {
+        guard let img = latestImage else { return Double.nan }
+        let px = Int(nx * Double(img.size.width))
+        let py = Int(y * Double(img.size.height))
+        return getTemperatureAtPoint(px, y: py)
+    }
+
+    @objc public func getBatteryLevel() -> Int {
+#if FLIR_ENABLED
+        if let cam = camera {
+            if let val = cam.value(forKey: "batteryLevel") as? Int { return val }
+            if let batt = cam.value(forKey: "battery") as? NSObject,
+               let lv = batt.value(forKey: "level") as? Int { return lv }
+        }
+#endif
+        return -1
+    }
+
+    @objc public func isBatteryCharging() -> Bool {
+#if FLIR_ENABLED
+        if let cam = camera {
+            if let ch = cam.value(forKey: "isCharging") as? Bool { return ch }
+            if let batt = cam.value(forKey: "battery") as? NSObject,
+               let ch = batt.value(forKey: "charging") as? Bool { return ch }
+        }
+#endif
+        return false
+    }
+
+    @objc public func latestFrameImage() -> UIImage? {
+        return latestImage
+    }
+
+    @objc public func latestFrameBase64() -> String? {
+        guard let img = latestImage else { return nil }
+        if let data = img.jpegData(compressionQuality: 0.7) {
+            return data.base64EncodedString()
+        }
+        if let data = img.pngData() {
+            return data.base64EncodedString()
+        }
+        return nil
+    }
+
+    // Client lifecycle helpers: callers (UI/filters) can retain/release to ensure
+    // discovery runs while any client is active.
+    @objc public func retainClient(_ clientId: String) {
+        DispatchQueue.main.async {
+            self.activeClients.insert(clientId)
+            self.shutdownWorkItem?.cancel()
+            self.shutdownWorkItem = nil
+            if self.activeClients.count == 1 {
+                self.startDiscovery()
+            }
+        }
+    }
+
+    @objc public func releaseClient(_ clientId: String) {
+        DispatchQueue.main.async {
+            self.activeClients.remove(clientId)
+            self.shutdownWorkItem?.cancel()
+            let work = DispatchWorkItem { [weak self] in
+                guard let self = self else { return }
+                if self.activeClients.isEmpty {
+                    self.stopDiscovery()
+                }
+            }
+            self.shutdownWorkItem = work
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5, execute: work)
+        }
+    }
+
+    // MARK: - Palette Control
+
+    /// Set palette by name (case-insensitive). If the SDK isn't available or the
+    /// palette cannot be found, this is a no-op.
+    @objc public func setPalette(_ paletteName: String) {
+#if FLIR_ENABLED
+        guard let streamer = streamer, let thermalImage = streamer.getImage() else {
+            NSLog("[FlirManager] Cannot set palette - no active streamer")
+            return
+        }
+
+        if let paletteManager = FLIRPaletteManager.defaultPalettes() {
+            for palette in paletteManager {
+                if let p = palette as? FLIRPalette, p.name.lowercased() == paletteName.lowercased() {
+                    thermalImage.palette = p
+                    NSLog("[FlirManager] ✅ Palette set to: \(paletteName)")
+                    return
+                }
+            }
+            NSLog("[FlirManager] Palette not found: \(paletteName)")
+        } else {
+            NSLog("[FlirManager] SDK not available - cannot set palette")
+        }
+#else
+        NSLog("[FlirManager] SDK not available - cannot set palette")
+#endif
+    }
+
+    /// Map a normalized acol value (0..1) to a palette name.
+    @objc public static func getPaletteNameFromAcol(_ acol: Float) -> String {
+        if acol < 0.125 { return "WhiteHot" }
+        else if acol < 0.25 { return "BlackHot" }
+        else if acol < 0.375 { return "Iron" }
+        else if acol < 0.5 { return "Rainbow" }
+        else if acol < 0.625 { return "Lava" }
+        else if acol < 0.75 { return "Arctic" }
+        else if acol < 0.875 { return "Coldest" }
+        else { return "Hottest" }
+    }
+
+    @objc public func setPaletteFromAcol(_ acol: Float) {
+        let paletteName = FlirManager.getPaletteNameFromAcol(acol)
+        NSLog("[FlirManager] Setting palette from acol=\(acol) -> \(paletteName)")
+        setPalette(paletteName)
+    }
     
     // MARK: - SDK Availability
     

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

@@ -11,6 +11,7 @@
 #import "FlirState.h"
 #import <React/RCTLog.h>
 #import <React/RCTBridge.h>
+#import <objc/message.h>
 
 #if __has_include(<ThermalSDK/ThermalSDK.h>)
 #define FLIR_SDK_AVAILABLE 1
@@ -19,8 +20,62 @@
 #define FLIR_SDK_AVAILABLE 0
 #endif
 
-// Forward declare Swift class
-@class FlirManager;
+// Use runtime lookup to avoid a hard link-time dependency on `FLIRManager`.
+// This prevents duplicate-definition and missing-symbol build failures when
+// the Swift `FLIRManager` may or may not be available at build/link time.
+static id flir_manager_shared(void) {
+    Class cls = NSClassFromString(@"FLIRManager");
+    if (!cls) return nil;
+    SEL sel = sel_registerName("shared");
+    if (![cls respondsToSelector:sel]) return nil;
+    id (*msgSend0)(id, SEL) = (id (*)(id, SEL))objc_msgSend;
+    return msgSend0((id)cls, sel);
+}
+
+static double flir_getTemperatureAtPoint(int x, int y) {
+    id inst = flir_manager_shared();
+    if (!inst) return NAN;
+    SEL sel = sel_registerName("getTemperatureAtPoint:y:");
+    if (![inst respondsToSelector:sel]) return NAN;
+    double (*msgSend2)(id, SEL, int, int) = (double (*)(id, SEL, int, int))objc_msgSend;
+    return msgSend2(inst, sel, x, y);
+}
+
+static int flir_getBatteryLevel(void) {
+    id inst = flir_manager_shared();
+    if (!inst) return -1;
+    SEL sel = sel_registerName("getBatteryLevel");
+    if (![inst respondsToSelector:sel]) return -1;
+    int (*msgSend0)(id, SEL) = (int (*)(id, SEL))objc_msgSend;
+    return msgSend0(inst, sel);
+}
+
+static BOOL flir_isBatteryCharging(void) {
+    id inst = flir_manager_shared();
+    if (!inst) return NO;
+    SEL sel = sel_registerName("isBatteryCharging");
+    if (![inst respondsToSelector:sel]) return NO;
+    BOOL (*msgSend0)(id, SEL) = (BOOL (*)(id, SEL))objc_msgSend;
+    return msgSend0(inst, sel);
+}
+
+static void flir_setPreferSdkRotation(BOOL prefer) {
+    id inst = flir_manager_shared();
+    if (!inst) return;
+    SEL sel = sel_registerName("setPreferSdkRotation:");
+    if (![inst respondsToSelector:sel]) return;
+    void (*msgSend1)(id, SEL, BOOL) = (void (*)(id, SEL, BOOL))objc_msgSend;
+    msgSend1(inst, sel, prefer);
+}
+
+static BOOL flir_isPreferSdkRotation(void) {
+    id inst = flir_manager_shared();
+    if (!inst) return NO;
+    SEL sel = sel_registerName("isPreferSdkRotation");
+    if (![inst respondsToSelector:sel]) return NO;
+    BOOL (*msgSend0)(id, SEL) = (BOOL (*)(id, SEL))objc_msgSend;
+    return msgSend0(inst, sel);
+}
 
 @interface FlirModule() 
 #if FLIR_SDK_AVAILABLE
@@ -77,6 +132,7 @@ RCT_EXPORT_MODULE(FlirModule);
         @"FlirFrameReceived",
         @"FlirError",
         @"FlirStateChanged"
+        , @"FlirBatteryUpdated"
     ];
 }
 
@@ -88,6 +144,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 +399,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 (runtime lookup)
+        double temp = flir_getTemperatureAtPoint([x intValue], [y intValue]);
         if (isnan(temp)) {
             resolve([NSNull null]);
         } else {
@@ -501,6 +564,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 = flir_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 = flir_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 {
+            flir_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 = flir_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.8",
   "description": "FLIR Thermal SDK for React Native - iOS & Android (bundled at compile time via postinstall)",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -15,7 +15,6 @@
     "android/Flir/build.gradle.kts",
     "ios/Flir/src/",
     "ios/Flir/SDKLoader/",
-    
     "app.plugin.js",
     "Flir.podspec",
     "sdk-manifest.json",