[Tizen.Applications][Non-ACR] Add ApplicationManager internal apis (#7420)

* [Tizen.Applications][Non-ACR] Add ApplicationManager internal apis

ApplicationLifecycleStateChanged EventHandler has been added.

Adds:
 - ApplicationLifecycleStateChanged

* Add exception description

Signed-off-by: Changgyu Choi <changyu.choi@samsung.com>

Author: upple

src/Tizen.Applications.Common/Interop/Interop.ApplicationManager.cs

@@ -71,6 +71,19 @@ internal enum AppInfoAppComponentType
             WatchApp = 3
         }
 
+        internal enum AppLifecycleState
+        {
+            Initialized = 0,
+            Created = 1,
+            Resumed = 2,
+            Paused = 3,
+            Destroyed = 4
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void AppManagerLifecycleStateChangedCallback(string appId, int pid, AppLifecycleState state, bool hasFocus, IntPtr userData);
+        //void (*app_manager_lifecycle_state_changed_cb)(const char *app_id, pid_t pid, app_manager_lifecycle_state_e state, bool has_focus, void *user_data)
+
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         internal delegate void AppManagerEventCallback(string appType, string appId, AppManagerEventType eventType, AppManagerEventState eventState, IntPtr eventHandle, IntPtr userData);
         //void(* app_manager_event_cb)(const char *type, const char *app_id, app_manager_event_type_e event_type, app_manager_event_state_e event_state, app_manager_event_h handle, void *user_data)
@@ -111,6 +124,14 @@ internal enum AppInfoAppComponentType
         internal static extern void AppManagerUnSetAppContextEvent();
         //void app_manager_unset_app_context_event_cb (void);
 
+        [DllImport(Libraries.AppManager, EntryPoint = "app_manager_set_lifecycle_state_changed_cb")]
+        internal static extern ErrorCode AppManagerSetLifecycleStateChangedCb(AppManagerLifecycleStateChangedCallback callback, IntPtr userData);
+        //int app_manager_set_lifecycle_state_changed_cb(app_manager_lifecycle_state_changed_cb callback, void *user_data)
+
+        [DllImport(Libraries.AppManager, EntryPoint = "app_manager_unset_lifecycle_state_changed_cb")]
+        internal static extern void AppManagerUnsetLifecycleStateChangedCb();
+        //void app_manager_unset_lifecycle_state_changed_cb(void)
+
         [DllImport(Libraries.AppManager, EntryPoint = "app_manager_foreach_running_app_context")]
         internal static extern ErrorCode AppManagerForeachRunningAppContext(AppManagerAppContextCallback callback, IntPtr userData);
         //int app_manager_foreach_running_app_context(app_manager_app_context_cb callback, void *user_data)

src/Tizen.Applications.Common/Tizen.Applications/ApplicationManager.cs

@@ -22,6 +22,51 @@
 
 namespace Tizen.Applications
 {
+    /// <summary>
+    /// Enumeration for application lifecycle state.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public enum ApplicationLifecycleState
+    {
+        /// <summary>The application is initialized.</summary>
+        Initialized = 0,
+        /// <summary>The application is created.</summary>
+        Created = 1,
+        /// <summary>The application is resumed.</summary>
+        Resumed = 2,
+        /// <summary>The application is paused.</summary>
+        Paused = 3,
+        /// <summary>The application is destroyed.</summary>
+        Destroyed = 4
+    }
+
+    /// <summary>
+    /// Event arguments for application lifecycle state changed event.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public class ApplicationLifecycleStateChangedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Gets the application ID.
+        /// </summary>
+        public string ApplicationId { get; internal set; }
+
+        /// <summary>
+        /// Gets the process ID.
+        /// </summary>
+        public int ProcessId { get; internal set; }
+
+        /// <summary>
+        /// Gets the lifecycle state.
+        /// </summary>
+        public ApplicationLifecycleState State { get; internal set; }
+
+        /// <summary>
+        /// Gets whether the application has focus.
+        /// </summary>
+        public bool HasFocus { get; internal set; }
+    }
+
     /// <summary>
     /// This class has the methods and events of the ApplicationManager.
     /// </summary>
@@ -38,6 +83,9 @@ public static class ApplicationManager
         private static IntPtr _eventHandle = IntPtr.Zero;
         private static readonly object s_eventLock = new object();
         private static readonly object s_applicationChangedEventLock = new object();
+        private static EventHandler<ApplicationLifecycleStateChangedEventArgs> s_lifecycleStateChangedHandler;
+        private static Interop.ApplicationManager.AppManagerLifecycleStateChangedCallback s_lifecycleStateChangedCallback;
+        private static readonly object s_lifecycleStateChangedLock = new object();
 
         /// <summary>
         /// Occurs whenever the installed application is enabled.
@@ -687,6 +735,85 @@ private static void UnRegisterApplicationEvent()
             }
         }
 
+        /// <summary>
+        /// Occurs when the lifecycle state of any application changes.
+        /// </summary>
+        /// <remarks>
+        /// This event is raised whenever the lifecycle state of any application changes.
+        /// It provides information about the application whose lifecycle state has changed.
+        /// </remarks>
+        /// <exception cref="ArgumentException">Thrown when failed of invalid argument.</exception>
+        /// <exception cref="InvalidOperationException">Thrown when failed to register the lifecycle state changed event.</exception>
+        /// <example>
+        /// The following code snippet demonstrates how to subscribe to the ApplicationLifecycleStateChanged event:
+        ///
+        /// <code>
+        /// ApplicationManager.ApplicationLifecycleStateChanged += (sender, e) =>
+        /// {
+        ///     Console.WriteLine($"Application {e.ApplicationId} (PID: {e.ProcessId}) state changed to {e.State}");
+        ///     Console.WriteLine($"Has focus: {e.HasFocus}");
+        /// };
+        /// </code>
+        /// </example>
+        /// <since_tizen> 13 </since_tizen>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public static event EventHandler<ApplicationLifecycleStateChangedEventArgs> ApplicationLifecycleStateChanged
+        {
+            add
+            {
+                lock (s_lifecycleStateChangedLock)
+                {
+                    if (s_lifecycleStateChangedCallback == null)
+                    {
+                        RegisterLifecycleStateChangedEvent();
+                    }
+                    s_lifecycleStateChangedHandler += value;
+                }
+            }
+            remove
+            {
+                lock (s_lifecycleStateChangedLock)
+                {
+                    s_lifecycleStateChangedHandler -= value;
+                    if (s_lifecycleStateChangedHandler == null && s_lifecycleStateChangedCallback != null)
+                    {
+                        UnRegisterLifecycleStateChangedEvent();
+                        s_lifecycleStateChangedCallback = null;
+                    }
+                }
+            }
+        }
+
+        private static void RegisterLifecycleStateChangedEvent()
+        {
+            s_lifecycleStateChangedCallback = (string appId, int pid,
+                Interop.ApplicationManager.AppLifecycleState state, bool hasFocus, IntPtr userData) =>
+            {
+                lock (s_lifecycleStateChangedLock)
+                {
+                    s_lifecycleStateChangedHandler?.Invoke(null, new ApplicationLifecycleStateChangedEventArgs
+                    {
+                        ApplicationId = appId,
+                        ProcessId = pid,
+                        State = (ApplicationLifecycleState)state,
+                        HasFocus = hasFocus
+                    });
+                }
+            };
+
+            Interop.ApplicationManager.ErrorCode err =
+                Interop.ApplicationManager.AppManagerSetLifecycleStateChangedCb(s_lifecycleStateChangedCallback, IntPtr.Zero);
+            if (err != Interop.ApplicationManager.ErrorCode.None)
+            {
+                throw ApplicationManagerErrorFactory.GetException(err, "Failed to register the lifecycle state changed event.");
+            }
+        }
+
+        private static void UnRegisterLifecycleStateChangedEvent()
+        {
+            Interop.ApplicationManager.AppManagerUnsetLifecycleStateChangedCb();
+        }
+
         /// <summary>
         /// Gets the information of the recent applications.
         /// </summary>