cuoral-ionic 0.0.1

package/src/types.ts

@@ -0,0 +1,129 @@
+/**
+ * Message types for communication between WebView and Native code
+ */
+export enum CuoralMessageType {
+  // Screen Recording
+  START_RECORDING = 'CUORAL_START_RECORDING',
+  STOP_RECORDING = 'CUORAL_STOP_RECORDING',
+  RECORDING_STARTED = 'CUORAL_RECORDING_STARTED',
+  RECORDING_STOPPED = 'CUORAL_RECORDING_STOPPED',
+  RECORDING_ERROR = 'CUORAL_RECORDING_ERROR',
+  
+  // Screenshot
+  TAKE_SCREENSHOT = 'CUORAL_TAKE_SCREENSHOT',
+  SCREENSHOT_TAKEN = 'CUORAL_SCREENSHOT_TAKEN',
+  SCREENSHOT_ERROR = 'CUORAL_SCREENSHOT_ERROR',
+  
+  // Widget Communication
+  WIDGET_READY = 'CUORAL_WIDGET_READY',
+  WIDGET_CLOSED = 'CUORAL_WIDGET_CLOSED',
+  
+  // File Upload
+  UPLOAD_FILE = 'CUORAL_UPLOAD_FILE',
+  UPLOAD_PROGRESS = 'CUORAL_UPLOAD_PROGRESS',
+  UPLOAD_COMPLETE = 'CUORAL_UPLOAD_COMPLETE',
+  UPLOAD_ERROR = 'CUORAL_UPLOAD_ERROR',
+}
+
+/**
+ * Base message structure
+ */
+export interface CuoralMessage {
+  type: CuoralMessageType;
+  payload?: any;
+  timestamp?: number;
+}
+
+/**
+ * Recording state
+ */
+export interface RecordingState {
+  isRecording: boolean;
+  duration?: number;
+  filePath?: string;
+  error?: string;
+}
+
+/**
+ * Screenshot data
+ */
+export interface ScreenshotData {
+  base64: string;
+  mimeType: string;
+  width: number;
+  height: number;
+}
+
+/**
+ * Upload progress data
+ */
+export interface UploadProgress {
+  loaded: number;
+  total: number;
+  percentage: number;
+}
+
+/**
+ * Plugin configuration
+ */
+export interface CuoralConfig {
+  /**
+   * Widget URL to load
+   */
+  widgetUrl: string;
+  
+  /**
+   * Enable debug logging
+   */
+  debug?: boolean;
+  
+  /**
+   * Custom message handler
+   */
+  onMessage?: (message: CuoralMessage) => void;
+  
+  /**
+   * Recording quality (0.0 - 1.0)
+   */
+  recordingQuality?: number;
+  
+  /**
+   * Screenshot quality (0.0 - 1.0)
+   */
+  screenshotQuality?: number;
+}
+
+/**
+ * Recording options
+ */
+export interface RecordingOptions {
+  /**
+   * Video quality (0.0 - 1.0)
+   */
+  quality?: number;
+  
+  /**
+   * Include audio
+   */
+  includeAudio?: boolean;
+  
+  /**
+   * Maximum duration in seconds
+   */
+  maxDuration?: number;
+}
+
+/**
+ * Screenshot options
+ */
+export interface ScreenshotOptions {
+  /**
+   * Image quality (0.0 - 1.0)
+   */
+  quality?: number;
+  
+  /**
+   * Image format
+   */
+  format?: 'png' | 'jpeg';
+}

package/src/web.ts

@@ -0,0 +1,135 @@
+import { WebPlugin } from '@capacitor/core';
+import { CuoralPluginInterface } from './plugin';
+import {
+  RecordingOptions,
+  RecordingState,
+  ScreenshotOptions,
+  ScreenshotData,
+} from './types';
+
+/**
+ * Web implementation (for testing in browser)
+ */
+export class CuoralPluginWeb extends WebPlugin implements CuoralPluginInterface {
+  private isRecording = false;
+  private recordingStartTime?: number;
+
+  async startRecording(options?: RecordingOptions): Promise<{ success: boolean }> {
+    console.log('[Cuoral Web] Start recording', options);
+    
+    // Check if Screen Capture API is available
+    if (!navigator.mediaDevices || !navigator.mediaDevices.getDisplayMedia) {
+      throw new Error('Screen recording is not supported in this browser');
+    }
+
+    try {
+      // Request screen capture
+      const stream = await navigator.mediaDevices.getDisplayMedia({
+        video: true,
+        audio: options?.includeAudio || false,
+      });
+
+      this.isRecording = true;
+      this.recordingStartTime = Date.now();
+
+      // Store stream for later stopping
+      (window as any).__cuoralRecordingStream = stream;
+
+      return { success: true };
+    } catch (error) {
+      console.error('[Cuoral Web] Failed to start recording:', error);
+      return { success: false };
+    }
+  }
+
+  async stopRecording(): Promise<{ success: boolean; filePath?: string; duration?: number }> {
+    console.log('[Cuoral Web] Stop recording');
+
+    if (!this.isRecording) {
+      return { success: false };
+    }
+
+    const stream = (window as any).__cuoralRecordingStream as MediaStream;
+    if (stream) {
+      stream.getTracks().forEach(track => track.stop());
+      delete (window as any).__cuoralRecordingStream;
+    }
+
+    const duration = this.recordingStartTime
+      ? Math.floor((Date.now() - this.recordingStartTime) / 1000)
+      : 0;
+
+    this.isRecording = false;
+    this.recordingStartTime = undefined;
+
+    return {
+      success: true,
+      duration,
+      filePath: 'web-recording-not-saved',
+    };
+  }
+
+  async getRecordingState(): Promise<RecordingState> {
+    return {
+      isRecording: this.isRecording,
+      duration: this.recordingStartTime
+        ? Math.floor((Date.now() - this.recordingStartTime) / 1000)
+        : undefined,
+    };
+  }
+
+  async takeScreenshot(options?: ScreenshotOptions): Promise<ScreenshotData> {
+    console.log('[Cuoral Web] Take screenshot', options);
+
+    try {
+      // Use Screen Capture API
+      const stream = await navigator.mediaDevices.getDisplayMedia({
+        video: { width: 1920, height: 1080 },
+      });
+
+      // Capture frame from video stream
+      const video = document.createElement('video');
+      video.srcObject = stream;
+      video.play();
+
+      await new Promise(resolve => {
+        video.onloadedmetadata = resolve;
+      });
+
+      const canvas = document.createElement('canvas');
+      canvas.width = video.videoWidth;
+      canvas.height = video.videoHeight;
+
+      const ctx = canvas.getContext('2d');
+      ctx?.drawImage(video, 0, 0);
+
+      // Stop stream
+      stream.getTracks().forEach(track => track.stop());
+
+      // Convert to base64
+      const format = options?.format || 'png';
+      const quality = options?.quality || 0.92;
+      const base64 = canvas.toDataURL(`image/${format}`, quality);
+
+      return {
+        base64: base64.split(',')[1],
+        mimeType: `image/${format}`,
+        width: canvas.width,
+        height: canvas.height,
+      };
+    } catch (error) {
+      console.error('[Cuoral Web] Failed to take screenshot:', error);
+      throw error;
+    }
+  }
+
+  async isRecordingSupported(): Promise<{ supported: boolean }> {
+    const supported = !!(navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia);
+    return { supported };
+  }
+
+  async requestPermissions(): Promise<{ granted: boolean }> {
+    // Web doesn't require explicit permissions - they're requested on demand
+    return { granted: true };
+  }
+}