[MediaController] Add disposed object checker

Change-Id: Ib0a2f7f9fa5e752a5ff9b25e3234ab554c479843
Signed-off-by: jiyong.min <jiyong.min@samsung.com>

diff --git a/src/Tizen.Multimedia/MediaController/MediaControllerClient.cs b/src/Tizen.Multimedia/MediaController/MediaControllerClient.cs
index 1842c59..da1b93d 100755 (executable)
--- a/src/Tizen.Multimedia/MediaController/MediaControllerClient.cs
+++ b/src/Tizen.Multimedia/MediaController/MediaControllerClient.cs
@@ -52,7 +52,20 @@ namespace Tizen.Multimedia.MediaController
 
         private bool IsValidHandle
         {
-            get { return (this._handle != IntPtr.Zero); }
+            get { return (_handle != IntPtr.Zero); }
+        }
+
+        private IntPtr SafeHandle
+        {
+            get
+            {
+                if (!IsValidHandle)
+                {
+                    throw new ObjectDisposedException(nameof(MediaControllerClient), "Fail to operate MediaControllerClient");
+                }
+
+                return _handle;
+            }
         }
 
         /// <summary>
@@ -235,10 +248,10 @@ namespace Tizen.Multimedia.MediaController
                 if (_customcommandReply == null)
                 {
                     _customcommandReplyCallback = (IntPtr serverName, int result, IntPtr bundle, IntPtr userData) =>
-                    {\r
-                        SafeBundleHandle safeBundleHandle = new SafeBundleHandle(bundle, true);\r
-                        Bundle bundleData = new Bundle(safeBundleHandle);\r
-                        CustomCommandReplyEventArgs eventArgs = new CustomCommandReplyEventArgs(Marshal.PtrToStringAnsi(serverName), result, bundleData);\r
+                    {
+                        SafeBundleHandle safeBundleHandle = new SafeBundleHandle(bundle, true);
+                        Bundle bundleData = new Bundle(safeBundleHandle);
+                        CustomCommandReplyEventArgs eventArgs = new CustomCommandReplyEventArgs(Marshal.PtrToStringAnsi(serverName), result, bundleData);
                         _customcommandReply?.Invoke(this, eventArgs);
                     };
                 }
@@ -266,15 +279,15 @@ namespace Tizen.Multimedia.MediaController
             IntPtr name = IntPtr.Zero;
             MediaControllerServerState state = MediaControllerServerState.None;
 
-            try\r
+            try
             {
                 MediaControllerValidator.ThrowIfError(
-                    Interop.MediaControllerClient.GetLatestServer(_handle, out name, out state), "Get Latest server failed");\r
-                return new ServerInformation(Marshal.PtrToStringAnsi(name), (MediaControllerServerState)state);\r
+                    Interop.MediaControllerClient.GetLatestServer(SafeHandle, out name, out state), "Get Latest server failed");
+                return new ServerInformation(Marshal.PtrToStringAnsi(name), (MediaControllerServerState)state);
             }
             finally
-            {\r
-                Interop.Libc.Free(name);\r
+            {
+                Interop.Libc.Free(name);
             }
         }
 
@@ -292,15 +305,15 @@ namespace Tizen.Multimedia.MediaController
             try
             {
                 MediaControllerValidator.ThrowIfError(
-                    Interop.MediaControllerClient.GetServerPlayback(_handle, serverName, out playbackHandle), "Get Playback handle failed");
+                    Interop.MediaControllerClient.GetServerPlayback(SafeHandle, serverName, out playbackHandle), "Get Playback handle failed");
                 playback = new MediaControllerPlayback(playbackHandle);
             }
             finally
             {
-                if (playbackHandle != IntPtr.Zero)\r
+                if (playbackHandle != IntPtr.Zero)
                 {
                     MediaControllerValidator.ThrowIfError(
-                        Interop.MediaControllerClient.DestroyPlayback(playbackHandle), "Destroy playback failed");\r
+                        Interop.MediaControllerClient.DestroyPlayback(playbackHandle), "Destroy playback failed");
                 }
             }
 
@@ -321,15 +334,15 @@ namespace Tizen.Multimedia.MediaController
             try
             {
                 MediaControllerValidator.ThrowIfError(
-                    Interop.MediaControllerClient.GetServerMetadata(_handle, serverName, out metadataHandle), "Get Metadata handle failed");
+                    Interop.MediaControllerClient.GetServerMetadata(SafeHandle, serverName, out metadataHandle), "Get Metadata handle failed");
                 metadata = new MediaControllerMetadata(metadataHandle);
             }
             finally
-            {\r
-                if (metadataHandle != IntPtr.Zero)\r
-                {\r
+            {
+                if (metadataHandle != IntPtr.Zero)
+                {
                     MediaControllerValidator.ThrowIfError(
-                    Interop.MediaControllerClient.DestroyMetadata(metadataHandle), "Destroy metadata failed");\r
+                    Interop.MediaControllerClient.DestroyMetadata(metadataHandle), "Destroy metadata failed");
                 }
             }
 
@@ -347,7 +360,7 @@ namespace Tizen.Multimedia.MediaController
             MediaControllerShuffleMode shuffleMode = MediaControllerShuffleMode.Off;
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerClient.GetServerShuffleMode(_handle, serverName, out shuffleMode), "Get ShuffleMode failed");
+                Interop.MediaControllerClient.GetServerShuffleMode(SafeHandle, serverName, out shuffleMode), "Get ShuffleMode failed");
 
             return shuffleMode;
         }
@@ -363,7 +376,7 @@ namespace Tizen.Multimedia.MediaController
             MediaControllerRepeatMode repeatMode = MediaControllerRepeatMode.Off;
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerClient.GetServerRepeatMode(_handle, serverName, out repeatMode), "Get RepeatMode failed");
+                Interop.MediaControllerClient.GetServerRepeatMode(SafeHandle, serverName, out repeatMode), "Get RepeatMode failed");
 
             return repeatMode;
         }
@@ -377,7 +390,7 @@ namespace Tizen.Multimedia.MediaController
         public void SendPlaybackStateCommand(string serverName, MediaControllerPlaybackState state)
         {
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerClient.SendPlaybackStateCommand(_handle, serverName, state), "Send playback state command failed");
+                Interop.MediaControllerClient.SendPlaybackStateCommand(SafeHandle, serverName, state), "Send playback state command failed");
         }
 
         /// <summary>
@@ -390,7 +403,7 @@ namespace Tizen.Multimedia.MediaController
         public void SendCustomCommand(string serverName, string command, Bundle bundle)
         {
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerClient.SendCustomCommand(_handle, serverName, command, bundle.SafeBundleHandle, _customcommandReplyCallback, IntPtr.Zero),
+                Interop.MediaControllerClient.SendCustomCommand(SafeHandle, serverName, command, bundle.SafeBundleHandle, _customcommandReplyCallback, IntPtr.Zero),
                 "Send custom command failed");
         }
 
@@ -402,7 +415,7 @@ namespace Tizen.Multimedia.MediaController
         public void Subscribe(MediaControllerSubscriptionType type, string serverName)
         {
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerClient.Subscribe(_handle, type, serverName), "Subscribe failed");
+                Interop.MediaControllerClient.Subscribe(SafeHandle, type, serverName), "Subscribe failed");
         }
 
         /// <summary>
@@ -413,7 +426,7 @@ namespace Tizen.Multimedia.MediaController
         public void Unsubscribe(MediaControllerSubscriptionType type, string serverName)
         {
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerClient.Unsubscribe(_handle, type, serverName), "Unsubscribe failed");
+                Interop.MediaControllerClient.Unsubscribe(SafeHandle, type, serverName), "Unsubscribe failed");
         }
 
         /// <summary>
@@ -423,7 +436,7 @@ namespace Tizen.Multimedia.MediaController
         {
             var task = new TaskCompletionSource<IEnumerable<string>>();
 
-            List<string> collectionList = ForEachActivatedServer(_handle);
+            List<string> collectionList = ForEachActivatedServer(SafeHandle);
             task.TrySetResult((IEnumerable<string>)collectionList);
 
             return task.Task;
@@ -439,7 +452,7 @@ namespace Tizen.Multimedia.MediaController
         {
             var task = new TaskCompletionSource<IEnumerable<string>>();
 
-            List<string> collectionList = ForEachSubscribedServer(_handle, subscriptionType);
+            List<string> collectionList = ForEachSubscribedServer(SafeHandle, subscriptionType);
             task.TrySetResult((IEnumerable<string>)collectionList);
 
             return task.Task;
@@ -452,12 +465,12 @@ namespace Tizen.Multimedia.MediaController
                 ServerUpdatedEventArgs eventArgs = new ServerUpdatedEventArgs(Marshal.PtrToStringAnsi(serverName), serverState);
                 _serverUpdated?.Invoke(this, eventArgs);
             };
-            Interop.MediaControllerClient.SetServerUpdatedCb(_handle, _serverUpdatedCallback, IntPtr.Zero);
+            Interop.MediaControllerClient.SetServerUpdatedCb(SafeHandle, _serverUpdatedCallback, IntPtr.Zero);
         }
 
         private void UnregisterServerUpdatedEvent()
         {
-            Interop.MediaControllerClient.UnsetServerUpdatedCb(_handle);
+            Interop.MediaControllerClient.UnsetServerUpdatedCb(SafeHandle);
         }
 
         private void RegisterPlaybackUpdatedEvent()
@@ -467,12 +480,12 @@ namespace Tizen.Multimedia.MediaController
                 PlaybackUpdatedEventArgs eventArgs = new PlaybackUpdatedEventArgs(Marshal.PtrToStringAnsi(serverName), playback);
                 _playbackUpdated?.Invoke(this, eventArgs);
             };
-            Interop.MediaControllerClient.SetPlaybackUpdatedCb(_handle, _playbackUpdatedCallback, IntPtr.Zero);
+            Interop.MediaControllerClient.SetPlaybackUpdatedCb(SafeHandle, _playbackUpdatedCallback, IntPtr.Zero);
         }
 
         private void UnregisterPlaybackUpdatedEvent()
         {
-            Interop.MediaControllerClient.UnsetPlaybackUpdatedCb(_handle);
+            Interop.MediaControllerClient.UnsetPlaybackUpdatedCb(SafeHandle);
         }
 
         private void RegisterMetadataUpdatedEvent()
@@ -482,12 +495,12 @@ namespace Tizen.Multimedia.MediaController
                 MetadataUpdatedEventArgs eventArgs = new MetadataUpdatedEventArgs(Marshal.PtrToStringAnsi(serverName), metadata);
                 _metadataUpdated?.Invoke(this, eventArgs);
             };
-            Interop.MediaControllerClient.SetMetadataUpdatedCb(_handle, _metadataUpdatedCallback, IntPtr.Zero);
+            Interop.MediaControllerClient.SetMetadataUpdatedCb(SafeHandle, _metadataUpdatedCallback, IntPtr.Zero);
         }
 
         private void UnregisterMetadataUpdatedEvent()
         {
-            Interop.MediaControllerClient.UnsetMetadataUpdatedCb(_handle);
+            Interop.MediaControllerClient.UnsetMetadataUpdatedCb(SafeHandle);
         }
 
         private void RegisterShuffleModeUpdatedEvent()
@@ -499,13 +512,13 @@ namespace Tizen.Multimedia.MediaController
             };
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerClient.SetShuffleModeUpdatedCb(_handle, _shufflemodeUpdatedCallback, IntPtr.Zero),
+                Interop.MediaControllerClient.SetShuffleModeUpdatedCb(SafeHandle, _shufflemodeUpdatedCallback, IntPtr.Zero),
                 "Set ShuffleModeUpdated callback failed");
         }
 
         private void UnregisterShuffleModeUpdatedEvent()
         {
-            Interop.MediaControllerClient.UnsetShuffleModeUpdatedCb(_handle);
+            Interop.MediaControllerClient.UnsetShuffleModeUpdatedCb(SafeHandle);
         }
 
         private void RegisterRepeatModeUpdatedEvent()
@@ -517,13 +530,13 @@ namespace Tizen.Multimedia.MediaController
             };
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerClient.SetRepeatModeUpdatedCb(_handle, _repeatmodeUpdatedCallback, IntPtr.Zero),
+                Interop.MediaControllerClient.SetRepeatModeUpdatedCb(SafeHandle, _repeatmodeUpdatedCallback, IntPtr.Zero),
                 "Set RepeatModeUpdated callback failed");
         }
 
         private void UnregisterRepeatModeUpdatedEvent()
         {
-            Interop.MediaControllerClient.UnsetRepeatModeUpdatedCb(_handle);
+            Interop.MediaControllerClient.UnsetRepeatModeUpdatedCb(SafeHandle);
         }
 
         private static List<string> ForEachSubscribedServer(IntPtr handle, MediaControllerSubscriptionType subscriptionType)
@@ -549,7 +562,7 @@ namespace Tizen.Multimedia.MediaController
 
             Interop.MediaControllerClient.ActivatedServerCallback serverCallback = (IntPtr serverName, IntPtr userData) =>
             {
-                activatedServerCollections.Add(Marshal.PtrToStringAnsi(serverName));\r
+                activatedServerCollections.Add(Marshal.PtrToStringAnsi(serverName));
                 return true;
             };
 

diff --git a/src/Tizen.Multimedia/MediaController/MediaControllerServer.cs b/src/Tizen.Multimedia/MediaController/MediaControllerServer.cs
index cfd2ecb..177ae76 100755 (executable)
--- a/src/Tizen.Multimedia/MediaController/MediaControllerServer.cs
+++ b/src/Tizen.Multimedia/MediaController/MediaControllerServer.cs
@@ -42,7 +42,20 @@ namespace Tizen.Multimedia.MediaController
 
         private bool IsValidHandle
         {
-            get { return (this._handle != IntPtr.Zero); }
+            get { return (_handle != IntPtr.Zero); }
+        }
+
+        private IntPtr SafeHandle
+        {
+            get
+            {
+                if (!IsValidHandle)
+                {
+                    throw new ObjectDisposedException(nameof(MediaControllerServer), "Fail to operate MediaControllerServer");
+                }
+
+                return _handle;
+            }
         }
 
         /// <summary>
@@ -151,13 +164,13 @@ namespace Tizen.Multimedia.MediaController
             }
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetPlaybackState(_handle, playback.State), "Set Playback state failed");
+                Interop.MediaControllerServer.SetPlaybackState(SafeHandle, playback.State), "Set Playback state failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetPlaybackPosition(_handle, playback.Position), "Set Playback position failed");
+                Interop.MediaControllerServer.SetPlaybackPosition(SafeHandle, playback.Position), "Set Playback position failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.UpdatePlayback(_handle), "Update Playback failed");
+                Interop.MediaControllerServer.UpdatePlayback(SafeHandle), "Update Playback failed");
         }
 
         /// <summary>
@@ -173,40 +186,40 @@ namespace Tizen.Multimedia.MediaController
             }
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Title, metadata.Title), "Set Title failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Title, metadata.Title), "Set Title failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Artist, metadata.Artist), "Set Artist failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Artist, metadata.Artist), "Set Artist failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Album, metadata.Album), "Set Album failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Album, metadata.Album), "Set Album failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Author, metadata.Author), "Set Author failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Author, metadata.Author), "Set Author failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Genre, metadata.Genre), "Set Genre failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Genre, metadata.Genre), "Set Genre failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Duration, metadata.Duration), "Set Duration failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Duration, metadata.Duration), "Set Duration failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Date, metadata.Date), "Set Date failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Date, metadata.Date), "Set Date failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Copyright, metadata.Copyright), "Set Copyright failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Copyright, metadata.Copyright), "Set Copyright failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Description, metadata.Description), "Set Description failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Description, metadata.Description), "Set Description failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.TrackNumber, metadata.TrackNumber), "Set TrackNumber failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.TrackNumber, metadata.TrackNumber), "Set TrackNumber failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SetMetadata(_handle, MediaControllerAttributes.Picture, metadata.Picture), "Set Picture failed");
+                Interop.MediaControllerServer.SetMetadata(SafeHandle, MediaControllerAttributes.Picture, metadata.Picture), "Set Picture failed");
 
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.UpdateMetadata(_handle), "UpdateMetadata Metadata failed");
+                Interop.MediaControllerServer.UpdateMetadata(SafeHandle), "UpdateMetadata Metadata failed");
         }
 
         /// <summary>
@@ -217,7 +230,7 @@ namespace Tizen.Multimedia.MediaController
         public void UpdateShuffleMode(MediaControllerShuffleMode mode)
         {
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.UpdateShuffleMode(_handle, mode), "Update Shuffle Mode failed");
+                Interop.MediaControllerServer.UpdateShuffleMode(SafeHandle, mode), "Update Shuffle Mode failed");
         }
 
         /// <summary>
@@ -228,7 +241,7 @@ namespace Tizen.Multimedia.MediaController
         public void UpdateRepeatMode(MediaControllerRepeatMode mode)
         {
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.UpdateRepeatMode(_handle, mode), "Update Repeat Mode failed");
+                Interop.MediaControllerServer.UpdateRepeatMode(SafeHandle, mode), "Update Repeat Mode failed");
         }
 
         /// <summary>
@@ -241,7 +254,7 @@ namespace Tizen.Multimedia.MediaController
         public void SendCustomCommandReply(string clientName, int result, Bundle bundle)
         {
             MediaControllerValidator.ThrowIfError(
-                Interop.MediaControllerServer.SendCommandReply(_handle, clientName, result, bundle.SafeBundleHandle), "Send reply for command failed");
+                Interop.MediaControllerServer.SendCommandReply(SafeHandle, clientName, result, bundle.SafeBundleHandle), "Send reply for command failed");
         }
 
         private void RegisterPlaybackCmdRecvEvent()
@@ -251,12 +264,12 @@ namespace Tizen.Multimedia.MediaController
                 PlaybackStateCommandEventArgs eventArgs = new PlaybackStateCommandEventArgs(Marshal.PtrToStringAnsi(clientName), state);
                 _playbackCommand?.Invoke(this, eventArgs);
             };
-            Interop.MediaControllerServer.SetPlaybackStateCmdRecvCb(_handle, _playbackCommandCallback, IntPtr.Zero);
+            Interop.MediaControllerServer.SetPlaybackStateCmdRecvCb(SafeHandle, _playbackCommandCallback, IntPtr.Zero);
         }
 
         private void UnregisterPlaybackCmdRecvEvent()
         {
-            Interop.MediaControllerServer.UnsetPlaybackStateCmdRecvCb(_handle);
+            Interop.MediaControllerServer.UnsetPlaybackStateCmdRecvCb(SafeHandle);
         }
 
         private void RegisterCustomCommandEvent()
@@ -268,12 +281,12 @@ namespace Tizen.Multimedia.MediaController
                 CustomCommandEventArgs eventArgs = new CustomCommandEventArgs(Marshal.PtrToStringAnsi(clientName), Marshal.PtrToStringAnsi(command), bundleData);
                 _customCommand?.Invoke(this, eventArgs);
         };
-            Interop.MediaControllerServer.SetCustomCmdRecvCb(_handle, _customCommandCallback, IntPtr.Zero);
+            Interop.MediaControllerServer.SetCustomCmdRecvCb(SafeHandle, _customCommandCallback, IntPtr.Zero);
         }
 
         private void UnregisterCustomCommandEvent()
         {
-            Interop.MediaControllerServer.UnsetCustomCmdRecvCb(_handle);
+            Interop.MediaControllerServer.UnsetCustomCmdRecvCb(SafeHandle);
         }
     }
 }