[NUI.Scene3D] Add capture to Scene3D.SceneView

src/Tizen.NUI.Scene3D/src/internal/Interop/Interop.SceneView.cs

@@ -117,6 +117,15 @@ internal static partial class SceneView
 
             [global::System.Runtime.InteropServices.DllImport(Libraries.Scene3D, EntryPoint = "CSharp_Dali_SceneView_CameraTransitionFinishedSignal_Disconnect")]
             public static extern void CameraTransitionFinishedDisconnect(global::System.Runtime.InteropServices.HandleRef actor, global::System.Runtime.InteropServices.HandleRef handler);
+
+            [global::System.Runtime.InteropServices.DllImport(Libraries.Scene3D, EntryPoint = "CSharp_Dali_SceneView_Capture")]
+            public static extern int Capture(global::System.Runtime.InteropServices.HandleRef sceneView, global::System.Runtime.InteropServices.HandleRef camera, global::System.Runtime.InteropServices.HandleRef size);
+
+            [global::System.Runtime.InteropServices.DllImport(Libraries.Scene3D, EntryPoint = "CSharp_Dali_SceneView_CaptureFinishedSignal_Connect")]
+            public static extern void CaptureFinishedConnect(global::System.Runtime.InteropServices.HandleRef actor, global::System.Runtime.InteropServices.HandleRef handler);
+
+            [global::System.Runtime.InteropServices.DllImport(Libraries.Scene3D, EntryPoint = "CSharp_Dali_SceneView_CaptureFinishedSignal_Disconnect")]
+            public static extern void CaptureFinishedDisconnect(global::System.Runtime.InteropServices.HandleRef actor, global::System.Runtime.InteropServices.HandleRef handler);
         }
     }
 }

src/Tizen.NUI.Scene3D/src/public/Controls/CaptureFinishedEventArgs.cs

@@ -0,0 +1,48 @@
+/*
+ * Copyright(c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+using System;
+using System.ComponentModel;
+
+namespace Tizen.NUI.Scene3D
+{
+    /// <summary>
+    /// Event arguments of SceneView capture finished event.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public class CaptureFinishedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Integer ID of the capture request.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public int CaptureId
+        {
+            get; set;
+        }
+
+        /// <summary>
+        /// ImageUrl of the captured result
+        /// If the capture is failed, it is null.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public ImageUrl CapturedImageUrl
+        {
+            get; set;
+        }
+    }
+}

src/Tizen.NUI.Scene3D/src/public/Controls/SceneView.cs

@@ -22,6 +22,9 @@
 using Tizen.NUI;
 using Tizen.NUI.Binding;
 using Tizen.NUI.BaseComponents;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Diagnostics;
 
 namespace Tizen.NUI.Scene3D
 {
@@ -68,14 +71,24 @@ namespace Tizen.NUI.Scene3D
     /// <since_tizen> 10 </since_tizen>
     public class SceneView : View
     {
+        private Dictionary<int, TaskCompletionSource<ImageUrl>> asyncCaptureIds = new();
         private string skyboxUrl;
 
+        // CameraTransitionFinishedEvent
         private EventHandler cameraTransitionFinishedEventHandler;
         private CameraTransitionFinishedEventCallbackType cameraTransitionFinishedEventCallback;
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         private delegate void CameraTransitionFinishedEventCallbackType(IntPtr data);
 
+        // CaptureFinishedEvent
+        private EventHandler<CaptureFinishedEventArgs> captureFinishedEventHandler;
+        private EventHandler<CaptureFinishedEventArgs> asyncCaptureFinishedEventHandler;
+        private CaptureFinishedEventCallbackType captureFinishedEventCallback;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void CaptureFinishedEventCallbackType(IntPtr data, int captureId, IntPtr capturedImageUrl);
+
         internal SceneView(global::System.IntPtr cPtr, bool cMemoryOwn) : this(cPtr, cMemoryOwn, cMemoryOwn)
         {
         }
@@ -104,6 +117,15 @@ protected override void Dispose(DisposeTypes type)
                 cameraTransitionFinishedEventCallback = null;
             }
 
+            if (captureFinishedEventCallback != null)
+            {
+                NUILog.Debug($"[Dispose] captureFinishedEventCallback");
+
+                Interop.SceneView.CaptureFinishedDisconnect(GetBaseHandleCPtrHandleRef, captureFinishedEventCallback.ToHandleRef(this));
+                NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+                captureFinishedEventCallback = null;
+            }
+
             LayoutCount = 0;
 
             base.Dispose(type);
@@ -170,6 +192,64 @@ public event EventHandler CameraTransitionFinished
             }
         }
 
+        /// <summary>
+        /// An event emitted when Capture is finished.
+        /// If Capture is successed, CaptureFinishedEventArgs includes finished capture ID and ImageUrl of the captured image.
+        /// If Capture is failed, the ImageUrl is null.
+        /// </summary>
+        // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public event EventHandler<CaptureFinishedEventArgs> CaptureFinished
+        {
+            add
+            {
+                if (captureFinishedEventHandler == null)
+                {
+                    captureFinishedEventCallback = OnCaptureFinished;
+                    Interop.SceneView.CaptureFinishedConnect(SwigCPtr, captureFinishedEventCallback.ToHandleRef(this));
+                    NDalicPINVOKE.ThrowExceptionIfExists();
+                }
+                captureFinishedEventHandler += value;
+            }
+
+            remove
+            {
+                captureFinishedEventHandler -= value;
+                if (captureFinishedEventHandler == null && captureFinishedEventCallback != null)
+                {
+                    Interop.SceneView.CaptureFinishedDisconnect(SwigCPtr, captureFinishedEventCallback.ToHandleRef(this));
+                    NDalicPINVOKE.ThrowExceptionIfExists();
+                    captureFinishedEventCallback = null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// An event emitted when CaptureAsync is finished.
+        /// </summary>
+        private event EventHandler<CaptureFinishedEventArgs> AsyncCaptureFinished
+        {
+            add
+            {
+                if (asyncCaptureFinishedEventHandler == null)
+                {
+                    CaptureFinished += dummy;
+                }
+                asyncCaptureFinishedEventHandler += value;
+            }
+
+            remove
+            {
+                asyncCaptureFinishedEventHandler -= value;
+                if (asyncCaptureFinishedEventHandler == null)
+                {
+                    CaptureFinished += dummy;
+                }
+            }
+        }
+
+        void dummy(object sender, CaptureFinishedEventArgs e) {}
+
         /// <summary>
         /// Set/Get the ImageBasedLight ScaleFactor.
         /// Scale factor controls light source intensity in [0.0f, 1.0f]
@@ -573,6 +653,82 @@ public void ResetResolution()
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Requests to capture this SceneView with the Camera.
+        /// When the capture is finished, CaptureFinished Event is emited.
+        /// <see cref="CaptureFinishedEventArgs"/> includes <see cref="CaptureFinishedEventArgs.CaptureId"/> and <see cref="CaptureFinishedEventArgs.CapturedImageUrl"/>.
+        /// If the capture is successful, the <see cref="CaptureFinishedEventArgs.CapturedImageUrl"/> contains url of captured image.
+        /// If the capture fails, the <see cref="CaptureFinishedEventArgs.CapturedImageUrl"/> is null.
+        /// </summary>
+        /// <param name="camera">Camera to be used for capture.</param>
+        /// <param name="size">captured size.</param>
+        /// <remarks>
+        /// The input camera should not be used for any other purpose during Capture.
+        /// (Simultaneous usage elsewhere may result in incorrect rendering.)
+        /// The camera is required to be added in this SceneView. (Not need to be a selected camera)
+        /// If the SceneView is disconnected from Scene, the left capture requests are canceled with fail.
+        /// </remarks>
+        /// <returns> capture id that id unique value to distinguish each requiest.</returns>
+        // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public int Capture(Scene3D.Camera camera, Vector2 size)
+        {
+            int id = Interop.SceneView.Capture(SwigCPtr, camera.SwigCPtr, Vector2.getCPtr(size));
+            if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+            return id;
+        }
+
+        /// <summary>
+        /// Requests to capture this SceneView with the Camera asynchronously.
+        /// </summary>
+        /// <param name="camera">Camera to be used for capture.</param>
+        /// <param name="size">captured size.</param>
+        /// <remarks>
+        /// The input camera should not be used for any other purpose during Capture.
+        /// (Simultaneous usage elsewhere may result in incorrect rendering.)
+        /// The camera is required to be added in this SceneView. (Not need to be a selected camera)
+        /// If the SceneView is disconnected from Scene, the left capture requests are canceled with fail.
+        /// </remarks>
+        /// <returns>
+        /// A task that represents the asynchronous operation. The task result contains the URL of the captured image.
+        /// If the capture is successful, the task result is the ImageURL.
+        /// If the capture fails, the task will complete with an <see cref="InvalidOperationException"/> 
+        /// </returns>
+        // This will be public opened after ACR done. (Before ACR, need to be hidden as Inhouse API)
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public Task<ImageUrl> CaptureAsync(Scene3D.Camera camera, Vector2 size)
+        {
+            void Handler(object _, CaptureFinishedEventArgs e)
+            {
+                if (asyncCaptureIds.TryGetValue(e.CaptureId, out var tcs))
+                {
+                    try
+                    {
+                        if (e.CapturedImageUrl != null)
+                        {
+                            tcs.SetResult(e.CapturedImageUrl);
+                        }
+                        else
+                        {
+                            tcs.SetException(new InvalidOperationException("Fail to Capture"));
+                        }
+                    }
+                    finally
+                    {
+                        AsyncCaptureFinished -= Handler;
+                        asyncCaptureIds.Remove(e.CaptureId);
+                    }
+                }
+            };
+
+            AsyncCaptureFinished += Handler;
+            var captureId = Interop.SceneView.Capture(SwigCPtr, camera.SwigCPtr, Vector2.getCPtr(size));
+            TaskCompletionSource<ImageUrl> ret = new TaskCompletionSource<ImageUrl>();
+            asyncCaptureIds.Add(captureId, ret);
+
+            return ret.Task;
+        }
+
         internal void SetUseFramebuffer(bool useFramebuffer)
         {
             Interop.SceneView.UseFramebuffer(SwigCPtr, useFramebuffer);
@@ -693,5 +849,25 @@ private void OnCameraTransitionFinished(IntPtr data)
         {
             cameraTransitionFinishedEventHandler?.Invoke(this, EventArgs.Empty);
         }
+
+        // Callback for capture finished signal
+        private void OnCaptureFinished(IntPtr data, int captureId, IntPtr capturedImageUrl)
+        {
+            CaptureFinishedEventArgs e = new CaptureFinishedEventArgs();
+            ImageUrl imageUrl = new ImageUrl(NUI.Interop.ImageUrl.NewImageUrl(new ImageUrl(capturedImageUrl, false).SwigCPtr), true);
+            NDalicPINVOKE.ThrowExceptionIfExists();
+
+            e.CaptureId = captureId;
+            e.CapturedImageUrl = imageUrl.HasBody() ? imageUrl : null;
+
+            if (asyncCaptureIds.ContainsKey(e.CaptureId))
+            {
+                asyncCaptureFinishedEventHandler?.Invoke(this, e);
+            }
+            else
+            {
+                captureFinishedEventHandler?.Invoke(this, e);
+            }
+        }
     }
 }

src/Tizen.NUI/src/internal/Interop/Interop.ImageUrl.cs

@@ -24,6 +24,10 @@ internal static partial class Interop
     {
         internal static partial class ImageUrl
         {
+
+            [DllImport(NDalicPINVOKE.Lib, EntryPoint = "CSharp_Dali_new_ImageUrl_Copy")]
+            public static extern global::System.IntPtr NewImageUrl(global::System.Runtime.InteropServices.HandleRef csImageUrl);
+
             [DllImport(NDalicPINVOKE.Lib, EntryPoint = "CSharp_Dali_delete_ImageUrl")]
             public static extern void Delete(HandleRef jarg1);
 

src/Tizen.NUI/src/public/BaseComponents/VisibilityChangeType.cs

@@ -34,5 +34,4 @@ public enum VisibilityChangeType
         /// <since_tizen> 3 </since_tizen>
         PARENT
     }
-
 }