node-mac-recorder 1.2.3 → 1.2.4

package/capture-test.js

@@ -0,0 +1,87 @@
+const MacRecorder = require("./");
+const fs = require("fs");
+const path = require("path");
+
+async function saveBase64Image(base64String, filePath) {
+	// Remove the data:image/png;base64, prefix if it exists
+	const base64Data = base64String.replace(/^data:image\/png;base64,/, "");
+
+	// Create directory if it doesn't exist
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir, { recursive: true });
+	}
+
+	// Write the file
+	fs.writeFileSync(filePath, base64Data, "base64");
+	console.log(`✅ Saved image to: ${filePath}`);
+}
+
+async function captureTest() {
+	const recorder = new MacRecorder();
+
+	// Create output directory
+	const outputDir = path.join(__dirname, "thumbnails");
+	if (!fs.existsSync(outputDir)) {
+		fs.mkdirSync(outputDir, { recursive: true });
+	}
+
+	console.log("📸 Testing Display Capture");
+
+	// Get displays
+	const displays = await recorder.getDisplays();
+	console.log(`Found ${displays.length} displays`);
+
+	// Capture each display
+	for (const display of displays) {
+		console.log(
+			`\nCapturing display ${display.id} (${display.width}x${display.height})`
+		);
+		try {
+			const thumbnail = await recorder.getDisplayThumbnail(display.id, {
+				maxWidth: 800,
+				maxHeight: 600,
+			});
+
+			const fileName = `display_${display.id}.png`;
+			const filePath = path.join(outputDir, fileName);
+			await saveBase64Image(thumbnail, filePath);
+		} catch (error) {
+			console.error(`Failed to capture display ${display.id}:`, error);
+		}
+	}
+
+	console.log("\n📸 Testing Window Capture");
+
+	// Get windows
+	const windows = await recorder.getWindows();
+	console.log(`Found ${windows.length} windows`);
+
+	// Capture each window
+	for (const window of windows) {
+		console.log(
+			`\nCapturing window "${window.appName}" (${window.width}x${window.height})`
+		);
+		try {
+			const thumbnail = await recorder.getWindowThumbnail(window.id, {
+				maxWidth: 800,
+				maxHeight: 600,
+			});
+
+			const fileName = `window_${window.id}_${window.appName.replace(
+				/[^a-z0-9]/gi,
+				"_"
+			)}.png`;
+			const filePath = path.join(outputDir, fileName);
+			await saveBase64Image(thumbnail, filePath);
+		} catch (error) {
+			console.error(`Failed to capture window "${window.appName}":`, error);
+		}
+	}
+
+	console.log(
+		"\n✅ Test completed. Check the thumbnails directory for results."
+	);
+}
+
+captureTest().catch(console.error);

package/index.js

@@ -69,31 +69,17 @@ class MacRecorder extends EventEmitter {
 	 * macOS ekranlarını listeler
 	 */
 	async getDisplays() {
-		return new Promise((resolve, reject) => {
-			try {
-				const displays = nativeBinding.getDisplays();
-				const formattedDisplays = displays.map((display, index) => ({
-					id: index,
-					name:
-						typeof display === "string"
-							? display
-							: display.name || `Display ${index + 1}`,
-					resolution:
-						typeof display === "object"
-							? `${display.width}x${display.height}`
-							: "Unknown",
-					width: typeof display === "object" ? display.width : null,
-					height: typeof display === "object" ? display.height : null,
-					x: typeof display === "object" ? display.x : 0,
-					y: typeof display === "object" ? display.y : 0,
-					isPrimary:
-						typeof display === "object" ? display.isPrimary : index === 0,
-				}));
-				resolve(formattedDisplays);
-			} catch (error) {
-				reject(error);
-			}
-		});
+		const displays = nativeBinding.getDisplays();
+		return displays.map((display, index) => ({
+			id: display.id, // Use the actual display ID from native code
+			name: display.name,
+			width: display.width,
+			height: display.height,
+			x: display.x,
+			y: display.y,
+			isPrimary: display.isPrimary,
+			resolution: `${display.width}x${display.height}`,
+		}));
 	}
 
 	/**
@@ -404,8 +390,16 @@ class MacRecorder extends EventEmitter {
 
 		return new Promise((resolve, reject) => {
 			try {
+				// Get all displays first to validate the ID
+				const displays = nativeBinding.getDisplays();
+				const display = displays.find((d) => d.id === displayId);
+
+				if (!display) {
+					throw new Error(`Display with ID ${displayId} not found`);
+				}
+
 				const base64Image = nativeBinding.getDisplayThumbnail(
-					displayId,
+					display.id, // Use the actual CGDirectDisplayID
 					maxWidth,
 					maxHeight
 				);
@@ -586,6 +580,52 @@ class MacRecorder extends EventEmitter {
 			nativeModule: "mac_recorder.node",
 		};
 	}
+
+	async getDisplaysWithThumbnails(options = {}) {
+		const displays = await this.getDisplays();
+
+		// Get thumbnails for each display
+		const displayPromises = displays.map(async (display) => {
+			try {
+				const thumbnail = await this.getDisplayThumbnail(display.id, options);
+				return {
+					...display,
+					thumbnail,
+				};
+			} catch (error) {
+				return {
+					...display,
+					thumbnail: null,
+					thumbnailError: error.message,
+				};
+			}
+		});
+
+		return Promise.all(displayPromises);
+	}
+
+	async getWindowsWithThumbnails(options = {}) {
+		const windows = await this.getWindows();
+
+		// Get thumbnails for each window
+		const windowPromises = windows.map(async (window) => {
+			try {
+				const thumbnail = await this.getWindowThumbnail(window.id, options);
+				return {
+					...window,
+					thumbnail,
+				};
+			} catch (error) {
+				return {
+					...window,
+					thumbnail: null,
+					thumbnailError: error.message,
+				};
+			}
+		});
+
+		return Promise.all(windowPromises);
+	}
 }
 
 module.exports = MacRecorder;

package/list-test.js

@@ -0,0 +1,46 @@
+const MacRecorder = require("./");
+
+async function testListing() {
+	const recorder = new MacRecorder();
+
+	console.log("📺 Testing Displays with Thumbnails");
+	const displays = await recorder.getDisplaysWithThumbnails({
+		maxWidth: 200,
+		maxHeight: 150,
+	});
+	console.log(`Found ${displays.length} displays:`);
+	for (const display of displays) {
+		console.log(`\nDisplay ID: ${display.id}`);
+		console.log(`Resolution: ${display.width}x${display.height}`);
+		console.log(`Position: (${display.x}, ${display.y})`);
+		console.log(`Primary: ${display.isPrimary}`);
+		console.log(
+			`Thumbnail included: ${display.thumbnail.substring(0, 50)}... (${
+				display.thumbnail.length
+			} chars)`
+		);
+	}
+
+	console.log("\n🪟 Testing Windows with Thumbnails");
+	const windows = await recorder.getWindowsWithThumbnails({
+		maxWidth: 200,
+		maxHeight: 150,
+	});
+	console.log(`Found ${windows.length} windows:`);
+	for (const window of windows.slice(0, 3)) {
+		// Just show first 3 for brevity
+		console.log(`\nWindow: ${window.appName}`);
+		console.log(`ID: ${window.id}`);
+		console.log(`Size: ${window.width}x${window.height}`);
+		console.log(
+			`Thumbnail included: ${window.thumbnail.substring(0, 50)}... (${
+				window.thumbnail.length
+			} chars)`
+		);
+	}
+	if (windows.length > 3) {
+		console.log(`\n... and ${windows.length - 3} more windows`);
+	}
+}
+
+testListing().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "1.2.3",
+	"version": "1.2.4",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [

package/src/mac_recorder.mm

@@ -7,6 +7,9 @@
 #import <ImageIO/ImageIO.h>
 #import <CoreAudio/CoreAudio.h>
 
+// Import screen capture
+#import "screen_capture.h"
+
 // Cursor tracker function declarations
 Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports);
 
@@ -363,35 +366,20 @@ Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
     @try {
-        NSMutableArray *displays = [NSMutableArray array];
-        
-        uint32_t displayCount;
-        CGGetActiveDisplayList(0, NULL, &displayCount);
-        
-        CGDirectDisplayID *displayList = (CGDirectDisplayID *)malloc(displayCount * sizeof(CGDirectDisplayID));
-        CGGetActiveDisplayList(displayCount, displayList, &displayCount);
-        
-        for (uint32_t i = 0; i < displayCount; i++) {
-            CGDirectDisplayID displayID = displayList[i];
-            CGRect bounds = CGDisplayBounds(displayID);
-            
-            [displays addObject:@{
-                @"id": @(displayID),
-                @"name": [NSString stringWithFormat:@"Display %d", i + 1],
-                @"width": @(bounds.size.width),
-                @"height": @(bounds.size.height),
-                @"x": @(bounds.origin.x),
-                @"y": @(bounds.origin.y),
-                @"isPrimary": @(CGDisplayIsMain(displayID))
-            }];
-        }
+        NSArray *displays = [ScreenCapture getAvailableDisplays];
+        Napi::Array result = Napi::Array::New(env, displays.count);
         
-        free(displayList);
+        NSLog(@"Found %lu displays", (unsigned long)displays.count);
         
-        // Convert to NAPI array
-        Napi::Array result = Napi::Array::New(env, displays.count);
         for (NSUInteger i = 0; i < displays.count; i++) {
             NSDictionary *display = displays[i];
+            NSLog(@"Display %lu: ID=%u, Name=%@, Size=%@x%@", 
+                  (unsigned long)i,
+                  [display[@"id"] unsignedIntValue],
+                  display[@"name"],
+                  display[@"width"],
+                  display[@"height"]);
+                  
             Napi::Object displayObj = Napi::Object::New(env);
             displayObj.Set("id", Napi::Number::New(env, [display[@"id"] unsignedIntValue]));
             displayObj.Set("name", Napi::String::New(env, [display[@"name"] UTF8String]));
@@ -406,6 +394,7 @@ Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
         return result;
         
     } @catch (NSException *exception) {
+        NSLog(@"Exception in GetDisplays: %@", exception);
         return Napi::Array::New(env, 0);
     }
 }
@@ -536,10 +525,34 @@ Napi::Value GetDisplayThumbnail(const Napi::CallbackInfo& info) {
     }
     
     @try {
+        // Verify display exists
+        CGDirectDisplayID activeDisplays[32];
+        uint32_t displayCount;
+        CGError err = CGGetActiveDisplayList(32, activeDisplays, &displayCount);
+        
+        if (err != kCGErrorSuccess) {
+            NSLog(@"Failed to get active display list: %d", err);
+            return env.Null();
+        }
+        
+        bool displayFound = false;
+        for (uint32_t i = 0; i < displayCount; i++) {
+            if (activeDisplays[i] == displayID) {
+                displayFound = true;
+                break;
+            }
+        }
+        
+        if (!displayFound) {
+            NSLog(@"Display ID %u not found in active displays", displayID);
+            return env.Null();
+        }
+        
         // Create display image
         CGImageRef displayImage = CGDisplayCreateImage(displayID);
         
         if (!displayImage) {
+            NSLog(@"CGDisplayCreateImage failed for display ID: %u", displayID);
             return env.Null();
         }
         
@@ -547,6 +560,8 @@ Napi::Value GetDisplayThumbnail(const Napi::CallbackInfo& info) {
         size_t originalWidth = CGImageGetWidth(displayImage);
         size_t originalHeight = CGImageGetHeight(displayImage);
         
+        NSLog(@"Original dimensions: %zux%zu", originalWidth, originalHeight);
+        
         // Calculate scaled dimensions maintaining aspect ratio
         double scaleX = (double)maxWidth / originalWidth;
         double scaleY = (double)maxHeight / originalHeight;
@@ -555,6 +570,8 @@ Napi::Value GetDisplayThumbnail(const Napi::CallbackInfo& info) {
         size_t thumbnailWidth = (size_t)(originalWidth * scale);
         size_t thumbnailHeight = (size_t)(originalHeight * scale);
         
+        NSLog(@"Thumbnail dimensions: %zux%zu (scale: %f)", thumbnailWidth, thumbnailHeight, scale);
+        
         // Create scaled image
         CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
         CGContextRef context = CGBitmapContextCreate(
@@ -564,43 +581,61 @@ Napi::Value GetDisplayThumbnail(const Napi::CallbackInfo& info) {
             8,
             thumbnailWidth * 4,
             colorSpace,
-            kCGImageAlphaPremultipliedLast
+            kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big
         );
         
-        if (context) {
-            CGContextDrawImage(context, CGRectMake(0, 0, thumbnailWidth, thumbnailHeight), displayImage);
-            CGImageRef thumbnailImage = CGBitmapContextCreateImage(context);
-            
-            if (thumbnailImage) {
-                // Convert to PNG data
-                NSBitmapImageRep *imageRep = [[NSBitmapImageRep alloc] initWithCGImage:thumbnailImage];
-                NSData *pngData = [imageRep representationUsingType:NSBitmapImageFileTypePNG properties:@{}];
-                
-                if (pngData) {
-                    // Convert to Base64
-                    NSString *base64String = [pngData base64EncodedStringWithOptions:0];
-                    std::string base64Std = [base64String UTF8String];
-                    
-                    CGImageRelease(thumbnailImage);
-                    CGContextRelease(context);
-                    CGColorSpaceRelease(colorSpace);
-                    CGImageRelease(displayImage);
-                    
-                    return Napi::String::New(env, base64Std);
-                }
-                
-                CGImageRelease(thumbnailImage);
-            }
-            
+        if (!context) {
+            NSLog(@"Failed to create bitmap context");
+            CGImageRelease(displayImage);
+            CGColorSpaceRelease(colorSpace);
+            return env.Null();
+        }
+        
+        // Set interpolation quality for better scaling
+        CGContextSetInterpolationQuality(context, kCGInterpolationHigh);
+        
+        // Draw the image
+        CGContextDrawImage(context, CGRectMake(0, 0, thumbnailWidth, thumbnailHeight), displayImage);
+        CGImageRef thumbnailImage = CGBitmapContextCreateImage(context);
+        
+        if (!thumbnailImage) {
+            NSLog(@"Failed to create thumbnail image");
+            CGContextRelease(context);
+            CGImageRelease(displayImage);
+            CGColorSpaceRelease(colorSpace);
+            return env.Null();
+        }
+        
+        // Convert to PNG data
+        NSBitmapImageRep *imageRep = [[NSBitmapImageRep alloc] initWithCGImage:thumbnailImage];
+        NSDictionary *properties = @{NSImageCompressionFactor: @0.8};
+        NSData *pngData = [imageRep representationUsingType:NSBitmapImageFileTypePNG properties:properties];
+        
+        if (!pngData) {
+            NSLog(@"Failed to convert image to PNG data");
+            CGImageRelease(thumbnailImage);
             CGContextRelease(context);
+            CGImageRelease(displayImage);
+            CGColorSpaceRelease(colorSpace);
+            return env.Null();
         }
         
+        // Convert to Base64
+        NSString *base64String = [pngData base64EncodedStringWithOptions:0];
+        std::string base64Std = [base64String UTF8String];
+        
+        NSLog(@"Successfully created thumbnail with base64 length: %lu", (unsigned long)base64Std.length());
+        
+        // Cleanup
+        CGImageRelease(thumbnailImage);
+        CGContextRelease(context);
         CGColorSpaceRelease(colorSpace);
         CGImageRelease(displayImage);
         
-        return env.Null();
+        return Napi::String::New(env, base64Std);
         
     } @catch (NSException *exception) {
+        NSLog(@"Exception in GetDisplayThumbnail: %@", exception);
         return env.Null();
     }
 }

package/src/screen_capture.h

@@ -0,0 +1,19 @@
+#ifndef SCREEN_CAPTURE_H
+#define SCREEN_CAPTURE_H
+
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+
+@interface ScreenCapture : NSObject
+
++ (NSArray *)getAvailableDisplays;
++ (BOOL)captureDisplay:(CGDirectDisplayID)displayID 
+                toFile:(NSString *)filePath 
+                  rect:(CGRect)rect
+           includeCursor:(BOOL)includeCursor;
++ (CGImageRef)createScreenshotFromDisplay:(CGDirectDisplayID)displayID 
+                                     rect:(CGRect)rect;
+
+@end
+
+#endif // SCREEN_CAPTURE_H