[NUI] Unified EventHandler connect-disconnect code style (Phase 1)

Make we use unified code style when we connect/disconnect native signal
to C# EventHandler.

It will be reduce some copy-paste the non-common style implementation.

This PR will change below classes

* (internal)Application and it's family
* (internal)ObjectRegistry
* (internal)Builder
* (internal)GaussianBlurView
* ImageView and it's family
* View, ViewAccessibility
* Clipboard
* Capture

Signed-off-by: Eunki, Hong <eunkiki.hong@samsung.com>

diff --git a/src/Tizen.NUI/src/internal/Application/Application.cs b/src/Tizen.NUI/src/internal/Application/Application.cs
index 5e406594c7095eccac34d78c879cf507c41be635..4d775bc957952cc0c509d51342438bf80280f98f 100755 (executable)
--- a/src/Tizen.NUI/src/internal/Application/Application.cs
+++ b/src/Tizen.NUI/src/internal/Application/Application.cs
@@ -660,18 +660,25 @@ namespace Tizen.NUI
                     initSignal = this.InitSignal();
                     initSignal?.Connect(applicationInitEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.Initialized] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationInitEventHandler != null)
                 {
-                    initSignal?.Disconnect(applicationInitEventCallbackDelegate);
-                    initSignal?.Dispose();
-                    initSignal = null;
+                    applicationInitEventHandler -= value;
+                    if (applicationInitEventHandler == null)
+                    {
+                        initSignal?.Disconnect(applicationInitEventCallbackDelegate);
+                        initSignal?.Dispose();
+                        initSignal = null;
+                        applicationInitEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationInitEventHandler -= value;
             }
         }
 
@@ -724,23 +731,29 @@ namespace Tizen.NUI
                 if (applicationTerminateEventHandler == null)
                 {
                     applicationTerminateEventHandler += value;
-
                     applicationTerminateEventCallbackDelegate = new NUIApplicationTerminateEventCallbackDelegate(OnNUIApplicationTerminate);
                     terminateSignal = this.TerminateSignal();
                     terminateSignal?.Connect(applicationTerminateEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.Terminating] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationTerminateEventHandler != null)
                 {
-                    terminateSignal?.Disconnect(applicationTerminateEventCallbackDelegate);
-                    terminateSignal?.Dispose();
-                    terminateSignal = null;
+                    applicationTerminateEventHandler -= value;
+                    if (applicationTerminateEventHandler == null)
+                    {
+                        terminateSignal?.Disconnect(applicationTerminateEventCallbackDelegate);
+                        terminateSignal?.Dispose();
+                        terminateSignal = null;
+                        applicationTerminateEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationTerminateEventHandler -= value;
             }
         }
 
@@ -774,23 +787,29 @@ namespace Tizen.NUI
                 if (applicationPauseEventHandler == null)
                 {
                     applicationPauseEventHandler += value;
-
                     applicationPauseEventCallbackDelegate = new NUIApplicationPauseEventCallbackDelegate(OnNUIApplicationPause);
                     pauseSignal = this.PauseSignal();
                     pauseSignal?.Connect(applicationPauseEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.Paused] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationPauseEventHandler != null)
                 {
-                    pauseSignal?.Disconnect(applicationPauseEventCallbackDelegate);
-                    pauseSignal?.Dispose();
-                    pauseSignal = null;
+                    applicationPauseEventHandler -= value;
+                    if (applicationTerminateEventHandler == null)
+                    {
+                        pauseSignal?.Disconnect(applicationPauseEventCallbackDelegate);
+                        pauseSignal?.Dispose();
+                        pauseSignal = null;
+                        applicationPauseEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationPauseEventHandler -= value;
             }
         }
 
@@ -815,23 +834,29 @@ namespace Tizen.NUI
                 if (applicationResumeEventHandler == null)
                 {
                     applicationResumeEventHandler += value;
-
                     applicationResumeEventCallbackDelegate = new NUIApplicationResumeEventCallbackDelegate(OnNUIApplicationResume);
                     resumeSignal = this.ResumeSignal();
                     resumeSignal?.Connect(applicationResumeEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.Resumed] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationResumeEventHandler != null)
                 {
-                    resumeSignal?.Disconnect(applicationResumeEventCallbackDelegate);
-                    resumeSignal?.Dispose();
-                    resumeSignal = null;
+                    applicationResumeEventHandler -= value;
+                    if (applicationResumeEventHandler == null)
+                    {
+                        resumeSignal?.Disconnect(applicationResumeEventCallbackDelegate);
+                        resumeSignal?.Dispose();
+                        resumeSignal = null;
+                        applicationResumeEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationResumeEventHandler -= value;
             }
         }
 
@@ -856,23 +881,29 @@ namespace Tizen.NUI
                 if (applicationResetEventHandler == null)
                 {
                     applicationResetEventHandler += value;
-
                     applicationResetEventCallbackDelegate = new NUIApplicationResetEventCallbackDelegate(OnNUIApplicationReset);
                     resetSignal = this.ResetSignal();
                     resetSignal?.Connect(applicationResetEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.Reset] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationResetEventHandler != null)
                 {
-                    resetSignal?.Disconnect(applicationResetEventCallbackDelegate);
-                    resetSignal?.Dispose();
-                    resetSignal = null;
+                    applicationResetEventHandler -= value;
+                    if (applicationResetEventHandler == null)
+                    {
+                        resetSignal?.Disconnect(applicationResetEventCallbackDelegate);
+                        resetSignal?.Dispose();
+                        resetSignal = null;
+                        applicationResetEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationResetEventHandler -= value;
             }
         }
 
@@ -897,23 +928,29 @@ namespace Tizen.NUI
                 if (applicationLanguageChangedEventHandler == null)
                 {
                     applicationLanguageChangedEventHandler += value;
-
                     applicationLanguageChangedEventCallbackDelegate = new NUIApplicationLanguageChangedEventCallbackDelegate(OnNUIApplicationLanguageChanged);
                     languageChangedSignal = this.LanguageChangedSignal();
                     languageChangedSignal?.Connect(applicationLanguageChangedEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.LanguageChanged] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationLanguageChangedEventHandler != null)
                 {
-                    languageChangedSignal?.Disconnect(applicationLanguageChangedEventCallbackDelegate);
-                    languageChangedSignal?.Dispose();
-                    languageChangedSignal = null;
+                    applicationLanguageChangedEventHandler -= value;
+                    if (applicationLanguageChangedEventHandler == null)
+                    {
+                        languageChangedSignal?.Disconnect(applicationLanguageChangedEventCallbackDelegate);
+                        languageChangedSignal?.Dispose();
+                        languageChangedSignal = null;
+                        applicationLanguageChangedEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationLanguageChangedEventHandler -= value;
             }
         }
 
@@ -938,23 +975,29 @@ namespace Tizen.NUI
                 if (applicationRegionChangedEventHandler == null)
                 {
                     applicationRegionChangedEventHandler += value;
-
                     applicationRegionChangedEventCallbackDelegate = new NUIApplicationRegionChangedEventCallbackDelegate(OnNUIApplicationRegionChanged);
                     regionChangedSignal = this.RegionChangedSignal();
                     regionChangedSignal?.Connect(applicationRegionChangedEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.RegionChanged] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationRegionChangedEventHandler != null)
                 {
-                    regionChangedSignal?.Disconnect(applicationRegionChangedEventCallbackDelegate);
-                    regionChangedSignal?.Dispose();
-                    regionChangedSignal = null;
+                    applicationRegionChangedEventHandler -= value;
+                    if (applicationRegionChangedEventHandler == null)
+                    {
+                        regionChangedSignal?.Disconnect(applicationRegionChangedEventCallbackDelegate);
+                        regionChangedSignal?.Dispose();
+                        regionChangedSignal = null;
+                        applicationRegionChangedEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationRegionChangedEventHandler -= value;
             }
         }
 
@@ -979,23 +1022,29 @@ namespace Tizen.NUI
                 if (applicationBatteryLowEventHandler == null)
                 {
                     applicationBatteryLowEventHandler += value;
-
                     applicationBatteryLowEventCallbackDelegate = new NUIApplicationBatteryLowEventCallbackDelegate(OnNUIApplicationBatteryLow);
                     batteryLowSignal = this.BatteryLowSignal();
                     batteryLowSignal?.Connect(applicationBatteryLowEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.BatteryLow] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationBatteryLowEventHandler != null)
                 {
-                    batteryLowSignal?.Disconnect(applicationBatteryLowEventCallbackDelegate);
-                    batteryLowSignal?.Dispose();
-                    batteryLowSignal = null;
+                    applicationBatteryLowEventHandler -= value;
+                    if (applicationBatteryLowEventHandler == null)
+                    {
+                        batteryLowSignal?.Disconnect(applicationBatteryLowEventCallbackDelegate);
+                        batteryLowSignal?.Dispose();
+                        batteryLowSignal = null;
+                        applicationBatteryLowEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationBatteryLowEventHandler -= value;
             }
         }
 
@@ -1019,23 +1068,29 @@ namespace Tizen.NUI
                 if (applicationMemoryLowEventHandler == null)
                 {
                     applicationMemoryLowEventHandler += value;
-
                     applicationMemoryLowEventCallbackDelegate = new NUIApplicationMemoryLowEventCallbackDelegate(OnNUIApplicationMemoryLow);
                     memoryLowSignal = this.MemoryLowSignal();
                     memoryLowSignal?.Connect(applicationMemoryLowEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.MemoryLow] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationMemoryLowEventHandler != null)
                 {
-                    memoryLowSignal?.Disconnect(applicationMemoryLowEventCallbackDelegate);
-                    memoryLowSignal?.Dispose();
-                    memoryLowSignal = null;
+                    applicationMemoryLowEventHandler -= value;
+                    if (applicationMemoryLowEventHandler == null)
+                    {
+                        memoryLowSignal?.Disconnect(applicationMemoryLowEventCallbackDelegate);
+                        memoryLowSignal?.Dispose();
+                        memoryLowSignal = null;
+                        applicationMemoryLowEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationMemoryLowEventHandler -= value;
             }
         }
 
@@ -1059,23 +1114,29 @@ namespace Tizen.NUI
                 if (applicationDeviceOrientationChangedEventHandler == null)
                 {
                     applicationDeviceOrientationChangedEventHandler += value;
-
                     applicationDeviceOrientationChangedEventCallback = new NUIApplicationDeviceOrientationChangedEventCallback(OnNUIApplicationDeviceOrientationChanged);
                     deviceOrientationChangedSignal = this.DeviceOrientationChangedSignal();
                     deviceOrientationChangedSignal?.Connect(applicationDeviceOrientationChangedEventCallback);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.DeviceOrientationChanged] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationDeviceOrientationChangedEventHandler != null)
                 {
-                    deviceOrientationChangedSignal?.Disconnect(applicationDeviceOrientationChangedEventCallback);
-                    deviceOrientationChangedSignal?.Dispose();
-                    deviceOrientationChangedSignal = null;
+                    applicationDeviceOrientationChangedEventHandler -= value;
+                    if (applicationDeviceOrientationChangedEventHandler == null)
+                    {
+                        deviceOrientationChangedSignal?.Disconnect(applicationDeviceOrientationChangedEventCallback);
+                        deviceOrientationChangedSignal?.Dispose();
+                        deviceOrientationChangedSignal = null;
+                        applicationDeviceOrientationChangedEventCallback = null;
+                    }
                 }
-
-                applicationDeviceOrientationChangedEventHandler -= value;
             }
         }
 
@@ -1098,23 +1159,29 @@ namespace Tizen.NUI
                 if (applicationAppControlEventHandler == null)
                 {
                     applicationAppControlEventHandler += value;
-
                     applicationAppControlEventCallbackDelegate = new NUIApplicationAppControlEventCallbackDelegate(OnNUIApplicationAppControl);
                     appControlSignal = this.AppControlSignal();
                     appControlSignal?.Connect(applicationAppControlEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.AppControl] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationAppControlEventHandler != null)
                 {
-                    appControlSignal?.Disconnect(applicationAppControlEventCallbackDelegate);
-                    appControlSignal?.Dispose();
-                    appControlSignal = null;
+                    applicationAppControlEventHandler -= value;
+                    if (applicationAppControlEventHandler == null)
+                    {
+                        appControlSignal?.Disconnect(applicationAppControlEventCallbackDelegate);
+                        appControlSignal?.Dispose();
+                        appControlSignal = null;
+                        applicationAppControlEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationAppControlEventHandler -= value;
             }
         }
 
@@ -1141,24 +1208,30 @@ namespace Tizen.NUI
                 // Restricted to only one listener
                 if (applicationTaskInitEventHandler == null)
                 {
-                    Tizen.Log.Fatal("NUI", "TaskInitialized Property adding");
                     applicationTaskInitEventHandler += value;
                     applicationTaskInitEventCallbackDelegate = new NUIApplicationInitEventCallbackDelegate(OnApplicationTaskInit);
                     taskInitSignal = this.TaskInitSignal();
                     taskInitSignal?.Connect(applicationTaskInitEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.TaskInitialized] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationTaskInitEventHandler != null)
                 {
-                    taskInitSignal?.Disconnect(applicationTaskInitEventCallbackDelegate);
-                    taskInitSignal?.Dispose();
-                    taskInitSignal = null;
+                    applicationTaskInitEventHandler -= value;
+                    if (applicationTaskInitEventHandler == null)
+                    {
+                        taskInitSignal?.Disconnect(applicationTaskInitEventCallbackDelegate);
+                        taskInitSignal?.Dispose();
+                        taskInitSignal = null;
+                        applicationTaskInitEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationTaskInitEventHandler -= value;
             }
         }
 
@@ -1185,23 +1258,29 @@ namespace Tizen.NUI
                 if (applicationTaskTerminateEventHandler == null)
                 {
                     applicationTaskTerminateEventHandler += value;
-
                     applicationTaskTerminateEventCallbackDelegate = new NUIApplicationTerminateEventCallbackDelegate(OnNUIApplicationTaskTerminate);
                     taskTerminateSignal = this.TaskTerminateSignal();
                     taskTerminateSignal?.Connect(applicationTaskTerminateEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.TaskTerminating] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationTaskTerminateEventHandler != null)
                 {
-                    taskTerminateSignal?.Disconnect(applicationTaskTerminateEventCallbackDelegate);
-                    taskTerminateSignal?.Dispose();
-                    taskTerminateSignal = null;
+                    applicationTaskTerminateEventHandler -= value;
+                    if (applicationTaskTerminateEventHandler == null)
+                    {
+                        taskTerminateSignal?.Disconnect(applicationTaskTerminateEventCallbackDelegate);
+                        taskTerminateSignal?.Dispose();
+                        taskTerminateSignal = null;
+                        applicationTaskTerminateEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationTaskTerminateEventHandler -= value;
             }
         }
 
@@ -1227,23 +1306,29 @@ namespace Tizen.NUI
                 if (applicationTaskLanguageChangedEventHandler == null)
                 {
                     applicationTaskLanguageChangedEventHandler += value;
-
                     applicationTaskLanguageChangedEventCallbackDelegate = new NUIApplicationLanguageChangedEventCallbackDelegate(OnNUIApplicationTaskLanguageChanged);
                     taskLanguageChangedSignal = this.TaskLanguageChangedSignal();
                     taskLanguageChangedSignal?.Connect(applicationTaskLanguageChangedEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.TaskLanguageChanged] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationTaskLanguageChangedEventHandler != null)
                 {
-                    taskLanguageChangedSignal?.Disconnect(applicationTaskLanguageChangedEventCallbackDelegate);
-                    taskLanguageChangedSignal?.Dispose();
-                    taskLanguageChangedSignal = null;
+                    applicationTaskLanguageChangedEventHandler -= value;
+                    if (applicationTaskLanguageChangedEventHandler == null)
+                    {
+                        taskLanguageChangedSignal?.Disconnect(applicationTaskLanguageChangedEventCallbackDelegate);
+                        taskLanguageChangedSignal?.Dispose();
+                        taskLanguageChangedSignal = null;
+                        applicationTaskLanguageChangedEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationTaskLanguageChangedEventHandler -= value;
             }
         }
 
@@ -1269,23 +1354,29 @@ namespace Tizen.NUI
                 if (applicationTaskRegionChangedEventHandler == null)
                 {
                     applicationTaskRegionChangedEventHandler += value;
-
                     applicationTaskRegionChangedEventCallbackDelegate = new NUIApplicationRegionChangedEventCallbackDelegate(OnNUIApplicationTaskRegionChanged);
                     taskRegionChangedSignal = this.TaskRegionChangedSignal();
                     taskRegionChangedSignal?.Connect(applicationTaskRegionChangedEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.TaskRegionChanged] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationTaskRegionChangedEventHandler != null)
                 {
-                    taskRegionChangedSignal?.Disconnect(applicationTaskRegionChangedEventCallbackDelegate);
-                    taskRegionChangedSignal?.Dispose();
-                    taskRegionChangedSignal = null;
+                    applicationTaskRegionChangedEventHandler -= value;
+                    if (applicationTaskRegionChangedEventHandler == null)
+                    {
+                        taskRegionChangedSignal?.Disconnect(applicationTaskRegionChangedEventCallbackDelegate);
+                        taskRegionChangedSignal?.Dispose();
+                        taskRegionChangedSignal = null;
+                        applicationTaskRegionChangedEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationTaskRegionChangedEventHandler -= value;
             }
         }
 
@@ -1311,23 +1402,29 @@ namespace Tizen.NUI
                 if (applicationTaskBatteryLowEventHandler == null)
                 {
                     applicationTaskBatteryLowEventHandler += value;
-
                     applicationTaskBatteryLowEventCallbackDelegate = new NUIApplicationBatteryLowEventCallbackDelegate(OnNUIApplicationTaskBatteryLow);
                     taskBatteryLowSignal = this.TaskBatteryLowSignal();
                     taskBatteryLowSignal?.Connect(applicationTaskBatteryLowEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.TaskBatteryLow] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationTaskBatteryLowEventHandler != null)
                 {
-                    taskBatteryLowSignal?.Disconnect(applicationTaskBatteryLowEventCallbackDelegate);
-                    taskBatteryLowSignal?.Dispose();
-                    taskBatteryLowSignal = null;
+                    applicationTaskBatteryLowEventHandler -= value;
+                    if (applicationTaskBatteryLowEventHandler == null)
+                    {
+                        taskBatteryLowSignal?.Disconnect(applicationTaskBatteryLowEventCallbackDelegate);
+                        taskBatteryLowSignal?.Dispose();
+                        taskBatteryLowSignal = null;
+                        applicationTaskBatteryLowEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationTaskBatteryLowEventHandler -= value;
             }
         }
 
@@ -1352,23 +1449,29 @@ namespace Tizen.NUI
                 if (applicationTaskMemoryLowEventHandler == null)
                 {
                     applicationTaskMemoryLowEventHandler += value;
-
                     applicationTaskMemoryLowEventCallbackDelegate = new NUIApplicationMemoryLowEventCallbackDelegate(OnNUIApplicationTaskMemoryLow);
                     taskMemoryLowSignal = this.TaskMemoryLowSignal();
                     taskMemoryLowSignal?.Connect(applicationTaskMemoryLowEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.TaskMemoryLow] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationTaskMemoryLowEventHandler != null)
                 {
-                    taskMemoryLowSignal?.Disconnect(applicationTaskMemoryLowEventCallbackDelegate);
-                    taskMemoryLowSignal?.Dispose();
-                    taskMemoryLowSignal = null;
+                    applicationTaskMemoryLowEventHandler -= value;
+                    if (applicationTaskMemoryLowEventHandler == null)
+                    {
+                        taskMemoryLowSignal?.Disconnect(applicationTaskMemoryLowEventCallbackDelegate);
+                        taskMemoryLowSignal?.Dispose();
+                        taskMemoryLowSignal = null;
+                        applicationTaskMemoryLowEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationTaskMemoryLowEventHandler -= value;
             }
         }
 
@@ -1392,23 +1495,29 @@ namespace Tizen.NUI
                 if (applicationTaskDeviceOrientationChangedEventHandler == null)
                 {
                     applicationTaskDeviceOrientationChangedEventHandler += value;
-
                     applicationTaskDeviceOrientationChangedEventCallback = new NUIApplicationDeviceOrientationChangedEventCallback(OnNUIApplicationTaskDeviceOrientationChanged);
                     taskDeviceOrientationChangedSignal = this.TaskDeviceOrientationChangedSignal();
                     taskDeviceOrientationChangedSignal?.Connect(applicationTaskDeviceOrientationChangedEventCallback);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.TaskDeviceOrientationChanged] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationTaskDeviceOrientationChangedEventHandler != null)
                 {
-                    taskDeviceOrientationChangedSignal?.Disconnect(applicationTaskDeviceOrientationChangedEventCallback);
-                    taskDeviceOrientationChangedSignal?.Dispose();
-                    taskDeviceOrientationChangedSignal = null;
+                    applicationTaskDeviceOrientationChangedEventHandler -= value;
+                    if (applicationTaskDeviceOrientationChangedEventHandler == null)
+                    {
+                        taskDeviceOrientationChangedSignal?.Disconnect(applicationTaskDeviceOrientationChangedEventCallback);
+                        taskDeviceOrientationChangedSignal?.Dispose();
+                        taskDeviceOrientationChangedSignal = null;
+                        applicationTaskDeviceOrientationChangedEventCallback = null;
+                    }
                 }
-
-                applicationTaskDeviceOrientationChangedEventHandler -= value;
             }
         }
 
@@ -1437,18 +1546,25 @@ namespace Tizen.NUI
                     taskAppControlSignal = this.TaskAppControlSignal();
                     taskAppControlSignal?.Connect(applicationTaskAppControlEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Application.TaskAppControl] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationTaskAppControlEventHandler != null)
                 {
-                    taskAppControlSignal?.Disconnect(applicationTaskAppControlEventCallbackDelegate);
-                    taskAppControlSignal?.Dispose();
-                    taskAppControlSignal = null;
+                    applicationTaskAppControlEventHandler -= value;
+                    if (applicationTaskAppControlEventHandler == null)
+                    {
+                        taskAppControlSignal?.Disconnect(applicationTaskAppControlEventCallbackDelegate);
+                        taskAppControlSignal?.Dispose();
+                        taskAppControlSignal = null;
+                        applicationTaskAppControlEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationTaskAppControlEventHandler -= value;
             }
         }
 

diff --git a/src/Tizen.NUI/src/internal/Application/ComponentApplication.cs b/src/Tizen.NUI/src/internal/Application/ComponentApplication.cs
index fb91e1fac06117b30193c9a30067d24bde57693a..c1d8917b68b8eaaba6225c0378dbd64cc7442c6d 100755 (executable)
--- a/src/Tizen.NUI/src/internal/Application/ComponentApplication.cs
+++ b/src/Tizen.NUI/src/internal/Application/ComponentApplication.cs
@@ -104,20 +104,26 @@ namespace Tizen.NUI
                 if (applicationCreateNativeEventHandler == null)
                 {
                     applicationCreateNativeEventHandler += value;
-
                     applicationCreateNativeEventCallbackDelegate = new NUIComponentApplicationCreatenativeEventCallbackDelegate(OnApplicationCreateNative);
                     Connect(applicationCreateNativeEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[ComponentApplication.CreateNative] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (applicationCreateNativeEventHandler != null)
                 {
-                    Disconnect(applicationCreateNativeEventCallbackDelegate);
+                    applicationCreateNativeEventHandler -= value;
+                    if (applicationCreateNativeEventHandler == null)
+                    {
+                        Disconnect(applicationCreateNativeEventCallbackDelegate);
+                        applicationCreateNativeEventCallbackDelegate = null;
+                    }
                 }
-
-                applicationCreateNativeEventHandler -= value;
             }
         }
 

diff --git a/src/Tizen.NUI/src/internal/Application/WatchApplication.cs b/src/Tizen.NUI/src/internal/Application/WatchApplication.cs
index 8aeef548a8d550aaa39b83e0b8ab14ea4bc653cc..8be5ed66f56bcd75c7a1abd154c1a9853f9e2884 100755 (executable)
--- a/src/Tizen.NUI/src/internal/Application/WatchApplication.cs
+++ b/src/Tizen.NUI/src/internal/Application/WatchApplication.cs
@@ -153,9 +153,10 @@ namespace Tizen.NUI
             {
                 timeTickEventHandler -= value;
 
-                if (timeTickEventHandler == null && TimeTickSignal().Empty() == false)
+                if (timeTickEventHandler == null && timeTickCallback != null)
                 {
                     TimeTickSignal().Disconnect(timeTickCallback);
+                    timeTickCallback = null;
                 }
             }
         }
@@ -225,9 +226,10 @@ namespace Tizen.NUI
             {
                 ambientTickEventHandler -= value;
 
-                if (ambientTickEventHandler == null && AmbientTickSignal().Empty() == false)
+                if (ambientTickEventHandler == null && ambientTickCallback != null)
                 {
                     AmbientTickSignal().Disconnect(ambientTickCallback);
+                    ambientTickCallback = null;
                 }
             }
         }
@@ -297,9 +299,10 @@ namespace Tizen.NUI
             {
                 ambientChangedEventHandler -= value;
 
-                if (ambientChangedEventHandler == null && AmbientChangedSignal().Empty() == false)
+                if (ambientChangedEventHandler == null && ambientChangedCallback != null)
                 {
                     AmbientChangedSignal().Disconnect(ambientChangedCallback);
+                    ambientChangedCallback = null;
                 }
             }
         }

diff --git a/src/Tizen.NUI/src/internal/Common/ObjectRegistry.cs b/src/Tizen.NUI/src/internal/Common/ObjectRegistry.cs
index 15f25f7ee6220bb995f1a7e738d86346ed7de62a..37bad4c47ec712b60dde26f92520edbd2cbf971a 100755 (executable)
--- a/src/Tizen.NUI/src/internal/Common/ObjectRegistry.cs
+++ b/src/Tizen.NUI/src/internal/Common/ObjectRegistry.cs
@@ -91,16 +91,23 @@ namespace Tizen.NUI
                     objectRegistryObjectCreatedEventCallbackDelegate = new ObjectCreatedEventCallbackDelegate(OnObjectCreated);
                     this.ObjectCreatedSignal().Connect(objectRegistryObjectCreatedEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[ObjectRegistry.ObjectCreated] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (objectRegistryObjectCreatedEventHandler != null)
                 {
-                    this.ObjectCreatedSignal().Disconnect(objectRegistryObjectCreatedEventCallbackDelegate);
+                    objectRegistryObjectCreatedEventHandler -= value;
+                    if (objectRegistryObjectCreatedEventHandler == null)
+                    {
+                        this.ObjectCreatedSignal().Disconnect(objectRegistryObjectCreatedEventCallbackDelegate);
+                        objectRegistryObjectCreatedEventCallbackDelegate = null;
+                    }
                 }
-
-                objectRegistryObjectCreatedEventHandler -= value;
             }
         }
 
@@ -131,16 +138,23 @@ namespace Tizen.NUI
                     objectRegistryObjectDestroyedEventCallbackDelegate = new ObjectDestroyedEventCallbackDelegate(OnObjectDestroyed);
                     this.ObjectDestroyedSignal().Connect(objectRegistryObjectDestroyedEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[ObjectRegistry.ObjectDestroyed] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (objectRegistryObjectDestroyedEventHandler != null)
                 {
-                    this.ObjectDestroyedSignal().Disconnect(objectRegistryObjectDestroyedEventCallbackDelegate);
+                    objectRegistryObjectDestroyedEventHandler -= value;
+                    if (objectRegistryObjectDestroyedEventHandler == null)
+                    {
+                        this.ObjectDestroyedSignal().Disconnect(objectRegistryObjectDestroyedEventCallbackDelegate);
+                        objectRegistryObjectDestroyedEventCallbackDelegate = null;
+                    }
                 }
-
-                objectRegistryObjectDestroyedEventHandler -= value;
             }
         }
 

diff --git a/src/Tizen.NUI/src/internal/Utility/Builder.cs b/src/Tizen.NUI/src/internal/Utility/Builder.cs
index e31516aa9f7e8d1d133847e226ee1d86473bb3a5..9adb676daf387bb8431766eda22f35c69e3d8e20 100755 (executable)
--- a/src/Tizen.NUI/src/internal/Utility/Builder.cs
+++ b/src/Tizen.NUI/src/internal/Utility/Builder.cs
@@ -51,21 +51,27 @@ namespace Tizen.NUI
                 if (builderQuitEventHandler == null)
                 {
                     builderQuitEventHandler += value;
-
                     builderQuitEventCallbackDelegate = new QuitEventCallbackDelegate(OnQuit);
                     quitSignal = this.QuitSignal();
                     quitSignal?.Connect(builderQuitEventCallbackDelegate);
                 }
+                else
+                {
+                    Tizen.Log.Error("NUI", "[Builder.Quit] Only one listener is allowed\n");
+                }
             }
 
             remove
             {
                 if (builderQuitEventHandler != null)
                 {
-                    quitSignal?.Disconnect(builderQuitEventCallbackDelegate);
+                    builderQuitEventHandler -= value;
+                    if (builderQuitEventHandler == null)
+                    {
+                        quitSignal?.Disconnect(builderQuitEventCallbackDelegate);
+                        builderQuitEventCallbackDelegate = null;
+                    }
                 }
-
-                builderQuitEventHandler -= value;
             }
         }
 

diff --git a/src/Tizen.NUI/src/internal/Utility/GaussianBlurView.cs b/src/Tizen.NUI/src/internal/Utility/GaussianBlurView.cs
index dc5f12ee030ef22edacacce218a319e21da20c6d..c0cae03915c9872e6e0bd7caa75730a98bcaa5a6 100755 (executable)
--- a/src/Tizen.NUI/src/internal/Utility/GaussianBlurView.cs
+++ b/src/Tizen.NUI/src/internal/Utility/GaussianBlurView.cs
@@ -109,12 +109,12 @@ namespace Tizen.NUI
         {
             add
             {
-                // Restricted to only one listener
                 if (finishedEventHandler == null)
                 {
                     finishedCallback = new FinishedCallbackType(OnFinished);
                     FinishedSignal().Connect(finishedCallback);
                 }
+
                 finishedEventHandler += value;
             }
 
@@ -122,9 +122,10 @@ namespace Tizen.NUI
             {
                 finishedEventHandler -= value;
 
-                if (finishedEventHandler == null && FinishedSignal().Empty() == false)
+                if (finishedEventHandler == null && finishedCallback != null)
                 {
                     FinishedSignal().Disconnect(finishedCallback);
+                    finishedCallback = null;
                 }
             }
         }

diff --git a/src/Tizen.NUI/src/public/BaseComponents/ImageView.cs b/src/Tizen.NUI/src/public/BaseComponents/ImageView.cs
index dc18df27ca66a88c334e54237d143ea1047f0792..9db7ef81c9eecf72675e0502f8a081a9affa07cd 100755 (executable)
--- a/src/Tizen.NUI/src/public/BaseComponents/ImageView.cs
+++ b/src/Tizen.NUI/src/public/BaseComponents/ImageView.cs
@@ -305,12 +305,12 @@ namespace Tizen.NUI.BaseComponents
             {
                 _resourceReadyEventHandler -= value;
 
-                ViewResourceReadySignal resourceReadySignal = ResourceReadySignal(this);
-                if (_resourceReadyEventHandler == null && resourceReadySignal?.Empty() == false)
+                if (_resourceReadyEventHandler == null && _resourceReadyEventCallback != null)
                 {
+                    using ViewResourceReadySignal resourceReadySignal = ResourceReadySignal(this);
                     resourceReadySignal?.Disconnect(_resourceReadyEventCallback);
+                    _resourceReadyEventCallback = null;
                 }
-                resourceReadySignal?.Dispose();
             }
         }
 
@@ -331,12 +331,12 @@ namespace Tizen.NUI.BaseComponents
             remove
             {
                 _resourceLoadedEventHandler -= value;
-                ViewResourceReadySignal resourceReadySignal = this.ResourceReadySignal(this);
-                if (_resourceLoadedEventHandler == null && resourceReadySignal?.Empty() == false)
+                if (_resourceLoadedEventHandler == null && _resourceLoadedCallback != null)
                 {
+                    using ViewResourceReadySignal resourceReadySignal = this.ResourceReadySignal(this);
                     resourceReadySignal?.Disconnect(_resourceLoadedCallback);
+                    _resourceLoadedCallback = null;
                 }
-                resourceReadySignal?.Dispose();
             }
         }
 

diff --git a/src/Tizen.NUI/src/public/BaseComponents/LottieAnimationView.cs b/src/Tizen.NUI/src/public/BaseComponents/LottieAnimationView.cs
index 2c8a788ab49ad124157a78fce4ec3f04684f632f..0c90bc22f6d4aa625e1bbc364f79ea44ab1848a8 100755 (executable)
--- a/src/Tizen.NUI/src/public/BaseComponents/LottieAnimationView.cs
+++ b/src/Tizen.NUI/src/public/BaseComponents/LottieAnimationView.cs
@@ -1166,11 +1166,8 @@ namespace Tizen.NUI.BaseComponents
                 if (finishedEventHandler == null && visualEventSignalCallback != null)
                 {
                     using VisualEventSignal visualEvent = VisualEventSignal();
-                    visualEvent.Disconnect(visualEventSignalCallback);
-                    if (visualEvent?.Empty() == true)
-                    {
-                        visualEventSignalCallback = null;
-                    }
+                    visualEvent?.Disconnect(visualEventSignalCallback);
+                    visualEventSignalCallback = null;
                 }
             }
         }

diff --git a/src/Tizen.NUI/src/public/BaseComponents/ViewAccessibilityEvent.cs b/src/Tizen.NUI/src/public/BaseComponents/ViewAccessibilityEvent.cs
index b0a844722288aba391c43c506d601307f53d5768..0409033d109596bdb1cd7c6cc457279fdc0ab2e3 100755 (executable)
--- a/src/Tizen.NUI/src/public/BaseComponents/ViewAccessibilityEvent.cs
+++ b/src/Tizen.NUI/src/public/BaseComponents/ViewAccessibilityEvent.cs
@@ -305,6 +305,7 @@ namespace Tizen.NUI.BaseComponents
                     gestureInfoSignal?.Disconnect(gestureInfoCallback);
                     gestureInfoSignal?.Dispose();
                     gestureInfoSignal = null;
+                    gestureInfoCallback = null;
                 }
             }
         }
@@ -367,6 +368,7 @@ namespace Tizen.NUI.BaseComponents
                     getDescriptionSignal?.Disconnect(getDescriptionCallback);
                     getDescriptionSignal?.Dispose();
                     getDescriptionSignal = null;
+                    getDescriptionCallback = null;
                 }
             }
         }
@@ -429,6 +431,7 @@ namespace Tizen.NUI.BaseComponents
                     getNameSignal?.Disconnect(getNameCallback);
                     getNameSignal?.Dispose();
                     getNameSignal = null;
+                    getNameCallback = null;
                 }
             }
         }
@@ -491,6 +494,7 @@ namespace Tizen.NUI.BaseComponents
                     ActivateSignal?.Disconnect(activateCallback);
                     ActivateSignal?.Dispose();
                     ActivateSignal = null;
+                    activateCallback = null;
                 }
             }
         }
@@ -540,6 +544,7 @@ namespace Tizen.NUI.BaseComponents
                     ReadingSkippedSignal?.Disconnect(readingSkippedCallback);
                     ReadingSkippedSignal?.Dispose();
                     ReadingSkippedSignal = null;
+                    readingSkippedCallback = null;
                 }
             }
         }
@@ -589,6 +594,7 @@ namespace Tizen.NUI.BaseComponents
                     ReadingPausedSignal?.Disconnect(readingPausedCallback);
                     ReadingPausedSignal?.Dispose();
                     ReadingPausedSignal = null;
+                    readingPausedCallback = null;
                 }
             }
         }
@@ -638,6 +644,7 @@ namespace Tizen.NUI.BaseComponents
                     ReadingResumedSignal?.Disconnect(readingResumedCallback);
                     ReadingResumedSignal?.Dispose();
                     ReadingResumedSignal = null;
+                    readingResumedCallback = null;
                 }
             }
         }
@@ -687,6 +694,7 @@ namespace Tizen.NUI.BaseComponents
                     ReadingCancelledSignal?.Disconnect(readingCancelledCallback);
                     ReadingCancelledSignal?.Dispose();
                     ReadingCancelledSignal = null;
+                    readingCancelledCallback = null;
                 }
             }
         }
@@ -736,6 +744,7 @@ namespace Tizen.NUI.BaseComponents
                     ReadingStoppedSignal?.Disconnect(readingStoppedCallback);
                     ReadingStoppedSignal?.Dispose();
                     ReadingStoppedSignal = null;
+                    readingStoppedCallback = null;
                 }
             }
         }

diff --git a/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs b/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs
index 951381118c6943d295006d9ab31538925f26d4c8..4de15a6de21a4c2fea716cd625fb3e6175937587 100755 (executable)
--- a/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs
+++ b/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs
@@ -1619,6 +1619,14 @@ namespace Tizen.NUI.BaseComponents
                 hitTestResultDataCallback = null;
             }
 
+            if (visibilityChangedEventCallback != null)
+            {
+                NUILog.Debug($"[Dispose] visibilityChangedEventCallback");
+
+                Interop.ActorSignal.VisibilityChangedDisconnect(SwigCPtr, visibilityChangedEventCallback.ToHandleRef(this));
+                NDalicPINVOKE.ThrowExceptionIfExists();
+                visibilityChangedEventCallback = null;
+            }
 
             if (interceptTouchDataCallback != null)
             {
@@ -1629,6 +1637,15 @@ namespace Tizen.NUI.BaseComponents
                 interceptTouchDataCallback = null;
             }
 
+            if (layoutDirectionChangedEventCallback != null)
+            {
+                NUILog.Debug($"[Dispose] layoutDirectionChangedEventCallback");
+
+                Interop.ActorSignal.LayoutDirectionChangedDisconnect(SwigCPtr, layoutDirectionChangedEventCallback.ToHandleRef(this));
+                NDalicPINVOKE.ThrowExceptionIfExists();
+                layoutDirectionChangedEventCallback = null;
+            }
+
             if (touchDataCallback != null)
             {
                 NUILog.Debug($"[Dispose] touchDataCallback");
@@ -1685,6 +1702,97 @@ namespace Tizen.NUI.BaseComponents
                 backgroundResourceLoadedCallback = null;
             }
 
+            // For ViewAccessibility
+            if (gestureInfoCallback != null)
+            {
+                NUILog.Debug($"[Dispose] gestureInfoCallback");
+
+                gestureInfoSignal?.Disconnect(gestureInfoCallback);
+                gestureInfoSignal?.Dispose();
+                gestureInfoSignal = null;
+                gestureInfoCallback = null;
+            }
+
+            if (getDescriptionCallback != null)
+            {
+                NUILog.Debug($"[Dispose] getDescriptionCallback");
+
+                getDescriptionSignal?.Disconnect(getDescriptionCallback);
+                getDescriptionSignal?.Dispose();
+                getDescriptionSignal = null;
+                getDescriptionCallback = null;
+            }
+
+            if (getNameCallback != null)
+            {
+                NUILog.Debug($"[Dispose] getNameCallback");
+
+                getNameSignal?.Disconnect(getNameCallback);
+                getNameSignal?.Dispose();
+                getNameSignal = null;
+                getNameCallback = null;
+            }
+
+            if (activateCallback != null)
+            {
+                NUILog.Debug($"[Dispose] activateCallback");
+
+                ActivateSignal?.Disconnect(activateCallback);
+                ActivateSignal?.Dispose();
+                ActivateSignal = null;
+                activateCallback = null;
+            }
+
+            if (readingSkippedCallback != null)
+            {
+                NUILog.Debug($"[Dispose] readingSkippedCallback");
+                
+                ReadingSkippedSignal?.Disconnect(readingSkippedCallback);
+                ReadingSkippedSignal?.Dispose();
+                ReadingSkippedSignal = null;
+                readingSkippedCallback = null;
+            }
+
+            if (readingPausedCallback != null)
+            {
+                NUILog.Debug($"[Dispose] readingPausedCallback");
+
+                ReadingPausedSignal?.Disconnect(readingPausedCallback);
+                ReadingPausedSignal?.Dispose();
+                ReadingPausedSignal = null;
+                readingPausedCallback = null;
+            }
+
+            if (readingResumedCallback != null)
+            {
+                NUILog.Debug($"[Dispose] readingResumedCallback");
+
+                ReadingResumedSignal?.Disconnect(readingResumedCallback);
+                ReadingResumedSignal?.Dispose();
+                ReadingResumedSignal = null;
+                readingResumedCallback = null;
+            }
+
+            if (readingCancelledCallback != null)
+            {
+                NUILog.Debug($"[Dispose] readingCancelledCallback");
+
+                ReadingCancelledSignal?.Disconnect(readingCancelledCallback);
+                ReadingCancelledSignal?.Dispose();
+                ReadingCancelledSignal = null;
+                readingCancelledCallback = null;
+            }
+
+            if (readingStoppedCallback != null)
+            {
+                NUILog.Debug($"[Dispose] readingStoppedCallback");
+
+                ReadingStoppedSignal?.Disconnect(readingStoppedCallback);
+                ReadingStoppedSignal?.Dispose();
+                ReadingStoppedSignal = null;
+                readingStoppedCallback = null;
+            }
+
             NDalicPINVOKE.ThrowExceptionIfExists();
             NUILog.Debug($"[Dispose] DisConnectFromSignals END");
         }

diff --git a/src/Tizen.NUI/src/public/Clipboard/Clipboard.cs b/src/Tizen.NUI/src/public/Clipboard/Clipboard.cs
index c0f84f8bed1020fe78c0bfa488768cff26a87bec..913c3db4dfe3c09ee9b04f40f90a24c9e963a461 100755 (executable)
--- a/src/Tizen.NUI/src/public/Clipboard/Clipboard.cs
+++ b/src/Tizen.NUI/src/public/Clipboard/Clipboard.cs
@@ -214,11 +214,13 @@ namespace Tizen.NUI
                 if (clipboardDataReceivedCallback != null)
                 {
                     this.ClipboardDataReceivedSignal().Disconnect(clipboardDataReceivedCallback);
+                    clipboardDataReceivedCallback = null;
                 }
 
                 if (clipboardDataSelectedCallback != null)
                 {
                     this.ClipboardDataSelectedSignal().Disconnect(clipboardDataSelectedCallback);
+                    clipboardDataSelectedCallback = null;
                 }
             }
 

diff --git a/src/Tizen.NUI/src/public/Clipboard/ClipboardEvent.cs b/src/Tizen.NUI/src/public/Clipboard/ClipboardEvent.cs
index bbf0bb3d3ccdf083b50f757d9397e6b8224eabe8..c8583347d276f9e5f6d6572e262a8b586b5d53f3 100755 (executable)
--- a/src/Tizen.NUI/src/public/Clipboard/ClipboardEvent.cs
+++ b/src/Tizen.NUI/src/public/Clipboard/ClipboardEvent.cs
@@ -121,9 +121,10 @@ namespace Tizen.NUI
             remove
             {
                 clipboardDataSelectedEventHandler -= value;
-                if (clipboardDataSelectedEventHandler == null && ClipboardDataSelectedSignal().Empty() == false)
+                if (clipboardDataSelectedEventHandler == null && clipboardDataSelectedCallback != null)
                 {
                     ClipboardDataSelectedSignal().Disconnect(clipboardDataSelectedCallback);
+                    clipboardDataSelectedCallback = null;
                 }
             }
         }
@@ -142,9 +143,10 @@ namespace Tizen.NUI
             remove
             {
                 clipboardDataReceivedEventHandler -= value;
-                if (clipboardDataReceivedEventHandler == null && ClipboardDataReceivedSignal().Empty() == false)
+                if (clipboardDataReceivedEventHandler == null && clipboardDataReceivedCallback != null)
                 {
                     ClipboardDataReceivedSignal().Disconnect(clipboardDataReceivedCallback);
+                    clipboardDataReceivedCallback = null;
                 }
             }
         }

diff --git a/src/Tizen.NUI/src/public/Utility/Capture.cs b/src/Tizen.NUI/src/public/Utility/Capture.cs
index 5208986314e2e2ce2934bc474b749d301b7d4cba..9bd506b0d30fbbfdc409e2c09e8b2bd10cc1084b 100755 (executable)
--- a/src/Tizen.NUI/src/public/Utility/Capture.cs
+++ b/src/Tizen.NUI/src/public/Utility/Capture.cs
@@ -94,6 +94,13 @@ namespace Tizen.NUI
                 //Called by User
                 //Release your own managed resources here.
                 //You should release all of your own disposable objects here.
+                if (finishedCallback != null)
+                {
+                    finishedSignal?.Disconnect(finishedCallback);
+                    finishedSignal?.Dispose();
+                    finishedSignal = null;
+                    finishedCallback = null;
+                }
             }
 
             base.Dispose(type);
@@ -318,8 +325,8 @@ namespace Tizen.NUI
             {
                 if (finishedEventHandler == null && disposed == false)
                 {
-                    finishedSignal = new CaptureSignal(Interop.Capture.Get(SwigCPtr));
                     finishedCallback = onFinished;
+                    finishedSignal = new CaptureSignal(Interop.Capture.Get(SwigCPtr));
                     finishedSignal.Connect(finishedCallback);
                 }
                 finishedEventHandler += value;
@@ -328,10 +335,12 @@ namespace Tizen.NUI
             {
                 finishedEventHandler -= value;
 
-                if (finishedEventHandler == null && finishedSignal?.Empty() == false)
+                if (finishedEventHandler == null && finishedCallback != null)
                 {
-                    finishedCallback = onFinished;
-                    finishedSignal.Disconnect(finishedCallback);
+                    finishedSignal?.Disconnect(finishedCallback);
+                    finishedSignal?.Dispose();
+                    finishedSignal = null;
+                    finishedCallback = null;
                 }
             }
         }