feat(game): requestClientScreenshot support

Author: itschip

game/server/bootstrap.ts

@@ -1,7 +1,7 @@
 import { createServer } from './koa-router';
 import './export';
 import { eventController } from './event';
-import { RequestUploadToken } from './types';
+import { RequestUploadToken, createRegularUploadData } from './types';
 import { UploadStore } from './upload-store';
 
 export const uploadStore = new UploadStore();
@@ -23,7 +23,7 @@ eventController<RequestUploadToken, string>(
       emitNet('screencapture:INTERNAL_uploadComplete', playerSource, JSON.stringify(response), correlationId);
     }
 
-    const token = uploadStore.addUpload({
+    const token = uploadStore.addUpload(createRegularUploadData({
       callback: uploadCallback,
       isRemote: true,
       remoteConfig: {
@@ -36,7 +36,7 @@ eventController<RequestUploadToken, string>(
       dataType: 'blob',
       playerSource: ctx.source,
       correlationId: body.correlationId,
-    });
+    }));
 
     return send(token);
   },

game/server/export.ts

@@ -1,5 +1,6 @@
 import { uploadStore } from './bootstrap';
-import { CallbackFn, CaptureOptions, DataType } from './types';
+import { CallbackFn, CaptureOptions, DataType, ScreenshotBasicCallbackFn, createScreenshotBasicUploadData, createRegularUploadData } from './types';
+import { exportHandler } from './utils';
 
 /* global.exports("serverCaptureStream", (source: number) => {
   const token = router.addStream({
@@ -22,7 +23,7 @@ global.exports(
   (source: number, url: string, options: CaptureOptions, callback: CallbackFn, dataType: DataType = 'base64') => {
     if (!source) return console.error('source is required for serverCapture');
 
-    const token = uploadStore.addUpload({
+    const token = uploadStore.addUpload(createRegularUploadData({
       callback: callback,
       isRemote: true,
       remoteConfig: {
@@ -31,7 +32,7 @@ global.exports(
       },
       url,
       dataType,
-    });
+    }));
 
     emitNet('screencapture:captureScreen', source, token, options, dataType);
   },
@@ -49,13 +50,44 @@ global.exports(
       encoding: options.encoding ?? 'webp',
     };
 
-    const token = uploadStore.addUpload({
+    const token = uploadStore.addUpload(createRegularUploadData({
       callback,
       isRemote: false,
-      remoteConfig: opts, // Store options here so we have access to encoding
+      remoteConfig: opts,
       dataType,
-    });
+    }));
 
     emitNet('screencapture:captureScreen', source, token, opts, dataType);
   },
-);
+);
+
+// screeenshot-basic backwards compatibility
+function requestClientScreenshot(source: number, options: CaptureOptions, callback: ScreenshotBasicCallbackFn) {
+  if (!source) return console.error('source is required for requestClientScreenshot');
+
+  const opts = {
+    ...options,
+    encoding: options.encoding ?? 'webp',
+  };
+
+  const isBlob = options.fileName ? true : false;
+
+  const token = uploadStore.addUpload(createScreenshotBasicUploadData({
+    callback,
+    isRemote: false,
+    remoteConfig: opts,
+    dataType: isBlob ? 'blob' : 'base64',
+  }));
+
+  emitNet('screencapture:captureScreen', source, token, opts, isBlob ? 'blob' : 'base64');
+}
+
+global.exports(
+  'requestClientScreenshot',
+  (source: number, options: CaptureOptions, callback: ScreenshotBasicCallbackFn) => {
+    requestClientScreenshot(source, options, callback);
+  },
+);
+exportHandler("requestClientScreenshot", (source: number, options: CaptureOptions, callback: ScreenshotBasicCallbackFn) => {
+  requestClientScreenshot(source, options, callback);
+});

game/server/koa-router.ts

@@ -1,5 +1,6 @@
 import Koa from 'koa';
 import Router from '@koa/router';
+import { writeFileSync} from 'fs';
 
 // @ts-ignore - no types
 import { setHttpCallback } from '@citizenfx/http-wrapper';
@@ -30,7 +31,7 @@ export async function createServer(uploadStore: UploadStore) {
     ctx.response.append('Access-Control-Allow-Origin', '*');
     ctx.response.append('Access-Control-Allow-Methods', 'GET, POST');
 
-    const { callback, dataType, isRemote, remoteConfig, url, playerSource, correlationId } =
+    const { callback, dataType, isRemote, remoteConfig, url, playerSource, correlationId, screenshotBasicCompatibility } =
       uploadStore.getUpload(token);
 
     if (!ctx.files) {
@@ -41,30 +42,55 @@ export async function createServer(uploadStore: UploadStore) {
     const file = ctx.file;
 
     try {
-      // Get encoding from remoteConfig or default to 'webp'
       const encoding = remoteConfig?.encoding || 'webp';
+      // base64 or buffer
       const buf = await buffer(dataType, file.buffer, encoding);
 
       if (isRemote) {
         const response = await uploadFile(url, remoteConfig, buf, dataType);
 
-        // this is only when we return data back to the client
-        if (playerSource && correlationId) {
-          callback(response, playerSource, correlationId);
+        if (screenshotBasicCompatibility) {
+          (callback as any)(false, response);
         } else {
-          callback(response);
+          if (playerSource && correlationId) {
+            (callback as any)(response, playerSource, correlationId);
+          } else {
+            (callback as any)(response);
+          }
         }
       } else {
-        callback(buf);
+        if (screenshotBasicCompatibility) {
+          // this will be a base64 string
+          if (remoteConfig?.fileName) {
+            const filename = saveFileToDisk(remoteConfig.fileName, buf);
+            (callback as any)(false, filename);
+          } else {
+            (callback as any)(false, buf);
+          }
+        } else {
+          (callback as any)(buf);
+        }
       }
 
       ctx.status = 200;
       ctx.body = { status: 'success' };
     } catch (err) {
       if (err instanceof Error) {
+        if (screenshotBasicCompatibility) {
+          (callback as any)(err.message, null);
+        } else {
+          (callback as any)(err);
+        }
+        
         ctx.status = 500;
         ctx.body = { status: 'error', message: err.message };
       } else {
+        if (screenshotBasicCompatibility) {
+          (callback as any)('An unknown error occurred', null);
+        } else {
+          (callback as any)(new Error('An unknown error occurred'));
+        }
+        
         ctx.status = 500;
         ctx.body = { status: 'error', message: 'An unknown error occurred' };
       }
@@ -195,3 +221,13 @@ function getMimeType(encoding: string): string {
       return 'image/webp';
   }
 }
+
+function saveFileToDisk(fileName: string, data: string | Buffer) {
+  try {
+    writeFileSync(fileName, data);
+    return fileName;
+  } catch (err) {
+    console.error('Error saving file to disk:', err);
+    throw new Error('Error saving file to disk');
+  }
+}

game/server/types.ts

@@ -3,13 +3,30 @@ export type DataType = 'base64' | 'blob';
 type Encoding = 'webp' | 'jpg' | 'png';
 
 export interface UploadData {
-  callback: CallbackFn;
+  callback: CallbackFn | ScreenshotBasicCallbackFn;
   isRemote: boolean;
   remoteConfig: CaptureOptions | null;
   dataType: DataType;
   url?: string;
   playerSource?: number;
   correlationId?: string;
+  screenshotBasicCompatibility?: boolean;
+}
+
+export function createScreenshotBasicUploadData(params: Omit<UploadData, 'callback' | 'screenshotBasicCompatibility'> & { callback: ScreenshotBasicCallbackFn }): UploadData {
+  return {
+    ...params,
+    callback: params.callback,
+    screenshotBasicCompatibility: true,
+  };
+}
+
+export function createRegularUploadData(params: Omit<UploadData, 'callback' | 'screenshotBasicCompatibility'> & { callback: CallbackFn }): UploadData {
+  return {
+    ...params,
+    callback: params.callback,
+    screenshotBasicCompatibility: false,
+  };
 }
 
 export interface StreamUploadData {
@@ -31,14 +48,17 @@ export interface CaptureOptions {
   headers?: HeadersInit;
   formField?: string;
   filename?: string;
+  // fuck me, but needed for screenshot-basic stuffies -- delete later :)
+  fileName?: string;
   encoding?: string;
   maxWidth?: number;
   maxHeight?: number;
 }
 
 export type CallbackFn = (data: unknown, _playerSource?: number, correlationId?: string) => void;
+export type ScreenshotBasicCallbackFn = (err: string | boolean, data: string) => void;
 
-export interface CallbackData {
+export interface CallbackData { 
   imageData: string | Buffer<ArrayBuffer>;
   dataType: string;
 }

game/server/utils.ts

@@ -0,0 +1,6 @@
+// https://github.com/overextended/ox_target/blob/main/client/compat/qtarget.lua#L1
+export function exportHandler(exportName: string, func: (...args: any[]) => any): void {
+  AddEventHandler(`__cfx_export_screenshot-basic_${exportName}`, (setCB: (cb: (...args: any[]) => any) => void) => {
+    setCB(func);
+  });
+}