ilabs-flir 1.0.1 → 1.0.3

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

@@ -0,0 +1,890 @@
+package flir.android;
+
+import android.graphics.Bitmap;
+import android.util.Log;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.List;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import dalvik.system.DexClassLoader;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Thin helper that wraps FLIR Atlas SDK emulator and streamer features.
+ * All SDK-specific reflection plumbing lives here so FlirManager stays small.
+ */
+class FlirSdkManager {
+    private static final String TAG = "FlirSdkManager";
+
+    interface Listener {
+        void onFrame(Bitmap bitmap);
+
+        void onTemperature(double temp, int x, int y);
+
+        void onDeviceFound(String name);
+
+        void onEmulatorEnabled();
+
+        void onStreamKindChanged(String kind);
+    }
+
+    private Listener listener;
+
+    // SDK objects
+    private Object discoveryFactory;
+    private Object cameraObj;
+    private Object streamerObj;
+    private ClassLoader sdkClassLoader = null;
+    private String sdkCurrentStreamKind = null;
+
+    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+    private volatile Bitmap latestFrame = null;
+
+    FlirSdkManager(Listener listener) {
+        this.listener = listener;
+    }
+
+    boolean startSdkEmulator() {
+        try {
+            Class<?> commIfaceClass = findSdkClass("com.flir.thermalsdk.live.CommunicationInterface");
+            Object emulatorInterface = Enum.valueOf((Class<Enum>) commIfaceClass, "EMULATOR");
+            Log.d(TAG, "[FLIR SDK] Found EMULATOR interface: " + emulatorInterface);
+
+            Class<?> discoveryFactoryClass = findSdkClass("com.flir.thermalsdk.live.discovery.DiscoveryFactory");
+            Method getInstance = discoveryFactoryClass.getMethod("getInstance");
+            discoveryFactory = getInstance.invoke(null);
+
+            Class<?> listenerClass = findSdkClass("com.flir.thermalsdk.live.discovery.DiscoveryEventListener");
+            Object discoveryListener = Proxy.newProxyInstance(
+                    listenerClass.getClassLoader(),
+                    new Class<?>[] { listenerClass },
+                    (proxy, method, args) -> {
+                        String methodName = method.getName();
+                        switch (methodName) {
+                            case "onCameraFound":
+                                Object discovered = args[0];
+                                Log.i(TAG, "[FLIR SDK] Camera found: " + discovered);
+                                connectToSdkCamera(discovered);
+                                return null;
+
+                            case "onCameraLost":
+                                Log.i(TAG, "[FLIR SDK] Camera lost");
+                                cameraObj = null;
+                                streamerObj = null;
+                                return null;
+                            default:
+                                return null;
+                        }
+                    });
+
+            // Get NETWORK interface for FLIR ONE Edge
+            Object networkInterface = Enum.valueOf((Class<Enum>) commIfaceClass, "NETWORK");
+
+            Method scanMethod = discoveryFactoryClass.getMethod("scan", listenerClass,
+                    java.lang.reflect.Array.newInstance(commIfaceClass, 0).getClass());
+            // Scan for BOTH NETWORK (FLIR ONE Edge) and EMULATOR
+            Object ifaceArray = java.lang.reflect.Array.newInstance(commIfaceClass, 2);
+            java.lang.reflect.Array.set(ifaceArray, 0, networkInterface);
+            java.lang.reflect.Array.set(ifaceArray, 1, emulatorInterface);
+            scanMethod.invoke(discoveryFactory, discoveryListener, ifaceArray);
+            Log.i(TAG, "[FLIR SDK] Started discovery scan for NETWORK and EMULATOR");
+            return true;
+        } catch (ClassNotFoundException cnf) {
+            Log.w(TAG, "[FLIR SDK] Classes not found: " + cnf.getMessage());
+            // Try to load classes from an AAR (on-device) via DexClassLoader
+            try {
+                if (attemptLoadSdkFromAar()) {
+                    // If class is now available via sdkClassLoader retry using that loader
+                    Log.i(TAG,
+                            "[FLIR SDK] SDK classes found via DexClassLoader, retrying discovery using sdkClassLoader");
+                    try {
+                        return startSdkEmulatorWithClassLoader(sdkClassLoader);
+                    } catch (Throwable t) {
+                        Log.w(TAG, "[FLIR SDK] retry using sdkClassLoader failed: " + t.getMessage());
+                    }
+                }
+            } catch (Throwable t) {
+                Log.w(TAG, "[FLIR SDK] DexClassLoader attempt failed: " + t.getMessage());
+            }
+            return false;
+        } catch (Throwable t) {
+            Log.w(TAG, "[FLIR SDK] startSdkEmulator failed: " + t.getMessage(), t);
+            return false;
+        }
+    }
+
+    private String sdkJarPath = null;
+
+    private boolean attemptLoadSdkFromAar() {
+        // TODO: This is legacy code - context should be passed as parameter
+        android.content.Context ctx = null; // ilabs.libs.io.data.Var.getAppContext();
+        try {
+            // android.content.Context ctx = ilabs.libs.io.data.Var.getAppContext();
+            if (ctx == null) {
+                Log.w(TAG, "[FLIR SDK] No application context available for SDK load");
+                return false;
+            }
+            File filesDir = ctx.getFilesDir();
+            // Candidate search locations (ordered by preference)
+            java.util.List<File> candList = new java.util.ArrayList<>();
+            // Add internal app filesDir candidates
+            try {
+                candList.add(new File(filesDir, "flir-sdk/thermalsdk-release.aar"));
+            } catch (Throwable ignored) {
+            }
+            try {
+                candList.add(new File(filesDir, "thermalsdk-release.aar"));
+            } catch (Throwable ignored) {
+            }
+            try {
+                candList.add(new File(filesDir, "thermalsdk.aar"));
+            } catch (Throwable ignored) {
+            }
+            // Add external files dir candidates if available
+            try {
+                if (ctx.getExternalFilesDir(null) != null) {
+                    candList.add(new File(ctx.getExternalFilesDir(null), "thermalsdk-release.aar"));
+                    candList.add(new File(ctx.getExternalFilesDir(null), "thermalsdk.aar"));
+                }
+            } catch (Throwable ignored) {
+            }
+            // Add common sdcard and tmp locations
+            try {
+                candList.add(new File("/sdcard/Download/thermalsdk-release.aar"));
+            } catch (Throwable ignored) {
+            }
+            try {
+                candList.add(new File("/sdcard/thermalsdk-release.aar"));
+            } catch (Throwable ignored) {
+            }
+            try {
+                candList.add(new File("/sdcard/thermalsdk.aar"));
+            } catch (Throwable ignored) {
+            }
+            try {
+                candList.add(new File("/data/local/tmp/thermalsdk-release.aar"));
+            } catch (Throwable ignored) {
+            }
+            try {
+                candList.add(new File("/data/local/tmp/thermalsdk.aar"));
+            } catch (Throwable ignored) {
+            }
+            File candidate = null;
+            StringBuilder tried = new StringBuilder();
+            Log.i(TAG,
+                    "[FLIR SDK] FilesDir=" + filesDir.getAbsolutePath() + ", ExternalFilesDir="
+                            + (ctx.getExternalFilesDir(null) != null ? ctx.getExternalFilesDir(null).getAbsolutePath()
+                                    : "null"));
+            for (File cand : candList) {
+                try {
+                    if (cand == null) {
+                        tried.append("null,");
+                        continue;
+                    }
+                    boolean exists = false;
+                    try {
+                        exists = cand.exists();
+                    } catch (Throwable ignored) {
+                    }
+                    tried.append(cand.getAbsolutePath()).append(exists ? "(exists)," : "(no),");
+                    if (exists) {
+                        candidate = cand;
+                        break;
+                    }
+                } catch (Throwable ignored) {
+                    tried.append("err,");
+                }
+            }
+            if (candidate == null || !candidate.exists()) {
+                Log.w(TAG, "[FLIR SDK] No SDK AAR found. Tried: " + tried.toString());
+                return false;
+            }
+            Log.i(TAG, "[FLIR SDK] Found SDK AAR: " + candidate.getAbsolutePath());
+            Log.i(TAG, "[FLIR SDK] Candidate list tried: " + tried.toString());
+            ZipFile zf = new ZipFile(candidate);
+            ZipEntry classesEntry = zf.getEntry("classes.jar");
+            if (classesEntry == null) {
+                Log.w(TAG, "[FLIR SDK] classes.jar not found in AAR");
+                zf.close();
+                return false;
+            }
+            File outJar = new File(filesDir, "flir-classes.jar");
+            FileOutputStream fos = new FileOutputStream(outJar);
+            java.io.InputStream is = zf.getInputStream(classesEntry);
+            byte[] buf = new byte[8192];
+            int r;
+            while ((r = is.read(buf)) != -1)
+                fos.write(buf, 0, r);
+            is.close();
+            fos.close();
+            zf.close();
+            File dexOutDir = ctx.getDir("dex", android.content.Context.MODE_PRIVATE);
+            DexClassLoader dcl = new DexClassLoader(outJar.getAbsolutePath(), dexOutDir.getAbsolutePath(), null,
+                    ctx.getClassLoader());
+            // verify class present
+            Class<?> test = Class.forName("com.flir.thermalsdk.live.CommunicationInterface", true, dcl);
+            if (test != null) {
+                sdkClassLoader = dcl;
+                Log.i(TAG, "[FLIR SDK] DexClassLoader created and class loaded from: " + outJar.getAbsolutePath());
+                try {
+                    Log.i(TAG, "[FLIR SDK] DexClassLoader parent loader=" + dcl.getParent() + " (loader=" + dcl + ")");
+                } catch (Throwable ignored) {
+                }
+                sdkJarPath = outJar.getAbsolutePath();
+                return true;
+            }
+        } catch (Throwable t) {
+            Log.w(TAG, "[FLIR SDK] attemptLoadSdkFromAar failed: " + t.getMessage(), t);
+            try {
+                Log.i(TAG, "[FLIR SDK] Candidate list tried on failure: ");
+            } catch (Throwable ignored) {
+            }
+        }
+        return false;
+    }
+
+    public boolean isSdkLoaded() {
+        return sdkClassLoader != null;
+    }
+
+    public String getLoadedSdkJarPath() {
+        return sdkJarPath;
+    }
+
+    private Class<?> findSdkClass(String name) throws ClassNotFoundException {
+        try {
+            return Class.forName(name);
+        } catch (ClassNotFoundException e) {
+            if (sdkClassLoader != null)
+                return Class.forName(name, true, sdkClassLoader);
+            throw e;
+        }
+    }
+
+    private boolean startSdkEmulatorWithClassLoader(ClassLoader loader) {
+        try {
+            Class<?> commIfaceClass = Class.forName("com.flir.thermalsdk.live.CommunicationInterface", true, loader);
+            Object emulatorInterface = Enum.valueOf((Class<Enum>) commIfaceClass, "EMULATOR");
+            Log.d(TAG, "[FLIR SDK] (DEX) CommunicationInterface found via loader: " + loader);
+            Log.d(TAG, "[FLIR SDK] Found EMULATOR interface (DEX): " + emulatorInterface);
+
+            Class<?> discoveryFactoryClass = Class.forName("com.flir.thermalsdk.live.discovery.DiscoveryFactory", true,
+                    loader);
+            Method getInstance = discoveryFactoryClass.getMethod("getInstance");
+            discoveryFactory = getInstance.invoke(null);
+            Log.d(TAG, "[FLIR SDK] (DEX) DiscoveryFactory.getInstance() returned: " + (discoveryFactory != null));
+
+            Class<?> listenerClass = Class.forName("com.flir.thermalsdk.live.discovery.DiscoveryEventListener", true,
+                    loader);
+            Object discoveryListener = Proxy.newProxyInstance(
+                    loader,
+                    new Class<?>[] { listenerClass },
+                    (proxy, method, args) -> {
+                        String methodName = method.getName();
+                        switch (methodName) {
+                            case "onCameraFound":
+                                Object discovered = args[0];
+                                Log.i(TAG, "[FLIR SDK] (DEX) Camera found: " + discovered);
+                                connectToSdkCamera(discovered);
+                                return null;
+                            case "onCameraLost":
+                                Log.i(TAG, "[FLIR SDK] (DEX) Camera lost");
+                                cameraObj = null;
+                                streamerObj = null;
+                                return null;
+                            default:
+                                return null;
+                        }
+                    });
+
+            // Get NETWORK interface for FLIR ONE Edge
+            Object networkInterface = Enum.valueOf((Class<Enum>) commIfaceClass, "NETWORK");
+
+            Method scanMethod = discoveryFactoryClass.getMethod("scan", listenerClass,
+                    java.lang.reflect.Array.newInstance(commIfaceClass, 0).getClass());
+            // Scan for BOTH NETWORK (FLIR ONE Edge) and EMULATOR
+            Object ifaceArray = java.lang.reflect.Array.newInstance(commIfaceClass, 2);
+            java.lang.reflect.Array.set(ifaceArray, 0, networkInterface);
+            java.lang.reflect.Array.set(ifaceArray, 1, emulatorInterface);
+            scanMethod.invoke(discoveryFactory, discoveryListener, ifaceArray);
+            Log.i(TAG, "[FLIR SDK] (DEX) scan invoked on DiscoveryFactory");
+            Log.i(TAG, "[FLIR SDK] (DEX) Started discovery scan for NETWORK and EMULATOR");
+            return true;
+        } catch (Throwable t) {
+            Log.w(TAG, "[FLIR SDK] startSdkEmulatorWithClassLoader failed: " + t.getMessage());
+            return false;
+        }
+    }
+
+    private void connectToSdkCamera(Object discoveredCamera) {
+        try {
+            Method getIdentity = discoveredCamera.getClass().getMethod("getIdentity");
+            Object identity = getIdentity.invoke(discoveredCamera);
+
+            Class<?> cameraClass = findSdkClass("com.flir.thermalsdk.live.Camera");
+            cameraObj = cameraClass.newInstance();
+
+            Class<?> connStatusClass = findSdkClass("com.flir.thermalsdk.live.connectivity.ConnectionStatusListener");
+            Object connListener = Proxy.newProxyInstance(connStatusClass.getClassLoader(),
+                    new Class<?>[] { connStatusClass }, (proxy, method, args) -> {
+                        if (method.getName().equals("onDisconnected")) {
+                            Log.w(TAG, "[FLIR SDK] Camera disconnected");
+                            cameraObj = null;
+                            streamerObj = null;
+                        }
+                        return null;
+                    });
+
+            // Try various connect overloads to be compatible across SDK versions
+            boolean connected = false;
+            try {
+                Class<?> connectParamsClass = findSdkClass("com.flir.thermalsdk.live.ConnectParameters");
+                Object connectParams = null;
+                try {
+                    connectParams = connectParamsClass.newInstance();
+                } catch (Throwable ignored) {
+                }
+                Method connectMethod3 = cameraClass.getMethod("connect", identity.getClass(), connStatusClass,
+                        connectParamsClass);
+                connectMethod3.invoke(cameraObj, identity, connListener, connectParams);
+                connected = true;
+            } catch (Throwable ignored) {
+                try {
+                    Method connectMethod2 = cameraClass.getMethod("connect", identity.getClass(), connStatusClass);
+                    connectMethod2.invoke(cameraObj, identity, connListener);
+                    connected = true;
+                } catch (Throwable ignored2) {
+                    try {
+                        Method connectSimple = cameraClass.getMethod("connect", identity.getClass());
+                        connectSimple.invoke(cameraObj, identity);
+                        connected = true;
+                    } catch (Throwable ignored3) {
+                        Log.w(TAG, "connect: All connect attempts failed: " + ignored3.getMessage());
+                    }
+                }
+            }
+
+            String deviceName = "EMULATOR";
+            try {
+                Method getName = identity.getClass().getMethod("getName");
+                Object nm = getName.invoke(identity);
+                if (nm != null)
+                    deviceName = nm.toString();
+            } catch (Throwable ignored) {
+            }
+
+            if (listener != null) {
+                listener.onDeviceFound(deviceName);
+                listener.onEmulatorEnabled();
+            }
+            Log.d(TAG, "[FLIR SDK] Scheduling startSdkStreaming; cameraObj=" + cameraObj + ", identity=" + identity
+                    + ", connected=" + connected);
+            scheduler.schedule(this::startSdkStreaming, 500, TimeUnit.MILLISECONDS);
+        } catch (Throwable t) {
+            Log.w(TAG, "connectToSdkCamera failed: " + t.getMessage(), t);
+        }
+    }
+
+    private void startSdkStreaming() {
+        try {
+            Log.d(TAG, "[FLIR SDK] startSdkStreaming invoked; cameraObj=" + cameraObj + ", streamerObj=" + streamerObj);
+            if (cameraObj == null)
+                return;
+            Method getStreams = cameraObj.getClass().getMethod("getStreams");
+            Object streams = getStreams.invoke(cameraObj);
+            if (streams == null)
+                Log.i(TAG, "[FLIR SDK] No streams returned from camera.getStreams()");
+            Object chosenStream = null;
+            int streamCount = 0;
+            if (streams instanceof List) {
+                List<?> streamList = (List<?>) streams;
+                streamCount = streamList.size();
+                Log.i(TAG, "[FLIR SDK] getStreams returned list with size=" + streamList.size());
+                for (Object s : streamList) {
+                    if (s == null)
+                        continue;
+                    try {
+                        Method getName = null;
+                        try {
+                            getName = s.getClass().getMethod("getName");
+                        } catch (Throwable ignored) {
+                        }
+                        String name = null;
+                        if (getName != null)
+                            name = getName.invoke(s).toString().toLowerCase();
+
+                        Method getType = null;
+                        try {
+                            getType = s.getClass().getMethod("getStreamType");
+                        } catch (Throwable ignored) {
+                        }
+                        if (getType == null)
+                            try {
+                                getType = s.getClass().getMethod("getType");
+                            } catch (Throwable ignored) {
+                            }
+                        String type = null;
+                        if (getType != null)
+                            type = getType.invoke(s).toString().toLowerCase();
+
+                        String test = (name != null ? name : "") + "|" + (type != null ? type : "");
+                        Log.d(TAG, "[FLIR SDK] stream candidate: name='" + name + "', type='" + type + "', test='"
+                                + test + "'");
+                        if (test.contains("fusion") || test.contains("palette") || test.contains("visual")
+                                || test.contains("msx")) {
+                            chosenStream = s;
+                            break;
+                        }
+                    } catch (Throwable ignored) {
+                    }
+                }
+                if (chosenStream == null && !streamList.isEmpty())
+                    chosenStream = streamList.get(0);
+            }
+            if (chosenStream == null)
+                Log.w(TAG, "[FLIR SDK] No chosen stream found; streamCount=" + streamCount);
+            if (chosenStream == null)
+                return;
+
+            Class<?> thermalStreamerClass = findSdkClass("com.flir.thermalsdk.live.streaming.ThermalStreamer");
+            java.lang.reflect.Constructor<?> ctor = thermalStreamerClass
+                    .getConstructor(findSdkClass("com.flir.thermalsdk.live.streaming.Stream"));
+            streamerObj = ctor.newInstance(chosenStream);
+            Log.i(TAG, "[FLIR SDK] ThermalStreamer instance created: "
+                    + (streamerObj != null ? streamerObj.getClass().getName() : "null"));
+
+            boolean listenerAttached = attachStreamerListener(streamerObj);
+            if (!listenerAttached)
+                startFramePolling();
+            Log.i(TAG, "[FLIR SDK] startSdkStreaming: listenerAttached=" + listenerAttached + ", streamerObj="
+                    + (streamerObj != null));
+
+            // Notify stream kind change
+            try {
+                Method getName = chosenStream.getClass().getMethod("getName");
+                Object nm = getName.invoke(chosenStream);
+                if (nm != null && listener != null)
+                    listener.onStreamKindChanged(nm.toString());
+                try {
+                    sdkCurrentStreamKind = nm != null ? nm.toString() : null;
+                } catch (Throwable ignored) {
+                }
+            } catch (Throwable ignored) {
+            }
+
+        } catch (Throwable t) {
+            Log.w(TAG, "startSdkStreaming failed: " + t.getMessage(), t);
+        }
+    }
+
+    public boolean forceStartStreaming() {
+        try {
+            if (cameraObj == null) {
+                Log.i(TAG, "[FLIR SDK] forceStartStreaming: No cameraObj, attempting discovery scan");
+                try {
+                    // Re-run discovery to find cameras
+                    Class<?> commIfaceClass = findSdkClass("com.flir.thermalsdk.live.CommunicationInterface");
+                    Object emulatorInterface = Enum.valueOf((Class<Enum>) commIfaceClass, "EMULATOR");
+                    Class<?> discoveryFactoryClass = findSdkClass(
+                            "com.flir.thermalsdk.live.discovery.DiscoveryFactory");
+                    Method getInstance = discoveryFactoryClass.getMethod("getInstance");
+                    Object df = getInstance.invoke(null);
+                    Class<?> listenerClass = findSdkClass("com.flir.thermalsdk.live.discovery.DiscoveryEventListener");
+                    Object discoveryListener = Proxy.newProxyInstance(
+                            sdkClassLoader != null ? sdkClassLoader : discoveryFactoryClass.getClassLoader(),
+                            new Class<?>[] { listenerClass },
+                            (proxy, method, args) -> {
+                                String methodName = method.getName();
+                                if ("onCameraFound".equalsIgnoreCase(methodName) && args != null && args.length > 0) {
+                                    try {
+                                        Object discovered = args[0];
+                                        Log.i(TAG, "[FLIR SDK] forceStartStreaming: discovered camera: " + discovered);
+                                        connectToSdkCamera(discovered);
+                                    } catch (Throwable t) {
+                                        Log.w(TAG, "[FLIR SDK] forceStartStreaming onCameraFound handler error: "
+                                                + t.getMessage());
+                                    }
+                                }
+                                return null;
+                            });
+                    Method scanMethod = discoveryFactoryClass.getMethod("scan", listenerClass,
+                            java.lang.reflect.Array.newInstance(commIfaceClass, 0).getClass());
+                    Object ifaceArray = java.lang.reflect.Array.newInstance(commIfaceClass, 1);
+                    java.lang.reflect.Array.set(ifaceArray, 0, emulatorInterface);
+                    scanMethod.invoke(df, discoveryListener, ifaceArray);
+                } catch (Throwable t) {
+                    Log.w(TAG, "[FLIR SDK] forceStartStreaming discovery scan failed: " + t.getMessage());
+                }
+                // if cameraObj still null - return false
+                if (cameraObj == null)
+                    return false;
+            }
+            // If cameraObj present, start streaming
+            scheduler.submit(() -> startSdkStreaming());
+            Log.i(TAG, "[FLIR SDK] forceStartStreaming scheduled startSdkStreaming");
+            return true;
+        } catch (Throwable t) {
+            Log.w(TAG, "[FLIR SDK] forceStartStreaming failed: " + t.getMessage(), t);
+            return false;
+        }
+    }
+
+    private void startFramePolling() {
+        scheduler.scheduleAtFixedRate(() -> {
+            try {
+                if (streamerObj == null)
+                    return;
+                Log.d(TAG, "[FLIR SDK] startFramePolling - streamerObj class=" + streamerObj.getClass().getName());
+                Method updateMethod = streamerObj.getClass().getMethod("update");
+                updateMethod.invoke(streamerObj);
+
+                Method getImage = streamerObj.getClass().getMethod("getImage");
+                Object thermalImage = getImage.invoke(streamerObj);
+                if (thermalImage != null) {
+                    try {
+                        // Prefer: direct getBitmap() if available
+                        try {
+                            Method getBitmap = thermalImage.getClass().getMethod("getBitmap");
+                            Object bmp = getBitmap.invoke(thermalImage);
+                            if (bmp instanceof Bitmap) {
+                                latestFrame = (Bitmap) bmp;
+                                if (listener != null) {
+                                    listener.onFrame((Bitmap) bmp);
+                                    Log.d(TAG, "[FLIR SDK] Frame emitted from polling: " + ((Bitmap) bmp).getWidth()
+                                            + "x" + ((Bitmap) bmp).getHeight());
+                                }
+                                return;
+                            }
+                        } catch (Throwable ignored) {
+                        }
+
+                        // Fallback: try using
+                        // BitmapAndroid.createBitmap(thermalImage.getImage()).getBitMap()
+                        try {
+                            Object imageBase = null;
+                            try {
+                                Method getImageFromThermal = thermalImage.getClass().getMethod("getImage");
+                                imageBase = getImageFromThermal.invoke(thermalImage);
+                            } catch (Throwable ignored) {
+                            }
+                            if (imageBase == null)
+                                imageBase = thermalImage;
+                            Class<?> bitmapAndroidClass = findSdkClass(
+                                    "com.flir.thermalsdk.androidsdk.image.BitmapAndroid");
+                            Method createBitmap = bitmapAndroidClass.getMethod("createBitmap", imageBase.getClass());
+                            Object wrapper = createBitmap.invoke(null, imageBase);
+                            if (wrapper != null) {
+                                Method getBitMapMethod = wrapper.getClass().getMethod("getBitMap");
+                                Object bmp = getBitMapMethod.invoke(wrapper);
+                                if (bmp instanceof Bitmap) {
+                                    latestFrame = (Bitmap) bmp;
+                                    if (listener != null)
+                                        listener.onFrame((Bitmap) bmp);
+                                }
+                            }
+                        } catch (Throwable ignored) {
+                        }
+                    } catch (Throwable ignored) {
+                    }
+                }
+            } catch (Throwable t) {
+                if (System.currentTimeMillis() % 5000 < 200)
+                    Log.d(TAG, "Frame poll error: " + t.getMessage());
+            }
+        }, 100, 100, TimeUnit.MILLISECONDS);
+    }
+
+    Bitmap getLatestFrame() {
+        return latestFrame;
+    }
+
+    double getTemperatureAtPoint(int x, int y) {
+        // Try to query using SDK streamer if available
+        try {
+            if (streamerObj != null) {
+                Method getImage = streamerObj.getClass().getMethod("getImage");
+                Object thermalImage = getImage.invoke(streamerObj);
+                if (thermalImage != null) {
+                    try {
+                        Method getValueAt = thermalImage.getClass().getMethod("getValueAt",
+                                android.graphics.Point.class);
+                        android.graphics.Point p = new android.graphics.Point(x, y);
+                        Object temp = getValueAt.invoke(thermalImage, p);
+                        if (temp instanceof Double)
+                            return (Double) temp;
+                        if (temp instanceof Float)
+                            return ((Float) temp).doubleValue();
+                    } catch (NoSuchMethodException nsme) {
+                    }
+                    try {
+                        Method getValues = thermalImage.getClass().getMethod("getValues");
+                        Object values = getValues.invoke(thermalImage);
+                        if (values != null) {
+                            Method valGetAt = values.getClass().getMethod("getValueAt", int.class, int.class);
+                            Object temp = valGetAt.invoke(values, x, y);
+                            if (temp instanceof Double)
+                                return (Double) temp;
+                        }
+                    } catch (Throwable ignored) {
+                    }
+                }
+            }
+        } catch (Throwable t) {
+        }
+        return Double.NaN;
+    }
+
+    boolean setPalette(String paletteName) {
+        try {
+            if (streamerObj == null && cameraObj == null)
+                return false;
+            Object thermalImage = null;
+            if (streamerObj != null) {
+                Method getImage = streamerObj.getClass().getMethod("getImage");
+                thermalImage = getImage.invoke(streamerObj);
+            }
+            if (thermalImage != null) {
+                Class<?> paletteManagerClass = null;
+                try {
+                    paletteManagerClass = findSdkClass("com.flir.thermalsdk.image.palettes.PaletteManager");
+                } catch (Throwable ignored) {
+                    try {
+                        paletteManagerClass = findSdkClass("com.flir.thermalsdk.image.PaletteManager");
+                    } catch (Throwable ignored2) {
+                    }
+                }
+                if (paletteManagerClass == null)
+                    return false;
+                Method getDefaultPalettes = paletteManagerClass.getMethod("getDefaultPalettes");
+                Object palettesResult = getDefaultPalettes.invoke(null);
+                Object target = null;
+                // Handle array or List return types
+                if (palettesResult instanceof Object[]) {
+                    for (Object p : (Object[]) palettesResult) {
+                        try {
+                            Method getName = p.getClass().getMethod("getName");
+                            String n = (String) getName.invoke(p);
+                            if (n != null && n.equalsIgnoreCase(paletteName)) {
+                                target = p;
+                                break;
+                            }
+                        } catch (Throwable ignored) {
+                        }
+                    }
+                } else if (palettesResult instanceof java.util.List) {
+                    for (Object p : (java.util.List) palettesResult) {
+                        try {
+                            Method getName = p.getClass().getMethod("getName");
+                            String n = (String) getName.invoke(p);
+                            if (n != null && n.equalsIgnoreCase(paletteName)) {
+                                target = p;
+                                break;
+                            }
+                        } catch (Throwable ignored) {
+                        }
+                    }
+                } else if (palettesResult != null && palettesResult.getClass().isArray()) {
+                    int len = java.lang.reflect.Array.getLength(palettesResult);
+                    for (int i = 0; i < len; i++) {
+                        Object p = java.lang.reflect.Array.get(palettesResult, i);
+                        try {
+                            Method getName = p.getClass().getMethod("getName");
+                            String n = (String) getName.invoke(p);
+                            if (n != null && n.equalsIgnoreCase(paletteName)) {
+                                target = p;
+                                break;
+                            }
+                        } catch (Throwable ignored) {
+                        }
+                    }
+                }
+                if (target != null) {
+                    Class<?> paletteClass = null;
+                    try {
+                        paletteClass = findSdkClass("com.flir.thermalsdk.image.palettes.Palette");
+                    } catch (Throwable ignored) {
+                        try {
+                            paletteClass = findSdkClass("com.flir.thermalsdk.image.Palette");
+                        } catch (Throwable ignored2) {
+                        }
+                    }
+                    if (paletteClass == null)
+                        return false;
+                    Method setPalette = thermalImage.getClass().getMethod("setPalette", paletteClass);
+                    setPalette.invoke(thermalImage, target);
+                    return true;
+                }
+            }
+        } catch (Throwable t) {
+            Log.w(TAG, "setPalette failed: " + t.getMessage());
+        }
+        return false;
+    }
+
+    public boolean isStreamingActive() {
+        return streamerObj != null;
+    }
+
+    public String getSdkCurrentStreamKind() {
+        return sdkCurrentStreamKind;
+    }
+
+    private boolean attachStreamerListener(Object streamer) {
+        if (streamer == null)
+            return false;
+        try {
+            Class<?> streamerClass = streamer.getClass();
+            String[] candidates = new String[] { "setFrameListener", "setListener", "addListener", "addFrameListener",
+                    "addStreamListener", "setOnImageAvailableListener", "addImageListener", "setDataListener",
+                    "subscribe" };
+            for (String name : candidates) {
+                try {
+                    for (Method m : streamerClass.getMethods()) {
+                        if (!m.getName().equalsIgnoreCase(name))
+                            continue;
+                        Class<?>[] params = m.getParameterTypes();
+                        if (params.length != 1 || !params[0].isInterface())
+                            continue;
+                        final Class<?> listenerInterface = params[0];
+                        Object proxy = Proxy.newProxyInstance(listenerInterface.getClassLoader(),
+                                new Class<?>[] { listenerInterface }, (proxyObj, method, args) -> {
+                                    try {
+                                        Log.d(TAG, "[FLIR SDK] Stream listener method invoked: " + method.getName());
+                                        if (args != null && args.length > 0) {
+                                            for (Object arg : args) {
+                                                if (arg == null)
+                                                    continue;
+                                                try {
+                                                    Method getFusion = arg.getClass().getMethod("getFusion");
+                                                    if (getFusion != null) {
+                                                        Object fusion = getFusion.invoke(arg);
+                                                        if (fusion != null) {
+                                                            try {
+                                                                Method getPhoto = fusion.getClass()
+                                                                        .getMethod("getPhoto");
+                                                                Object photo = getPhoto.invoke(fusion);
+                                                                if (photo != null) {
+                                                                    try {
+                                                                        Method pb = photo.getClass()
+                                                                                .getMethod("getBitmap");
+                                                                        Object bmpObj = pb.invoke(photo);
+                                                                        if (bmpObj instanceof Bitmap) {
+                                                                            if (listener != null) {
+                                                                                listener.onFrame((Bitmap) bmpObj);
+                                                                                Log.d(TAG,
+                                                                                        "[FLIR SDK] Streamer listener delivered bitmap via getBitmap");
+                                                                            }
+                                                                            return null;
+                                                                        }
+                                                                    } catch (Throwable ignored) {
+                                                                    }
+                                                                }
+                                                            } catch (Throwable ignored) {
+                                                            }
+                                                        }
+                                                    }
+                                                } catch (Throwable ignored) {
+                                                }
+                                                try {
+                                                    Method getBitmap = arg.getClass().getMethod("getBitmap");
+                                                    Object bmp = getBitmap.invoke(arg);
+                                                    if (bmp instanceof Bitmap) {
+                                                        if (listener != null) {
+                                                            listener.onFrame((Bitmap) bmp);
+                                                            Log.d(TAG,
+                                                                    "[FLIR SDK] Streamer listener delivered bitmap via direct getBitmap");
+                                                        }
+                                                        return null;
+                                                    }
+                                                } catch (Throwable ignored) {
+                                                }
+                                                try {
+                                                    Method getImage = arg.getClass().getMethod("getImage");
+                                                    Object imgObj = getImage.invoke(arg);
+                                                    if (imgObj instanceof Bitmap) {
+                                                        if (listener != null) {
+                                                            listener.onFrame((Bitmap) imgObj);
+                                                            Log.d(TAG,
+                                                                    "[FLIR SDK] Streamer listener delivered bitmap via getImage");
+                                                        }
+                                                        return null;
+                                                    }
+                                                    // fallback to BitmapAndroid.createBitmap(imgObj).getBitMap()
+                                                    try {
+                                                        Class<?> bitmapAndroidClass = findSdkClass(
+                                                                "com.flir.thermalsdk.androidsdk.image.BitmapAndroid");
+                                                        Method createBitmap = bitmapAndroidClass
+                                                                .getMethod("createBitmap", imgObj.getClass());
+                                                        Object wrapper = createBitmap.invoke(null, imgObj);
+                                                        if (wrapper != null) {
+                                                            Method getBitMap = wrapper.getClass()
+                                                                    .getMethod("getBitMap");
+                                                            Object bmpObj = getBitMap.invoke(wrapper);
+                                                            if (bmpObj instanceof Bitmap) {
+                                                                if (listener != null) {
+                                                                    listener.onFrame((Bitmap) bmpObj);
+                                                                    Log.d(TAG,
+                                                                            "[FLIR SDK] Streamer listener delivered bitmap via BitmapAndroid wrapper");
+                                                                }
+                                                                return null;
+                                                            }
+                                                        }
+                                                    } catch (Throwable ignored2) {
+                                                    }
+                                                } catch (Throwable ignored) {
+                                                }
+                                            }
+                                        }
+                                    } catch (Throwable t) {
+                                        Log.w(TAG, "Streamer listener failed: " + t.getMessage());
+                                    }
+                                    return null;
+                                });
+                        try {
+                            m.invoke(streamer, proxy);
+                        } catch (Throwable e) {
+                            Log.w(TAG, "attach proxy failed: " + e.getMessage(), e);
+                            continue;
+                        }
+                        Log.i(TAG, "Attached streamer listener using: " + m.getName());
+                        return true;
+                    }
+                } catch (Throwable ignored) {
+                }
+            }
+        } catch (Throwable t) {
+            Log.w(TAG, "attachStreamerListener error: " + t.getMessage());
+        }
+        return false;
+    }
+
+    public void stop() {
+        try {
+            scheduler.shutdownNow();
+            if (streamerObj != null) {
+                try {
+                    Method stop = streamerObj.getClass().getMethod("stop");
+                    if (stop != null)
+                        stop.invoke(streamerObj);
+                } catch (Throwable ignored) {
+                }
+            }
+            if (cameraObj != null) {
+                try {
+                    Method disconnect = cameraObj.getClass().getMethod("disconnect");
+                    if (disconnect != null)
+                        disconnect.invoke(cameraObj);
+                } catch (Throwable ignored) {
+                }
+            }
+        } catch (Throwable t) {
+            Log.w(TAG, "Failed to stop SDK manager: " + t.getMessage());
+        }
+    }
+}