@shopware-ag/dive 1.18.5 → 1.19.1-beta.0

package/src/ar/AR.ts

@@ -1,49 +1,40 @@
-import { DIVEInfo, WebXRUnsupportedReason } from '../info/Info';
-import { DIVEARQuickLook } from './arquicklook/ARQuickLook';
-import { DIVEWebXR } from './webxr/WebXR';
-import { type DIVEScene } from '../scene/Scene';
-import { type DIVERenderer } from '../renderer/Renderer';
-import DIVEOrbitControls from '../controls/OrbitControls';
-import { DIVESceneViewer } from './sceneviewer/SceneViewer';
-
-export type DIVEAROptions = {
+import { SystemInfo } from '../info/Info';
+import { ESystem } from '../types/info';
+import { ARQuickLook } from './arquicklook/ARQuickLook';
+import { SceneViewer } from './sceneviewer/SceneViewer';
+
+/**
+ * Options for configuring the AR system behavior
+ */
+export type ARSystemOptions = {
+    /** The placement orientation for AR content - either horizontal or vertical */
     arPlacement: 'horizontal' | 'vertical';
+    /** The scaling behavior for AR content - either automatic or fixed */
     arScale: 'auto' | 'fixed';
-    /**
-     * experimental, currently deactivated
-     */
-    useWebXR: false;
 };
 
-export class DIVEAR {
-    private _renderer: DIVERenderer;
-    private _scene: DIVEScene;
-    private _controller: DIVEOrbitControls;
-
-    constructor(
-        renderer: DIVERenderer,
-        scene: DIVEScene,
-        controller: DIVEOrbitControls,
-    ) {
-        this._renderer = renderer;
-        this._scene = scene;
-        this._controller = controller;
-    }
-
-    public async Launch(options?: DIVEAROptions): Promise<void> {
-        const system = DIVEInfo.GetSystem();
+/**
+ * Main class for handling AR functionality across different platforms
+ * Provides methods to launch AR experiences using platform-specific implementations
+ */
+export class ARSystem {
+    /**
+     * Launches an AR experience using the appropriate platform-specific implementation
+     *
+     * @param uri - The URI of the 3D model to display in AR
+     * @param options - Optional configuration for the AR experience
+     * @returns Promise that resolves when AR is launched successfully
+     * @throws Error if AR is not supported on the current platform
+     */
+    public async launch(uri: string, options?: ARSystemOptions): Promise<void> {
+        const system = SystemInfo.GetSystem();
 
-        if (system === 'iOS') {
-            return this.tryARQuickLook();
+        if (system === ESystem.IOS) {
+            return this.tryARQuickLook(uri, options);
         }
 
-        if (system === 'Android') {
-            if (options?.useWebXR) {
-                console.warn('DIVE: WebXR is experimental on Android.');
-                return this.tryWebXR();
-            }
-
-            return this.trySceneViewer();
+        if (system === ESystem.ANDROID) {
+            return this.trySceneViewer(uri, options);
         }
 
         console.log(
@@ -51,48 +42,60 @@ export class DIVEAR {
                 system +
                 ')',
         );
+        return Promise.reject(
+            new Error('AR not supported on non-mobile systems'),
+        );
     }
 
-    private async tryARQuickLook(options?: DIVEAROptions): Promise<void> {
-        const support = DIVEInfo.GetSupportsARQuickLook();
+    /**
+     * Attempts to launch AR using ARQuickLook (iOS-specific implementation)
+     *
+     * @param uri - The URI of the 3D model to display in AR
+     * @param options - Optional configuration for the AR experience
+     * @returns Promise that resolves when ARQuickLook is launched successfully
+     * @throws Error if ARQuickLook is not supported on the device
+     */
+    private async tryARQuickLook(
+        uri: string,
+        options?: ARSystemOptions,
+    ): Promise<void> {
+        const support = SystemInfo.GetSupportsARQuickLook();
         if (!support) {
             console.log('ARQuickLook not supported');
-            return Promise.reject();
+            return Promise.reject(new Error('ARQuickLook not supported'));
         }
 
         console.log('DIVE: Launching AR with ARQuickLook ...');
 
-        // Launch ARQuickLook
-        await DIVEARQuickLook.Launch(this._scene, options);
-        return Promise.resolve();
-    }
-
-    private async tryWebXR(): Promise<void> {
-        const support = await DIVEInfo.GetSupportsWebXR();
-        if (!support) {
-            console.log(
-                'WebXR not supported. Reason: ' +
-                    WebXRUnsupportedReason[
-                        DIVEInfo.GetWebXRUnsupportedReason()!
-                    ],
-            );
-            return Promise.reject();
+        try {
+            return new ARQuickLook().launch(uri, options);
+        } catch (error) {
+            console.error('Error launching ARQuickLook:', error);
+            return Promise.reject(error);
         }
-
-        console.log('DIVE: Launching AR with WebXR ...');
-        // Launch WebXR
-        await DIVEWebXR.Launch(this._renderer, this._scene, this._controller);
-        return Promise.resolve();
     }
 
-    private async trySceneViewer(options?: DIVEAROptions): Promise<void> {
-        // actually we don't have to try here, because SceneViewer is supported on all devices by now.
-        // if there are no AR services (ARCore) installed on the device, SceneViewer will only show the model in 3D.
-        // we also have no options to detect if SceneViewer is supported.
-
+    /**
+     * Launches AR using SceneViewer (Android-specific implementation)
+     * Note: SceneViewer is supported on all Android devices. If ARCore is not installed,
+     * the model will be displayed in 3D view mode instead of AR mode.
+     *
+     * @param uri - The URI of the 3D model to display in AR
+     * @param options - Optional configuration for the AR experience
+     * @returns Promise that resolves when SceneViewer is launched successfully
+     * @throws Error if there's an issue launching SceneViewer
+     */
+    private async trySceneViewer(
+        uri: string,
+        options?: ARSystemOptions,
+    ): Promise<void> {
         console.log('DIVE: Launching AR with SceneViewer ...');
 
-        DIVESceneViewer.Launch(this._scene, options);
-        return Promise.resolve();
+        try {
+            return new SceneViewer().launch(uri, options);
+        } catch (error) {
+            console.error('Error launching SceneViewer:', error);
+            return Promise.reject(error);
+        }
     }
 }

package/src/ar/__test__/AR.test.ts

@@ -1,187 +1,276 @@
-import { DIVEAR, type DIVEAROptions } from '../AR';
-import { DIVEInfo } from '../../info/Info';
-import { DIVERenderer } from '../../renderer/Renderer';
-import { DIVEScene } from '../../scene/Scene';
-import DIVEOrbitControls from '../../controls/OrbitControls';
-import { DIVEARQuickLook } from '../arquicklook/ARQuickLook';
-import { DIVESceneViewer } from '../sceneviewer/SceneViewer';
-import { DIVEWebXR } from '../webxr/WebXR';
-
-jest.mock('../arquicklook/ARQuickLook', () => ({
-    DIVEARQuickLook: {
-        Launch: jest.fn(),
+import { ARSystem, type ARSystemOptions } from '../AR';
+import { SystemInfo } from '../../info/Info';
+import { ARQuickLook } from '../arquicklook/ARQuickLook';
+import { SceneViewer } from '../sceneviewer/SceneViewer';
+
+// Mock Info
+jest.mock('../../info/Info', () => ({
+    SystemInfo: {
+        GetSystem: jest.fn(),
+        GetSupportsARQuickLook: jest.fn(),
     },
 }));
 
-jest.mock('../webxr/WebXR', () => ({
-    DIVEWebXR: {
-        Launch: jest.fn(),
-    },
+// Mock ARQuickLook
+const mockLaunchARQuickLook = jest.fn().mockResolvedValue(undefined);
+jest.mock('../arquicklook/ARQuickLook', () => ({
+    ARQuickLook: jest.fn().mockImplementation(() => ({
+        launch: mockLaunchARQuickLook,
+    })),
 }));
 
+// Mock SceneViewer
+const mockSceneViewerLaunch = jest.fn().mockResolvedValue(undefined);
 jest.mock('../sceneviewer/SceneViewer', () => ({
-    DIVESceneViewer: {
-        Launch: jest.fn(),
-    },
+    SceneViewer: jest.fn().mockImplementation(() => ({
+        launch: mockSceneViewerLaunch,
+    })),
 }));
 
-describe('DIVEAR', () => {
-    let renderer: DIVERenderer;
-    let scene: DIVEScene;
-    let controller: DIVEOrbitControls;
-    let diveAR: DIVEAR;
+describe('ARSystem', () => {
+    let diveAR: ARSystem;
+    const mockUri = 'https://example.com/model.glb';
 
     beforeEach(() => {
-        renderer = {} as DIVERenderer;
-        scene = {} as DIVEScene;
-        controller = {} as DIVEOrbitControls;
-        diveAR = new DIVEAR(renderer, scene, controller);
+        diveAR = new ARSystem();
+        jest.clearAllMocks();
     });
 
-    describe('Launch', () => {
+    describe('launch', () => {
         describe('AR Quick Look', () => {
             it('should launch ARQuickLook on iOS', async () => {
-                jest.spyOn(DIVEInfo, 'GetSystem').mockReturnValue('iOS');
-                jest.spyOn(DIVEInfo, 'GetSupportsARQuickLook').mockReturnValue(
-                    true,
-                );
-                const arQuickLookLaunchSpy = jest.spyOn(
-                    DIVEARQuickLook,
-                    'Launch',
-                );
+                (SystemInfo.GetSystem as jest.Mock).mockReturnValue('iOS');
+                (
+                    SystemInfo.GetSupportsARQuickLook as jest.Mock
+                ).mockReturnValue(true);
 
                 const consoleLogSpy = jest
                     .spyOn(console, 'log')
                     .mockImplementation();
 
-                await diveAR.Launch();
+                await diveAR.launch(mockUri);
 
-                expect(arQuickLookLaunchSpy).toHaveBeenCalledWith(
-                    scene,
+                expect(mockLaunchARQuickLook).toHaveBeenCalledWith(
+                    mockUri,
                     undefined,
                 );
-                arQuickLookLaunchSpy.mockRestore();
+                expect(consoleLogSpy).toHaveBeenCalledWith(
+                    'DIVE: Launching AR with ARQuickLook ...',
+                );
+                consoleLogSpy.mockRestore();
+            });
+
+            it('should launch ARQuickLook on iOS with options', async () => {
+                (SystemInfo.GetSystem as jest.Mock).mockReturnValue('iOS');
+                (
+                    SystemInfo.GetSupportsARQuickLook as jest.Mock
+                ).mockReturnValue(true);
 
-                expect(consoleLogSpy).toHaveBeenCalled();
+                const options: ARSystemOptions = {
+                    arPlacement: 'vertical',
+                    arScale: 'fixed',
+                };
+
+                const consoleLogSpy = jest
+                    .spyOn(console, 'log')
+                    .mockImplementation();
+
+                await diveAR.launch(mockUri, options);
+
+                expect(mockLaunchARQuickLook).toHaveBeenCalledWith(
+                    mockUri,
+                    options,
+                );
+                expect(consoleLogSpy).toHaveBeenCalledWith(
+                    'DIVE: Launching AR with ARQuickLook ...',
+                );
                 consoleLogSpy.mockRestore();
             });
 
             it('should not launch ARQuickLook on iOS if not supported', async () => {
-                jest.spyOn(DIVEInfo, 'GetSystem').mockReturnValue('iOS');
-                jest.spyOn(DIVEInfo, 'GetSupportsARQuickLook').mockReturnValue(
-                    false,
+                (SystemInfo.GetSystem as jest.Mock).mockReturnValue('iOS');
+                (
+                    SystemInfo.GetSupportsARQuickLook as jest.Mock
+                ).mockReturnValue(false);
+
+                const consoleLogSpy = jest
+                    .spyOn(console, 'log')
+                    .mockImplementation();
+
+                try {
+                    await diveAR.launch(mockUri);
+                    fail('Expected launch to reject');
+                } catch (error: unknown) {
+                    if (error instanceof Error) {
+                        expect(error.message).toBe('ARQuickLook not supported');
+                    } else {
+                        fail('Expected error to be an Error instance');
+                    }
+                }
+                expect(consoleLogSpy).toHaveBeenCalledWith(
+                    'ARQuickLook not supported',
                 );
-                const arQuickLookLaunchSpy = jest.spyOn(
-                    DIVEARQuickLook,
-                    'Launch',
+                consoleLogSpy.mockRestore();
+            });
+
+            it('should handle ARQuickLook launch errors', async () => {
+                (SystemInfo.GetSystem as jest.Mock).mockReturnValue('iOS');
+                (
+                    SystemInfo.GetSupportsARQuickLook as jest.Mock
+                ).mockReturnValue(true);
+
+                const mockError = new Error('Launch failed');
+                const mockInstance = {
+                    launch: jest.fn().mockImplementation(() => {
+                        throw mockError;
+                    }),
+                };
+                (ARQuickLook as jest.Mock).mockImplementation(
+                    () => mockInstance,
                 );
 
                 const consoleLogSpy = jest
                     .spyOn(console, 'log')
                     .mockImplementation();
+                const consoleErrorSpy = jest
+                    .spyOn(console, 'error')
+                    .mockImplementation();
 
-                await diveAR.Launch().catch(() => {});
-
-                expect(arQuickLookLaunchSpy).not.toHaveBeenCalled();
-                arQuickLookLaunchSpy.mockRestore();
+                try {
+                    await diveAR.launch(mockUri);
+                    fail('Expected launch to reject');
+                } catch (error: unknown) {
+                    if (error instanceof Error) {
+                        expect(error.message).toBe('Launch failed');
+                    } else {
+                        fail('Expected error to be an Error instance');
+                    }
+                }
+
+                expect(consoleLogSpy).toHaveBeenCalledWith(
+                    'DIVE: Launching AR with ARQuickLook ...',
+                );
+                expect(consoleErrorSpy).toHaveBeenCalledWith(
+                    'Error launching ARQuickLook:',
+                    mockError,
+                );
 
-                expect(consoleLogSpy).toHaveBeenCalled();
                 consoleLogSpy.mockRestore();
+                consoleErrorSpy.mockRestore();
             });
         });
 
         describe('Scene Viewer', () => {
             it('should launch SceneViewer on Android', async () => {
-                jest.spyOn(DIVEInfo, 'GetSystem').mockReturnValue('Android');
+                (SystemInfo.GetSystem as jest.Mock).mockReturnValue('Android');
 
                 const consoleLogSpy = jest
                     .spyOn(console, 'log')
                     .mockImplementation();
 
-                await diveAR.Launch();
+                await diveAR.launch(mockUri);
 
-                expect(DIVESceneViewer.Launch).toHaveBeenCalledWith(
-                    scene,
+                expect(mockSceneViewerLaunch).toHaveBeenCalledWith(
+                    mockUri,
                     undefined,
                 );
-
-                expect(consoleLogSpy).toHaveBeenCalled();
+                expect(consoleLogSpy).toHaveBeenCalledWith(
+                    'DIVE: Launching AR with SceneViewer ...',
+                );
                 consoleLogSpy.mockRestore();
             });
-        });
 
-        describe('WebXR', () => {
-            it('should launch WebXR on Android with useWebXR option', async () => {
-                jest.spyOn(DIVEInfo, 'GetSystem').mockReturnValue('Android');
-                jest.spyOn(DIVEInfo, 'GetSupportsWebXR').mockResolvedValue(
-                    true,
-                );
+            it('should launch SceneViewer on Android with options', async () => {
+                (SystemInfo.GetSystem as jest.Mock).mockReturnValue('Android');
+
+                const options: ARSystemOptions = {
+                    arPlacement: 'vertical',
+                    arScale: 'fixed',
+                };
 
                 const consoleLogSpy = jest
                     .spyOn(console, 'log')
                     .mockImplementation();
-                const consoleWarnSpy = jest
-                    .spyOn(console, 'warn')
-                    .mockImplementation();
 
-                await diveAR.Launch({
-                    useWebXR: true,
-                } as unknown as DIVEAROptions);
+                await diveAR.launch(mockUri, options);
 
-                expect(DIVEWebXR.Launch).toHaveBeenCalledWith(
-                    renderer,
-                    scene,
-                    controller,
+                expect(mockSceneViewerLaunch).toHaveBeenCalledWith(
+                    mockUri,
+                    options,
+                );
+                expect(consoleLogSpy).toHaveBeenCalledWith(
+                    'DIVE: Launching AR with SceneViewer ...',
                 );
-                expect(consoleWarnSpy).toHaveBeenCalled();
-                consoleWarnSpy.mockRestore();
-
-                expect(consoleLogSpy).toHaveBeenCalled();
                 consoleLogSpy.mockRestore();
             });
 
-            it('should not launch WebXR on Android with useWebXR option', async () => {
-                jest.spyOn(DIVEInfo, 'GetSystem').mockReturnValue('Android');
-                jest.spyOn(DIVEInfo, 'GetSupportsWebXR').mockResolvedValue(
-                    false,
+            it('should handle SceneViewer launch errors', async () => {
+                (SystemInfo.GetSystem as jest.Mock).mockReturnValue('Android');
+
+                const mockError = new Error('Launch failed');
+                const mockInstance = {
+                    launch: jest.fn().mockImplementation(() => {
+                        throw mockError;
+                    }),
+                };
+                (SceneViewer as jest.Mock).mockImplementation(
+                    () => mockInstance,
                 );
 
                 const consoleLogSpy = jest
                     .spyOn(console, 'log')
                     .mockImplementation();
-                const consoleWarnSpy = jest
-                    .spyOn(console, 'warn')
+                const consoleErrorSpy = jest
+                    .spyOn(console, 'error')
                     .mockImplementation();
 
-                await diveAR
-                    .Launch({
-                        useWebXR: true,
-                    } as unknown as DIVEAROptions)
-                    .catch(() => {});
-
-                expect(DIVEWebXR.Launch).toHaveBeenCalledWith(
-                    renderer,
-                    scene,
-                    controller,
+                try {
+                    await diveAR.launch(mockUri);
+                    fail('Expected launch to reject');
+                } catch (error: unknown) {
+                    if (error instanceof Error) {
+                        expect(error.message).toBe('Launch failed');
+                    } else {
+                        fail('Expected error to be an Error instance');
+                    }
+                }
+
+                expect(consoleLogSpy).toHaveBeenCalledWith(
+                    'DIVE: Launching AR with SceneViewer ...',
+                );
+                expect(consoleErrorSpy).toHaveBeenCalledWith(
+                    'Error launching SceneViewer:',
+                    mockError,
                 );
-                expect(consoleWarnSpy).toHaveBeenCalled();
-                consoleWarnSpy.mockRestore();
 
-                expect(consoleLogSpy).toHaveBeenCalled();
                 consoleLogSpy.mockRestore();
+                consoleErrorSpy.mockRestore();
             });
         });
 
-        it('should log AR not supported on non-mobile systems', async () => {
+        it('should reject on non-mobile systems', async () => {
+            (SystemInfo.GetSystem as jest.Mock).mockReturnValue('Windows');
+
             const consoleLogSpy = jest
                 .spyOn(console, 'log')
                 .mockImplementation();
 
-            jest.spyOn(DIVEInfo, 'GetSystem').mockReturnValue('Windows');
-
-            await diveAR.Launch();
-
-            expect(consoleLogSpy).toHaveBeenCalled();
+            try {
+                await diveAR.launch(mockUri);
+                fail('Expected launch to reject');
+            } catch (error: unknown) {
+                if (error instanceof Error) {
+                    expect(error.message).toBe(
+                        'AR not supported on non-mobile systems',
+                    );
+                } else {
+                    fail('Expected error to be an Error instance');
+                }
+            }
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                'DIVE: AR not supported. Not a mobile system. (System is Windows)',
+            );
+            consoleLogSpy.mockRestore();
         });
     });
 });

package/src/ar/arquicklook/ARQuickLook.ts

@@ -1,20 +1,39 @@
-import { type DIVEScene } from '../../scene/Scene';
-import { type DIVEAROptions } from '../AR';
-
-export class DIVEARQuickLook {
-    public static Launch(
-        scene: DIVEScene,
-        options?: DIVEAROptions,
-    ): Promise<void> {
-        const url = this.findARQuickLookSrc(scene);
+import { type ARSystemOptions } from '../AR';
+import { Converter } from '../../converter/Converter';
+import { type USDZExporterOptions } from '../../types';
+
+export class ARQuickLook {
+    public async launch(uri: string, options?: ARSystemOptions): Promise<void> {
+        const usdzUrl = await this.convertToUSDZ(uri, options);
+        return this.launchARQuickLook(usdzUrl, options);
+    }
 
-        // launch ARQuickLook
-        return this.launchARQuickLook(url, options);
+    private async convertToUSDZ(
+        uri: string,
+        options?: ARSystemOptions,
+    ): Promise<string> {
+        // Convert the file to USDZ format
+        const usdzBuffer = await Converter.convert(uri).to('usdz', {
+            quickLookCompatible: true,
+            ar: {
+                anchoring: { type: 'plane' },
+                planeAnchoring: {
+                    alignment:
+                        options?.arPlacement === 'vertical'
+                            ? 'vertical'
+                            : 'horizontal',
+                },
+            },
+        } as USDZExporterOptions);
+
+        // Create a blob from the USDZ buffer
+        const blob = new Blob([usdzBuffer], { type: 'model/vnd.usdz+zip' });
+        return URL.createObjectURL(blob);
     }
 
-    private static launchARQuickLook(
+    private launchARQuickLook(
         uri: string,
-        options?: DIVEAROptions,
+        options?: ARSystemOptions,
     ): Promise<void> {
         return new Promise((resolve) => {
             if (options?.arScale === 'fixed') {
@@ -31,63 +50,4 @@ export class DIVEARQuickLook {
             a.click();
         });
     }
-
-    private static findARQuickLookSrc(scene: DIVEScene): string {
-        let uri: string | null = null;
-
-        scene.traverse((object) => {
-            if (uri) return;
-            if (object.userData.uri) {
-                uri = object.userData.uri;
-            }
-        });
-
-        if (!uri) {
-            throw new Error('No model found in scene');
-        }
-
-        return uri;
-    }
-
-    // private static extractModels(scene: DIVEScene): Object3D[] {
-    //     // extract models
-    //     return scene.Root.children;
-    // }
-
-    // private static launchARFromNode(
-    //     node: Object3D,
-    //     options?: DIVEAROptions,
-    // ): Promise<void> {
-    //     // bundle USDZ
-    //     return this._usdzExporter
-    //         .parse(node, {
-    //             quickLookCompatible: true,
-    //             ar: {
-    //                 anchoring: { type: 'plane' },
-    //                 planeAnchoring: {
-    //                     alignment:
-    //                         options?.arPlacement === 'vertical'
-    //                             ? 'vertical'
-    //                             : 'horizontal',
-    //                 },
-    //             },
-    //         })
-    //         .then((usdz: Uint8Array) => {
-    //             // create blob
-    //             const blob = new Blob([usdz], { type: 'model/vnd.usdz+zip' });
-    //             let url = URL.createObjectURL(blob);
-
-    //             if (options?.arScale === 'fixed') {
-    //                 url = url.concat('#allowsContentScaling=0');
-    //             }
-
-    //             // launch ARQuickLook
-    //             const a = document.createElement('a');
-    //             a.innerHTML = '<picture></picture>'; // This is actually needed so the viewer opens instantly
-    //             a.rel = 'ar';
-    //             a.href = url;
-    //             a.download = 'scene.usdz';
-    //             a.click();
-    //         });
-    // }
 }