@phystack/hub-device 4.3.40-dev

package/src/storage/browser.ts

@@ -0,0 +1,16 @@
+export default async function initializeBrowserStorage(): Promise<any> {
+  return {
+    set: (key: string, value: any) => {
+      localStorage.setItem(`phyHub-${key}`, JSON.stringify(value));
+      return Promise.resolve();
+    },
+    get: (key: string) => {
+      const value = localStorage.getItem(`phyHub-${key}`);
+      return Promise.resolve(value ? JSON.parse(value) : null);
+    },
+    remove: (key: string) => {
+      localStorage.removeItem(key);
+      return Promise.resolve();
+    }
+  };
+}

package/src/storage/index.ts

@@ -0,0 +1,46 @@
+let storage: {
+  set: (key: string, value: any) => Promise<void>;
+  get: (key: string) => Promise<any>;
+  remove: (key: string) => Promise<void>;
+} | null = null;
+
+const isNode = typeof window === 'undefined';
+
+const logger = console;
+
+export default async function getStorage(): Promise<{
+  set: (key: string, value: any) => Promise<void>;
+  get: (key: string) => Promise<any>;
+  remove: (key: string) => Promise<void>;
+}> {
+  if (!storage) {
+    try {
+      if (isNode) {
+        logger.info('getStorage(): Initializing Node storage');
+        const initializeStorage = require('./node').default;
+        storage = await initializeStorage();
+      } else {
+        logger.info('getStorage(): Initializing Browser storage');
+        const initializeStorage = require('./browser').default;
+        storage = await initializeStorage();
+      }
+    } catch (error) {
+      logger.error('getStorage(): Error during storage initialization:', error);
+      throw new Error('Storage initialization failed');
+    }
+  }
+
+  if (!storage) {
+    throw new Error('Storage initialization failed');
+  }
+
+  return storage;
+}
+
+// Example usage:
+// (async () => {
+//   const storage = await getStorage();
+//   await storage.set('exampleKey', { example: 'value' });
+//   const value = await storage.get('exampleKey');
+//   console.log(value);
+// })();

package/src/storage/node.ts

@@ -0,0 +1,42 @@
+export default async function initializeNodeStorage(): Promise<any> {
+  try {
+    console.log('Initializing Node storage');
+    const path = await import('path');
+    const fs = await import('fs');
+    const dirPath = '/data/settings';
+
+    return {
+      set: async (key: string, value: any) => {
+        const filePath = path.join(dirPath, 'phyhub', `${key}.json`);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(value), 'utf-8');
+      },
+      get: async (key: string) => {
+        const filePath = path.join(dirPath, 'phyhub', `${key}.json`);
+        try {
+          const data = fs.readFileSync(filePath, 'utf-8');
+          return JSON.parse(data);
+        } catch (error: any) {
+          if (error.code === 'ENOENT') {
+            // console.error(`[Warning] Storage not initialized for ${key} yet`);
+            return null;
+          }
+          console.error(`[Error] Error to get ${key} from node storage`, error);
+        }
+      },
+      async remove(key: string): Promise<void> {
+        const filePath = path.join(dirPath, 'phyhub', `${key}.json`);
+        try {
+          fs.unlinkSync(filePath);
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+            console.error(`[Error] Failed to remove ${key} from node storage`, error);
+          }
+        }
+      },
+    };
+  } catch (error) {
+    console.error('Failed to initialize Node storage:', error);
+    throw error;
+  }
+}

package/src/sysinfo/browser.ts

@@ -0,0 +1,217 @@
+import UAParser from 'ua-parser-js';
+
+// Extending the Navigator interface to include deviceMemory and connection properties
+interface NavigatorExtended extends Navigator {
+  deviceMemory?: number;
+  connection?: {
+    type?: string;
+    effectiveType?: string;
+    addEventListener?: (type: string, listener: (event: Event) => void) => void;
+  };
+  getBattery?: () => Promise<any>;
+}
+
+function getBrowserSystemInfo(): any {
+  const parser = new UAParser();
+  const uaResult = parser.getResult();
+  // console.log({ uaResult })
+
+  function isCanvasSupported(): boolean {
+    try {
+      let canvas = document.createElement('canvas');
+      return !!(canvas.getContext && canvas.getContext('2d'));
+    } catch (e) {
+      return false;
+    }
+  }
+
+  function isWebGLSupported(): boolean {
+    try {
+      let canvas = document.createElement('canvas');
+      return !!(
+        window.WebGLRenderingContext &&
+        (canvas.getContext('webgl') || canvas.getContext('experimental-webgl'))
+      );
+    } catch (e) {
+      return false;
+    }
+  }
+
+  function computeCPUScore(timeFrame: number): number {
+    let sysm = 0;
+    let start = new Date().getTime();
+    let end = start;
+
+    while (end - start === 0) {
+      end = new Date().getTime();
+    }
+
+    start = end;
+
+    while (end - start < timeFrame) {
+      sysm++;
+      end = new Date().getTime();
+    }
+
+    return sysm;
+  }
+
+  const navigatorExtended = navigator as NavigatorExtended;
+
+  const systemInfo: any = {
+    system: {
+      manufacturer: uaResult.device.vendor || '',
+      model: uaResult.device.model || '',
+      version: '',
+      serial: '',
+      uuid: '',
+      sku: '',
+    },
+    browser: {
+      name: uaResult.browser.name || '',
+      version: uaResult.browser.version || '',
+      major: uaResult.browser.major || '',
+      agent: uaResult.ua,
+    },
+    os: {
+      platform: uaResult.device.model || '',
+      distro: uaResult.os.name || '',
+      release: uaResult.os.version || '',
+      codename: '',
+      kernel: '',
+      arch: uaResult.cpu.architecture || '',
+      hostname: '',
+      codepage: '',
+      logofile: '',
+    },
+    bios: {
+      vendor: '',
+      version: '',
+      releaseDate: '',
+      revision: '',
+    },
+    baseboard: {
+      manufacturer: '',
+      model: '',
+      version: '',
+      serial: '',
+      assetTag: '',
+    },
+    chassis: {
+      manufacturer: '',
+      model: '',
+      version: '',
+      serial: '',
+      assetTag: '',
+      sku: '',
+    },
+    cpu: {
+      manufacturer: '',
+      brand: '',
+      vendor: '',
+      family: '',
+      model: '',
+      stepping: '',
+      revision: '',
+      voltage: '',
+      speed: '',
+      speedmin: '',
+      speedmax: '',
+      cores: navigator.hardwareConcurrency || '',
+      physicalCores: '',
+      processors: '',
+      socket: '',
+      cache: {
+        l1d: '',
+        l1i: '',
+        l2: '',
+        l3: '',
+      },
+      score: computeCPUScore(20),
+    },
+    memory: {
+      total: navigatorExtended.deviceMemory ? navigatorExtended.deviceMemory * 1073741824 : '', // in bytes
+      free: '',
+      used: '',
+      active: '',
+      available: '',
+      buffers: '',
+      cached: '',
+      slab: '',
+      buffcache: '',
+      swaptotal: '',
+      swapused: '',
+      swapfree: '',
+    },
+    graphics: {
+      controllers: [
+        {
+          vendor: '',
+          model: '',
+          bus: '',
+          vram: '',
+          vramDynamic: '',
+        },
+      ],
+      displays: [
+        {
+          model: '',
+          main: true,
+          resolutionx: window.screen.width,
+          resolutiony: window.screen.height,
+          sizex: window.screen.width, // in pixels
+          sizey: window.screen.height, // in pixels
+          pixeldepth: window.screen.pixelDepth,
+        },
+      ],
+      features: {
+        canvas: isCanvasSupported(),
+        webgl: isWebGLSupported(),
+      },
+    },
+    network: [],
+    battery: {
+      hasbattery: false,
+      cyclecount: '',
+      ischarging: '',
+      designedcapacity: '',
+      maxcapacity: '',
+      currentcapacity: '',
+      voltage: '',
+      capacityUnit: '',
+    },
+    usb: [],
+    audio: [],
+  };
+
+  // Determine display orientation
+  systemInfo.graphics.orientation =
+    systemInfo.graphics.displays[0].resolutionx > systemInfo.graphics.displays[0].resolutiony
+      ? 'landscape'
+      : 'portrait';
+
+  if (navigatorExtended.getBattery) {
+    navigatorExtended.getBattery().then(battery => {
+      systemInfo.battery.hasbattery = true;
+      systemInfo.battery.ischarging = battery.charging;
+      systemInfo.battery.currentcapacity = battery.level * 100; // Convert to percentage
+    });
+  }
+
+  if (navigatorExtended.connection) {
+    systemInfo.network.push({
+      iface: '',
+      ifaceName: '',
+      ip4: '',
+      ip6: '',
+      mac: '',
+      internal: false,
+      effectiveType: navigatorExtended.connection.effectiveType,
+    });
+  }
+
+  return systemInfo;
+}
+
+// Example usage:
+export default getBrowserSystemInfo;

package/src/sysinfo/index.ts

@@ -0,0 +1,29 @@
+const isNode = typeof window === 'undefined';
+export const isTizen =
+  typeof window !== 'undefined' && typeof (window as any).tizen !== 'undefined';
+
+const logger = console;
+export default async function getSystemInfo() {
+  let info: any = {};
+  try {
+    if (isNode) {
+      logger.info('getSystemInfo(): Initializing Node sysinfo');
+      const getInfo = require('./node').default;
+      info = await getInfo();
+    } else if (isTizen) {
+      logger.info('getSystemInfo(): Initializing Tizen sysinfo');
+      const getInfo = require('./tizen').default;
+      info = await getInfo();
+      logger.info(`getSystemInfo(): Fetched Tizen sysinfo`, info);
+    } else {
+      logger.info('getSystemInfo(): Initializing Browser sysinfo');
+      const getInfo = require('./browser').default;
+      info = await getInfo();
+    }
+  } catch (error) {
+    logger.error('getSystemInfo(): Error during sysinfo initialization:', error);
+    throw new Error('System information initialization failed');
+  }
+
+  return info;
+}