diff --git a/src/Pages/BookingScreen/Components/UtillComponents/BSNavBarWeightScale.jsx b/src/Pages/BookingScreen/Components/UtillComponents/BSNavBarWeightScale.jsx
index ba06bd4..c8a63b8 100644
--- a/src/Pages/BookingScreen/Components/UtillComponents/BSNavBarWeightScale.jsx
+++ b/src/Pages/BookingScreen/Components/UtillComponents/BSNavBarWeightScale.jsx
@@ -1,4 +1,4 @@
-import { useEffect, useState, useCallback } from 'react';
+import { useCallback, useRef, useState, useEffect } from 'react'; // ← add useEffect
import { useDispatch } from 'react-redux';
import PozoWeightScaleIcon from './Pozo retail icons/PozoWeightScaleIcon';
import {
@@ -9,30 +9,148 @@ import WeightScaleComp from '../../../../Components/WeightScale/weightScale.jsx'
import { Messages } from '../../../../Components/Notifications/Messages';
import TooltipWrapper from '../../../../Components/Tooltip/Tooltip';
import { isMobile } from 'react-device-detect';
-import WeightScaleApp from '../../WeightscaleApp.jsx';
+import { Capacitor } from '@capacitor/core';
+import { weightScaleService } from '../../../../Services/getusbdevices.js';
const BSNavBarWeightScale = ({Combo}) => {
const dispatch = useDispatch();
+
+ // ── FIX: init from service so remount restores correct status ──
+ const [usbStatus, setUsbStatus] = useState(
+ () => weightScaleService.isConnected ? 'connected' : 'disconnected'
+ );
+
const [WeightScale, setWeightScale] = useState(false);
- const [wsport, setwsport] = useState(null);
const [WeightScale2, setWeightScale2] = useState(false);
+ const [wsport, setwsport] = useState(null);
+
const [messageType, setMessageType] = useState(null);
const [messageData, setMessageData] = useState(null);
-console.log(WeightScale,"WeightScale")
+
+ const lastStableWeightRef = useRef(null);
+ const lastWeightRef = useRef(null);
+ const stableCountRef = useRef(0);
+ const STABLE_THRESHOLD = 3;
+
+ const isNativeApp = Capacitor.isNativePlatform();
+
+ // ── FIX: on remount, if already connected re-attach the reading callback ──
useEffect(() => {
- if (WeightScale2 === true) {
- setWeightScale(true);
- } else {
- setWeightScale(false);
+ if (weightScaleService.isConnected) {
+ setUsbStatus('connected');
+ dispatch(changeWeightScalePort(true));
+
+ // Re-register the weight reading callback since component remounted
+ weightScaleService.startReading(
+ (w) => handleWeightReading(w),
+ (err) => {
+ setUsbStatus('disconnected');
+ dispatch(changeWeightScalePort(false));
+ dispatch(changeWeightScaleWeight(null));
+ resetStable();
+ setMessageType('error');
+ setMessageData('Scale error: ' + err.message);
+ }
+ );
}
- }, [WeightScale2]);
- const handleWeightScaleOpen = () => {
-
- setWeightScale2(!WeightScale2);
- dispatch(changeWeightScalePort(!WeightScale2));
-
-
+
+ // ── FIX: on unmount, do NOT disconnect — just clear the reading callback
+ // so old callbacks don't fire on the unmounted component (memory leak)
+ return () => {
+ weightScaleService.detachCallbacks();
+ };
+ }, []); // runs once on mount/remount
+
+ // ── ICON COLOR ────────────────────────────────────
+ const getIconColor = () => {
+ if (isNativeApp || isMobile) {
+ if (usbStatus === 'connected') return 'rgb(82, 196, 26)';
+ if (usbStatus === 'connecting') return '#faad14';
+ return '#ff4d4f';
+ }
+ return WeightScale2 ? 'rgb(82, 196, 26)' : '#ff4d4f';
};
+
+ // ── STABLE WEIGHT DETECTION ───────────────────────
+ const handleWeightReading = (w) => {
+ if (w === lastWeightRef.current) {
+ stableCountRef.current++;
+ } else {
+ stableCountRef.current = 1;
+ }
+ lastWeightRef.current = w;
+
+ const isStable = stableCountRef.current >= STABLE_THRESHOLD;
+ const isValid = typeof w === 'number' && !isNaN(w);
+ const hasChanged = w !== lastStableWeightRef.current;
+
+ if (isValid && isStable && hasChanged) {
+ lastStableWeightRef.current = w;
+ dispatch(changeWeightScaleWeight(w));
+ }
+ };
+
+ const resetStable = () => {
+ lastStableWeightRef.current = null;
+ lastWeightRef.current = null;
+ stableCountRef.current = 0;
+ };
+
+ // ── CONNECT ───────────────────────────────────────
+ const connectScale = async () => {
+ setUsbStatus('connecting');
+ resetStable();
+
+ const success = await weightScaleService.autoConnect();
+
+ if (success) {
+ setUsbStatus('connected');
+ dispatch(changeWeightScalePort(true));
+
+ await weightScaleService.startReading(
+ (w) => handleWeightReading(w),
+ (err) => {
+ setUsbStatus('disconnected');
+ dispatch(changeWeightScalePort(false));
+ dispatch(changeWeightScaleWeight(null));
+ resetStable();
+ setMessageType('error');
+ setMessageData('Scale error: ' + err.message);
+ }
+ );
+ } else {
+ setUsbStatus('disconnected');
+ setMessageType('error');
+ setMessageData(weightScaleService.lastError || 'Cannot connect. Check USB / OTG cable.');
+ }
+ };
+
+ // ── DISCONNECT ────────────────────────────────────
+ const disconnectScale = async () => {
+ await weightScaleService.disconnect();
+ setUsbStatus('disconnected');
+ dispatch(changeWeightScalePort(false));
+ dispatch(changeWeightScaleWeight(null));
+ resetStable();
+ };
+
+ // ── MAIN CLICK HANDLER ────────────────────────────
+ const handleWeightScaleOpen = async () => {
+ if (isNativeApp || isMobile) {
+ if (usbStatus === 'connected') {
+ await disconnectScale();
+ } else if (usbStatus === 'disconnected') {
+ await connectScale();
+ }
+ } else {
+ const next = !WeightScale2;
+ setWeightScale2(next);
+ setWeightScale(next);
+ dispatch(changeWeightScalePort(next));
+ }
+ };
+
+ // ── DESKTOP HANDLERS ──────────────────────────────
const setWsport = async (e) => {
if (e?.readable) {
setwsport(e);
@@ -40,11 +158,11 @@ console.log(WeightScale,"WeightScale")
setMessageType('error');
setMessageData('Please check weightscale connection');
setWeightScale2(false);
+ setWeightScale(false);
}
};
const myfun = async (e) => {
- console.log(e,"weight")
dispatch(changeWeightScaleWeight(e));
};
@@ -52,10 +170,12 @@ console.log(WeightScale,"WeightScale")
setMessageData(null);
setMessageType(null);
}, []);
+
const msgAlert = async (e) => {
setMessageType(e.type);
setMessageData(e.msg);
};
+
return (
- {Combo == "combolayout" ?
+ {Combo == 'combolayout' ? (
- :
-
-
- }
- {/* */}
- {(WeightScale == true && isMobile) && (
-
- )}
+ className="BSC1Search-button1"
+ style={{ backgroundColor: getIconColor() }}
+ onClick={handleWeightScaleOpen}
+ disabled={usbStatus === 'connecting'}
+ >
+ {(isNativeApp || isMobile)
+ ? usbStatus === 'connecting' ? 'Connecting...'
+ : usbStatus === 'connected' ? 'Scale ON'
+ : 'Weight Scale'
+ : 'Weight Scale'}
+
+ ) : (
+
+ )}
- {(WeightScale == true && !isMobile) && (
-
- )}
+ {WeightScale && !isMobile && !isNativeApp && (
+
+ )}
);
};
-export default BSNavBarWeightScale;
+
+export default BSNavBarWeightScale;
\ No newline at end of file
diff --git a/src/Services/Others.js b/src/Services/Others.js
index fd6b5b2..8884fa1 100644
--- a/src/Services/Others.js
+++ b/src/Services/Others.js
@@ -134,7 +134,7 @@ export const TokendecryptedValuesFun = (value) => {
};
// ✅ Cookie helpers (used only in Capacitor)
const setCapCookieData = (key, value, days = 1) => {
- console.log("Setting cookie:", key, value);
+ // console.log("Setting cookie:", key, value);
const expires = new Date();
expires.setDate(expires.getDate() + days);
document.cookie = `${key}=${encodeURIComponent(value)}; expires=${expires.toUTCString()}; path=/`;
diff --git a/src/Services/getusbdevices.js b/src/Services/getusbdevices.js
new file mode 100644
index 0000000..55fcba6
--- /dev/null
+++ b/src/Services/getusbdevices.js
@@ -0,0 +1,315 @@
+import { Capacitor } from '@capacitor/core';
+import { UsbSerial } from 'capacitor-usb-serial';
+
+const WEIGHT_PATTERNS = [
+ /(\d+\.?\d*)\s*(kg|KG)/,
+ /(\d+\.?\d*)\s*(lb|LB)/,
+ /(\d+\.?\d*)\s*(g|G)\b/,
+ /ST,GS\s*(\d+\.?\d*)/,
+ /[+-]?\s*(\d+\.?\d+)/,
+];
+
+const WS_URL = 'ws://localhost:8080';
+const CONTROL_URL = 'http://localhost:8081';
+
+class WeightScaleService {
+ constructor() {
+ this.portKey = null;
+ this.isConnected = false;
+ this.lastError = '';
+ this.reading = false;
+ this.ws = null;
+ this.isNative = Capacitor.isNativePlatform();
+ this.reconnectTimeout = null;
+ this.shouldReconnect = false;
+ }
+
+ isAndroidApp() {
+ return this.isNative;
+ }
+
+ // ─── GET DEVICES ──────────────────────────────────
+ async getDevices() {
+ if (!this.isAndroidApp()) return [];
+ try {
+ const result = await UsbSerial.getDeviceConnections();
+ console.log('Devices:', JSON.stringify(result));
+ return result.devices || [];
+ } catch (e) {
+ this.lastError = e.message;
+ return [];
+ }
+ }
+
+ // ─── AUTO CONNECT ─────────────────────────────────
+ async autoConnect() {
+ if (this.isAndroidApp()) {
+ return await this.connectNative();
+ } else {
+ return await this.connectWebSocket();
+ }
+ }
+
+ // ─── NATIVE ANDROID CONNECT ───────────────────────
+ async connectNative() {
+ try {
+ try {
+ await UsbSerial.endConnections();
+ console.log('Cleared old connections');
+ } catch (_) {}
+
+ await this.sleep(500);
+
+ const devices = await this.getDevices();
+ if (!devices || devices.length === 0) {
+ this.lastError = 'No USB device found. Check OTG cable.';
+ return false;
+ }
+
+ const device = devices[0];
+ console.log('Device:', JSON.stringify(device));
+
+ const result = await UsbSerial.openConnection({
+ deviceId: device.deviceId,
+ baudRate: 9600,
+ dataBits: 8,
+ stopBits: 1,
+ parity: 0,
+ });
+
+ console.log('openConnection result:', JSON.stringify(result));
+
+ try {
+ const activePorts = await UsbSerial.getActivePorts();
+ console.log('Active ports:', JSON.stringify(activePorts));
+ if (activePorts?.ports?.length > 0) {
+ this.portKey = activePorts.ports[0];
+ } else {
+ this.portKey = result?.portKey
+ || result?.key
+ || result?.port
+ || result?.portId
+ || String(device.deviceId);
+ }
+ } catch (e) {
+ this.portKey = result?.portKey
+ || result?.key
+ || result?.port
+ || String(device.deviceId);
+ }
+
+ console.log('Final portKey:', this.portKey);
+ this.isConnected = true;
+ return true;
+
+ } catch (e) {
+ this.lastError = e.message;
+ if (e.message?.toLowerCase().includes('permission')) {
+ this.lastError = 'USB permission denied. Unplug and replug USB cable.';
+ }
+ if (e.message?.toLowerCase().includes('port') || e.message?.toLowerCase().includes('open')) {
+ this.lastError = 'Port busy. Unplug USB, wait 3 seconds, replug and try again.';
+ }
+ console.error('connectNative error:', e.message);
+ return false;
+ }
+ }
+
+ // ─── CHROME WEBSOCKET CONNECT ─────────────────────
+ connectWebSocket() {
+ return new Promise((resolve) => {
+ try {
+ this.shouldReconnect = true;
+
+ // Try to start the service
+ fetch(`${CONTROL_URL}/start`, { method: 'POST' }).catch(() => {});
+
+ const ws = new WebSocket(WS_URL);
+ this.ws = ws;
+
+ const timeout = setTimeout(() => {
+ this.lastError = 'WebSocket connection timeout';
+ resolve(false);
+ }, 5000);
+
+ ws.onopen = () => {
+ clearTimeout(timeout);
+ this.isConnected = true;
+ console.log('WebSocket connected');
+ resolve(true);
+ };
+
+ ws.onerror = () => {
+ clearTimeout(timeout);
+ this.lastError = 'WebSocket error. Is the scale service running?';
+ resolve(false);
+ };
+
+ ws.onclose = () => {
+ this.isConnected = false;
+ // Auto reconnect if not manually disconnected
+ if (this.shouldReconnect) {
+ console.log('WebSocket closed, reconnecting...');
+ this.reconnectTimeout = setTimeout(() => {
+ this.connectWebSocket();
+ }, 2000);
+ }
+ };
+
+ } catch (e) {
+ this.lastError = e.message;
+ resolve(false);
+ }
+ });
+ }
+
+ // ─── START READING ────────────────────────────────
+ async startReading(onWeight, onError) {
+ if (this.isAndroidApp()) {
+ await this.startNativeReading(onWeight, onError);
+ } else {
+ this.startWebSocketReading(onWeight, onError);
+ }
+ }
+
+ // Native read polling loop
+ async startNativeReading(onWeight, onError) {
+ if (!this.portKey) return;
+
+ this.reading = true;
+ let buffer = '';
+ let errorCount = 0;
+
+ const poll = async () => {
+ while (this.reading) {
+ try {
+ const result = await UsbSerial.read({ key: this.portKey });
+
+ if (result && result.data && result.data.length > 0) {
+ buffer += result.data;
+ const parsed = this.parseWeight(buffer);
+ if (parsed) {
+ onWeight(parsed.value, parsed.unit);
+ buffer = '';
+ }
+ if (buffer.length > 100) {
+ buffer = buffer.slice(-50);
+ }
+ }
+
+ errorCount = 0;
+ await this.sleep(200);
+
+ } catch (e) {
+ errorCount++;
+ console.error(`Read error (${errorCount}):`, e.message);
+ if (errorCount >= 5) {
+ this.reading = false;
+ this.isConnected = false;
+ if (onError) onError(new Error('Scale disconnected: ' + e.message));
+ break;
+ }
+ await this.sleep(500);
+ }
+ }
+ };
+
+ poll();
+ }
+
+ // WebSocket read
+ startWebSocketReading(onWeight, onError) {
+ if (!this.ws) return;
+
+ this.ws.onmessage = (event) => {
+ try {
+ const data = JSON.parse(event.data);
+ if (data.type === 'weight') {
+ const value = parseFloat(data.weight);
+ const unit = data.unit || 'kg';
+ if (!isNaN(value)) {
+ onWeight(value, unit);
+ }
+ } else if (data.type === 'status') {
+ console.log('Scale status:', data);
+ }
+ } catch (e) {
+ if (onError) onError(e);
+ }
+ };
+ }
+
+ // ─── PARSE WEIGHT ─────────────────────────────────
+ parseWeight(raw) {
+ if (!raw || raw.trim() === '') return null;
+ const cleaned = raw.trim();
+
+ for (const pattern of WEIGHT_PATTERNS) {
+ const match = cleaned.match(pattern);
+ if (match) {
+ const value = parseFloat(match[1]);
+ const unit = match[2] ? match[2].toLowerCase() : 'kg';
+ if (!isNaN(value) && value >= 0) {
+ return { value, unit };
+ }
+ }
+ }
+
+ const fixedMatch = cleaned.match(/^0*(\d+)(\d{3})$/);
+ if (fixedMatch) {
+ const value = parseFloat(`${fixedMatch[1]}.${fixedMatch[2]}`);
+ return { value, unit: 'kg' };
+ }
+
+ return null;
+ }
+
+ // ─── DISCONNECT ───────────────────────────────────
+ async disconnect() {
+ this.reading = false;
+ this.shouldReconnect = false;
+
+ if (this.reconnectTimeout) {
+ clearTimeout(this.reconnectTimeout);
+ this.reconnectTimeout = null;
+ }
+
+ if (this.isAndroidApp()) {
+ try {
+ await UsbSerial.endConnections();
+ } catch (e) {
+ console.error('Disconnect error:', e);
+ }
+ } else {
+ try {
+ await fetch(`${CONTROL_URL}/stop`, { method: 'POST' }).catch(() => {});
+ if (this.ws) {
+ this.ws.close();
+ this.ws = null;
+ }
+ } catch (e) {
+ console.error('Disconnect error:', e);
+ }
+ }
+
+ this.portKey = null;
+ this.isConnected = false;
+ }
+// Call on component unmount — clears callbacks WITHOUT closing USB connection
+detachCallbacks() {
+ if (this.isAndroidApp()) {
+ // Stop the read loop softly — don't close the port
+ this.reading = false;
+ } else {
+ // Remove WebSocket message handler
+ if (this.ws) {
+ this.ws.onmessage = null;
+ }
+ }
+}
+ sleep(ms) {
+ return new Promise(resolve => setTimeout(resolve, ms));
+ }
+}
+
+export const weightScaleService = new WeightScaleService();
\ No newline at end of file