- add to release native memory and check valid handle.
- apply C# coding rule.
Change-Id: Id46803b69a2467e2e8e35ffdbadfb82865d928f6
Signed-off-by: Jiyong Min <jiyong.min@samsung.com>
using Tizen.Multimedia.MediaController;
internal static partial class Interop
-{
+{\r
internal static partial class MediaControllerClient
{
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void ServerUpdatedCallback(string serverName, MediaControllerServerState serverState, IntPtr userData);
+ internal delegate void ServerUpdatedCallback(IntPtr serverName, MediaControllerServerState serverState, IntPtr userData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void PlaybackUpdatedCallback(string serverName, IntPtr playback, IntPtr userData);
+ internal delegate void PlaybackUpdatedCallback(IntPtr serverName, IntPtr playback, IntPtr userData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void MetadataUpdatedCallback(string serverName, IntPtr metadata, IntPtr userData);
+ internal delegate void MetadataUpdatedCallback(IntPtr serverName, IntPtr metadata, IntPtr userData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void ShuffleModeUpdatedCallback(string serverName, MediaControllerShuffleMode shuffleMode, IntPtr userData);
+ internal delegate void ShuffleModeUpdatedCallback(IntPtr serverName, MediaControllerShuffleMode shuffleMode, IntPtr userData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void RepeatModeUpdatedCallback(string serverName, MediaControllerRepeatMode repeatMode, IntPtr userData);
+ internal delegate void RepeatModeUpdatedCallback(IntPtr serverName, MediaControllerRepeatMode repeatMode, IntPtr userData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void CommandReplyRecievedCallback(string serverName, int result, IntPtr bundle, IntPtr userData);
+ internal delegate void CommandReplyRecievedCallback(IntPtr serverName, int result, IntPtr bundle, IntPtr userData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate bool SubscribedServerCallback(string serverName, IntPtr userData);
+ internal delegate bool SubscribedServerCallback(IntPtr serverName, IntPtr userData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate bool ActivatedServerCallback(string serverName, IntPtr userData);
+ internal delegate bool ActivatedServerCallback(IntPtr serverName, IntPtr userData);
[DllImport(Libraries.MediaController, EntryPoint = "mc_client_create")]
internal static extern MediaControllerError Create(out IntPtr handle);
internal static extern MediaControllerError DestroyPlayback(IntPtr playback);
[DllImport(Libraries.MediaController, EntryPoint = "mc_client_get_metadata")]
- internal static extern MediaControllerError GetMetadata(IntPtr metadata, MediaControllerAttributes attribute, out string value);
+ private static extern MediaControllerError GetMetadata(IntPtr metadata, MediaControllerAttributes attribute, out IntPtr value);
+
+ internal static string GetMetadata(IntPtr handle, MediaControllerAttributes attr)
+ {
+ IntPtr valuePtr = IntPtr.Zero;
+
+ try
+ {
+ var ret = GetMetadata(handle, attr, out valuePtr);
+ MediaControllerValidator.ThrowIfError(ret, "Failed to get value for " + attr);
+ return Marshal.PtrToStringAnsi(valuePtr);
+ }
+ finally
+ {
+ Libc.Free(valuePtr);
+ }
+ }
[DllImport(Libraries.MediaController, EntryPoint = "mc_client_destroy_metadata")]
internal static extern MediaControllerError DestroyMetadata(IntPtr metadata);
[DllImport(Libraries.MediaController, EntryPoint = "mc_client_get_latest_server_info")]
- internal static extern MediaControllerError GetLatestServer(IntPtr handle, out string serverName, out MediaControllerServerState serverState);
+ internal static extern MediaControllerError GetLatestServer(IntPtr handle, out IntPtr serverName, out MediaControllerServerState serverState);
[DllImport(Libraries.MediaController, EntryPoint = "mc_client_get_server_playback_info")]
internal static extern MediaControllerError GetServerPlayback(IntPtr handle, string serverName, out IntPtr playback);
internal static partial class MediaControllerServer
{
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void PlaybackStateCommandRecievedCallback(string clientName, MediaControllerPlaybackState state, IntPtr userData);
+ internal delegate void PlaybackStateCommandRecievedCallback(IntPtr clientName, MediaControllerPlaybackState state, IntPtr userData);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void CustomCommandRecievedCallback(string clientName, string command, IntPtr bundle, IntPtr userData);
+ internal delegate void CustomCommandRecievedCallback(IntPtr clientName, IntPtr command, IntPtr bundle, IntPtr userData);
[DllImport(Libraries.MediaController, EntryPoint = "mc_server_create")]
internal static extern MediaControllerError Create(out IntPtr handle);
/// </remarks>
public class CustomCommandEventArgs : EventArgs
{
- internal CustomCommandEventArgs (string name, string command, Bundle bundle)
+ internal CustomCommandEventArgs(string name, string command, Bundle bundle)
{
ClientName = name;
Command = command;
/// </remarks>
public class CustomCommandReplyEventArgs : EventArgs
{
- internal CustomCommandReplyEventArgs (string serverName, int result, Bundle bundle)
+ internal CustomCommandReplyEventArgs(string serverName, int result, Bundle bundle)
{
ServerName = serverName;
Result = result;
using System;
using System.Collections.Generic;
+using System.Runtime.InteropServices;
using System.Threading.Tasks;
using Tizen.Applications;
namespace Tizen.Multimedia.MediaController
-{\r
-\r
+{
+
/// <summary>
/// The MediaControllerClient class provides APIs required for media-controller-client.
/// </summary>
- /// <privilege>\r
- /// http://tizen.org/privilege/mediacontroller.client\r
+ /// <privilege>
+ /// http://tizen.org/privilege/mediacontroller.client
/// </privilege>
/// <remarks>
/// The MediaControllerClient APIs provides functions to get media information from server.
private EventHandler<CustomCommandReplyEventArgs> _customcommandReply;
private Interop.MediaControllerClient.CommandReplyRecievedCallback _customcommandReplyCallback;
+ private bool IsValidHandle
+ {
+ get { return (this._handle != IntPtr.Zero); }
+ }
+
/// <summary>
/// The constructor of MediaControllerClient class.
/// </summary>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
/// <exception cref="UnauthorizedAccessException">Thrown when the access is denied for media controller client</exception>
- public MediaControllerClient ()
+ public MediaControllerClient()
{
MediaControllerValidator.ThrowIfError(
Interop.MediaControllerClient.Create(out _handle), "Create client failed");
}
- ~MediaControllerClient ()
+ ~MediaControllerClient()
{
Dispose(false);
}
protected virtual void Dispose(bool disposing)
{
- if(!_disposed)
+ if (!_disposed)
{
- if(disposing)
+ if (disposing)
{
// To be used if there are any other disposable objects
}
- if(_handle != IntPtr.Zero)
+
+ if (IsValidHandle)
{
Interop.MediaControllerClient.Destroy(_handle);
_handle = IntPtr.Zero;
}
+
_disposed = true;
}
}
{
add
{
- if(_serverUpdated == null)
+ if (_serverUpdated == null)
{
RegisterServerUpdatedEvent();
}
+
_serverUpdated += value;
}
+
remove
{
_serverUpdated -= value;
- if(_serverUpdated == null)
+ if (_serverUpdated == null)
{
UnregisterServerUpdatedEvent();
}
{
add
{
- if(_playbackUpdated == null)
+ if (_playbackUpdated == null)
{
RegisterPlaybackUpdatedEvent();
}
+
_playbackUpdated += value;
}
+
remove
{
_playbackUpdated -= value;
- if(_playbackUpdated == null)
+ if (_playbackUpdated == null)
{
UnregisterPlaybackUpdatedEvent();
}
{
add
{
- if(_metadataUpdated == null)
+ if (_metadataUpdated == null)
{
RegisterMetadataUpdatedEvent();
}
+
_metadataUpdated += value;
}
+
remove
{
_metadataUpdated -= value;
- if(_metadataUpdated == null)
+ if (_metadataUpdated == null)
{
UnregisterMetadataUpdatedEvent();
}
{
add
{
- if(_shufflemodeUpdated == null)
+ if (_shufflemodeUpdated == null)
{
RegisterShuffleModeUpdatedEvent();
}
+
_shufflemodeUpdated += value;
}
+
remove
{
_shufflemodeUpdated -= value;
- if(_shufflemodeUpdated == null)
+ if (_shufflemodeUpdated == null)
{
UnregisterShuffleModeUpdatedEvent();
}
{
add
{
- if(_repeatmodeUpdated == null)
+ if (_repeatmodeUpdated == null)
{
RegisterRepeatModeUpdatedEvent();
}
- _repeatmodeUpdated += value;
+ _repeatmodeUpdated += value;
}
+
remove
{
_repeatmodeUpdated -= value;
- if(_repeatmodeUpdated == null)
+ if (_repeatmodeUpdated == null)
{
UnregisterRepeatModeUpdatedEvent();
}
{
add
{
- if(_customcommandReply == null)
+ if (_customcommandReply == null)
{
- _customcommandReplyCallback = (string serverName, int result, IntPtr bundle, IntPtr userData) =>
- {
- SafeBundleHandle bundleHandle = new SafeBundleHandle(bundle, true);
- Applications.Bundle _bundle = new Bundle(bundleHandle);
- CustomCommandReplyEventArgs eventArgs = new CustomCommandReplyEventArgs(serverName, result, _bundle);
+ _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
_customcommandReply?.Invoke(this, eventArgs);
};
}
+
_customcommandReply += value;
}
+
remove
{
_customcommandReply -= value;
- if(_customcommandReply == null)
+ if (_customcommandReply == null)
{
_customcommandReplyCallback = null;
}
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
public ServerInformation GetLatestServer()
{
- string _name = null;
- MediaControllerServerState _state = MediaControllerServerState.None;
+ IntPtr name = IntPtr.Zero;
+ MediaControllerServerState state = MediaControllerServerState.None;
- MediaControllerValidator.ThrowIfError(\r
- Interop.MediaControllerClient.GetLatestServer(_handle, out _name, out _state), "Get Latest server failed");\r
-\r
- return new ServerInformation(_name, (MediaControllerServerState)_state);\r
+ try\r
+ {
+ MediaControllerValidator.ThrowIfError(
+ Interop.MediaControllerClient.GetLatestServer(_handle, out name, out state), "Get Latest server failed");\r
+ return new ServerInformation(Marshal.PtrToStringAnsi(name), (MediaControllerServerState)state);\r
+ }
+ finally
+ {\r
+ Interop.Libc.Free(name);\r
+ }
}
/// <summary>
/// <returns>The playback state and playback position of the specific media controller server application:MediaControllerPlayback object</returns>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
- public MediaControllerPlayback GetPlayback(String serverName)
+ public MediaControllerPlayback GetPlayback(string serverName)
{
- IntPtr _playbackHandle = IntPtr.Zero;
+ IntPtr playbackHandle = IntPtr.Zero;
+ MediaControllerPlayback playback = null;
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetServerPlayback(_handle, serverName, out _playbackHandle), "Get Playback handle failed");
+ try
+ {
+ MediaControllerValidator.ThrowIfError(
+ Interop.MediaControllerClient.GetServerPlayback(_handle, serverName, out playbackHandle), "Get Playback handle failed");
+ playback = new MediaControllerPlayback(playbackHandle);
+ }
+ finally
+ {
+ if (playbackHandle != IntPtr.Zero)\r
+ {
+ MediaControllerValidator.ThrowIfError(
+ Interop.MediaControllerClient.DestroyPlayback(playbackHandle), "Destroy playback failed");\r
+ }
+ }
- return new MediaControllerPlayback (_playbackHandle);
+ return playback;
}
/// <summary>
/// <returns>The metadata information of the specific media controller server application:MediaControllerMetadata object</returns>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
- public MediaControllerMetadata GetMetadata(String serverName)
+ public MediaControllerMetadata GetMetadata(string serverName)
{
- IntPtr _metadataHandle = IntPtr.Zero;
+ IntPtr metadataHandle = IntPtr.Zero;
+ MediaControllerMetadata metadata = null;
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetServerMetadata(_handle, serverName, out _metadataHandle), "Get Metadata handle failed");
+ try
+ {
+ MediaControllerValidator.ThrowIfError(
+ Interop.MediaControllerClient.GetServerMetadata(_handle, serverName, out metadataHandle), "Get Metadata handle failed");
+ metadata = new MediaControllerMetadata(metadataHandle);
+ }
+ finally
+ {\r
+ if (metadataHandle != IntPtr.Zero)\r
+ {\r
+ MediaControllerValidator.ThrowIfError(
+ Interop.MediaControllerClient.DestroyMetadata(metadataHandle), "Destroy metadata failed");\r
+ }
+ }
- return new MediaControllerMetadata (_metadataHandle);
+ return metadata;
}
/// <summary>
/// <returns>The shuffle mode of the specific media controller server application:MediaControllerShuffleMode enum</returns>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
- public MediaControllerShuffleMode GetShuffleMode(String serverName)
+ public MediaControllerShuffleMode GetShuffleMode(string serverName)
{
- MediaControllerShuffleMode _shuffleMode = MediaControllerShuffleMode.Off;
+ MediaControllerShuffleMode shuffleMode = MediaControllerShuffleMode.Off;
MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetServerShuffleMode(_handle, serverName, out _shuffleMode), "Get ShuffleMode failed");
+ Interop.MediaControllerClient.GetServerShuffleMode(_handle, serverName, out shuffleMode), "Get ShuffleMode failed");
- return _shuffleMode;
+ return shuffleMode;
}
/// <summary>
/// <returns>The repeat mode of the specific media controller server application:MediaControllerRepeatMode enum</returns>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
- public MediaControllerRepeatMode GetRepeatMode(String serverName)
+ public MediaControllerRepeatMode GetRepeatMode(string serverName)
{
- MediaControllerRepeatMode _repeatMode = MediaControllerRepeatMode.Off;
+ MediaControllerRepeatMode repeatMode = MediaControllerRepeatMode.Off;
MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetServerRepeatMode(_handle, serverName, out _repeatMode), "Get RepeatMode failed");
+ Interop.MediaControllerClient.GetServerRepeatMode(_handle, serverName, out repeatMode), "Get RepeatMode failed");
- return _repeatMode;
+ return repeatMode;
}
/// <summary>
private void RegisterServerUpdatedEvent()
{
- _serverUpdatedCallback = (string serverName, MediaControllerServerState serverState, IntPtr userData) =>
+ _serverUpdatedCallback = (IntPtr serverName, MediaControllerServerState serverState, IntPtr userData) =>
{
- ServerUpdatedEventArgs eventArgs = new ServerUpdatedEventArgs(serverName, serverState);
+ ServerUpdatedEventArgs eventArgs = new ServerUpdatedEventArgs(Marshal.PtrToStringAnsi(serverName), serverState);
_serverUpdated?.Invoke(this, eventArgs);
};
Interop.MediaControllerClient.SetServerUpdatedCb(_handle, _serverUpdatedCallback, IntPtr.Zero);
private void RegisterPlaybackUpdatedEvent()
{
- _playbackUpdatedCallback = (string serverName, IntPtr playback, IntPtr userData) =>
+ _playbackUpdatedCallback = (IntPtr serverName, IntPtr playback, IntPtr userData) =>
{
- PlaybackUpdatedEventArgs eventArgs = new PlaybackUpdatedEventArgs(serverName, playback);
+ PlaybackUpdatedEventArgs eventArgs = new PlaybackUpdatedEventArgs(Marshal.PtrToStringAnsi(serverName), playback);
_playbackUpdated?.Invoke(this, eventArgs);
};
Interop.MediaControllerClient.SetPlaybackUpdatedCb(_handle, _playbackUpdatedCallback, IntPtr.Zero);
private void RegisterMetadataUpdatedEvent()
{
- _metadataUpdatedCallback = (string serverName, IntPtr metadata, IntPtr userData) =>
+ _metadataUpdatedCallback = (IntPtr serverName, IntPtr metadata, IntPtr userData) =>
{
- MetadataUpdatedEventArgs eventArgs = new MetadataUpdatedEventArgs(serverName, metadata);
+ MetadataUpdatedEventArgs eventArgs = new MetadataUpdatedEventArgs(Marshal.PtrToStringAnsi(serverName), metadata);
_metadataUpdated?.Invoke(this, eventArgs);
};
Interop.MediaControllerClient.SetMetadataUpdatedCb(_handle, _metadataUpdatedCallback, IntPtr.Zero);
private void RegisterShuffleModeUpdatedEvent()
{
- _shufflemodeUpdatedCallback = (string serverName, MediaControllerShuffleMode shuffleMode, IntPtr userData) =>
+ _shufflemodeUpdatedCallback = (IntPtr serverName, MediaControllerShuffleMode shuffleMode, IntPtr userData) =>
{
- ShuffleModeUpdatedEventArgs eventArgs = new ShuffleModeUpdatedEventArgs(serverName, shuffleMode);
+ ShuffleModeUpdatedEventArgs eventArgs = new ShuffleModeUpdatedEventArgs(Marshal.PtrToStringAnsi(serverName), shuffleMode);
_shufflemodeUpdated?.Invoke(this, eventArgs);
};
private void RegisterRepeatModeUpdatedEvent()
{
- _repeatmodeUpdatedCallback = (string serverName, MediaControllerRepeatMode repeatMode, IntPtr userData) =>
+ _repeatmodeUpdatedCallback = (IntPtr serverName, MediaControllerRepeatMode repeatMode, IntPtr userData) =>
{
- RepeatModeUpdatedEventArgs eventArgs = new RepeatModeUpdatedEventArgs(serverName, repeatMode);
+ RepeatModeUpdatedEventArgs eventArgs = new RepeatModeUpdatedEventArgs(Marshal.PtrToStringAnsi(serverName), repeatMode);
_repeatmodeUpdated?.Invoke(this, eventArgs);
};
{
List<string> subscribedServerCollections = new List<string>();
- Interop.MediaControllerClient.SubscribedServerCallback serverCallback = (string serverName, IntPtr userData) =>
+ Interop.MediaControllerClient.SubscribedServerCallback serverCallback = (IntPtr serverName, IntPtr userData) =>
{
- subscribedServerCollections.Add (serverName);
+ subscribedServerCollections.Add(Marshal.PtrToStringAnsi(serverName));
return true;
};
{
List<string> activatedServerCollections = new List<string>();
- Interop.MediaControllerClient.ActivatedServerCallback serverCallback = (string serverName, IntPtr userData) =>
+ Interop.MediaControllerClient.ActivatedServerCallback serverCallback = (IntPtr serverName, IntPtr userData) =>
{
- activatedServerCollections.Add(serverName);\r
+ activatedServerCollections.Add(Marshal.PtrToStringAnsi(serverName));\r
return true;
};
// Do nothing
}
- internal MediaControllerMetadata(IntPtr _handle) {
- string _title;
- string _artist;
- string _album;
- string _author;
- string _genre;
- string _duration;
- string _date;
- string _copyright;
- string _description;
- string _track_number;
- string _picture;
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Title, out _title),
- "Get Title failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Artist, out _artist),
- "Get Artist failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Album, out _album),
- "Get Album failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Author, out _author),
- "Get Author failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Genre, out _genre),
- "Get Genre failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Duration, out _duration),
- "Get Duration failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Date, out _date),
- "Get Date failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Copyright, out _copyright),
- "Get Copyright failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Description, out _description),
- "Get Description failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.TrackNumber, out _track_number),
- "Get TrackNumber failed");
-
- MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetMetadata(_handle, MediaControllerAttributes.Picture, out _picture),
- "Get Picture failed");
-
- Title = _title;
- Artist = _artist;
- Album = _album;
- Author = _author;
- Genre = _genre;
- Duration = _duration;
- Date = _date;
- Copyright = _copyright;
- Description = _description;
- TrackNumber = _track_number;
- Picture = _picture;
+ internal MediaControllerMetadata(IntPtr handle)
+ {
+ if (handle == IntPtr.Zero)
+ {
+ throw new InvalidOperationException("MediaControllerMetadata is not valid.");
+ }
+
+ Title = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Title);
+ Artist = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Artist);
+ Album = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Album);
+ Author = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Author);
+ Genre = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Genre);
+ Duration = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Duration);
+ Date = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Date);
+ Copyright = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Copyright);
+ Description = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Description);
+ TrackNumber = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.TrackNumber);
+ Picture = Interop.MediaControllerClient.GetMetadata(handle, MediaControllerAttributes.Picture);
}
/// <summary>
/// <summary>
/// The constructor of MediaControllerPlayback class.
/// </summary>
- public MediaControllerPlayback(MediaControllerPlaybackState state, ulong position) {
+ /// <param name="state">
+ /// The state of the playback which is playing in MediaConttoller server application
+ /// </param>
+ /// <param name="position">
+ /// The position of the playback which is playing in MediaConttoller server application
+ /// </param>
+ public MediaControllerPlayback(MediaControllerPlaybackState state, ulong position)
+ {
State = state;
Position = position;
}
- internal MediaControllerPlayback(IntPtr _handle) {
+ internal MediaControllerPlayback(IntPtr handle)
+ {
MediaControllerPlaybackState state = MediaControllerPlaybackState.None;
ulong position = 0L;
+ if (handle == IntPtr.Zero)
+ {
+ throw new InvalidOperationException("MediaControllerPlayback is not valid.");
+ }
+
MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetPlaybackState(_handle, out state), "Get Playback state failed");
+ Interop.MediaControllerClient.GetPlaybackState(handle, out state), "Get Playback state failed");
MediaControllerValidator.ThrowIfError(
- Interop.MediaControllerClient.GetPlaybackPosition(_handle, out position), "Get Playback position failed");
+ Interop.MediaControllerClient.GetPlaybackPosition(handle, out position), "Get Playback position failed");
State = state;
Position = position;
*/
using System;
+using System.Runtime.InteropServices;
using Tizen.Applications;
namespace Tizen.Multimedia.MediaController
private EventHandler<CustomCommandEventArgs> _customCommand;
private Interop.MediaControllerServer.CustomCommandRecievedCallback _customCommandCallback;
+ private bool IsValidHandle
+ {
+ get { return (this._handle != IntPtr.Zero); }
+ }
+
/// <summary>
/// The constructor of MediaControllerServer class.
/// </summary>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
/// <exception cref="UnauthorizedAccessException">Thrown when the access is denied for media controller client</exception>
- public MediaControllerServer ()
+ public MediaControllerServer()
{
MediaControllerValidator.ThrowIfError(
Interop.MediaControllerServer.Create(out _handle), "Create server failed");
}
- ~MediaControllerServer ()
+ ~MediaControllerServer()
{
Dispose(false);
}
protected virtual void Dispose(bool disposing)
{
- if(!_disposed)
+ if (!_disposed)
{
- if(disposing)
+ if (disposing)
{
// To be used if there are any other disposable objects
}
- if(_handle != IntPtr.Zero)
+
+ if (IsValidHandle)
{
Interop.MediaControllerServer.Destroy(_handle);
_handle = IntPtr.Zero;
}
+
_disposed = true;
}
}
{
add
{
- if(_playbackCommand == null)
+ if (_playbackCommand == null)
{
RegisterPlaybackCmdRecvEvent();
}
+
_playbackCommand += value;
}
+
remove
{
_playbackCommand -= value;
- if(_playbackCommand == null)
+ if (_playbackCommand == null)
{
UnregisterPlaybackCmdRecvEvent();
}
{
add
{
- if(_customCommand == null)
+ if (_customCommand == null)
{
RegisterCustomCommandEvent();
}
+
_customCommand += value;
}
+
remove
{
_customCommand -= value;
- if(_customCommand == null)
+ if (_customCommand == null)
{
UnregisterCustomCommandEvent();
}
/// Send reply for command from server to client </summary>
/// <param name="clientName"> client name to recieve reply </param>
/// <param name="result"> result to run command </param>
- /// <param name="bundleData"> Bundle data </param>
+ /// <param name="bundle"> Bundle to send various data </param>
/// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
/// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
public void SendCustomCommandReply(string clientName, int result, Bundle bundle)
private void RegisterPlaybackCmdRecvEvent()
{
- _playbackCommandCallback = (string clientName, MediaControllerPlaybackState state, IntPtr userData) =>
+ _playbackCommandCallback = (IntPtr clientName, MediaControllerPlaybackState state, IntPtr userData) =>
{
- PlaybackStateCommandEventArgs eventArgs = new PlaybackStateCommandEventArgs(clientName, state);
+ PlaybackStateCommandEventArgs eventArgs = new PlaybackStateCommandEventArgs(Marshal.PtrToStringAnsi(clientName), state);
_playbackCommand?.Invoke(this, eventArgs);
};
Interop.MediaControllerServer.SetPlaybackStateCmdRecvCb(_handle, _playbackCommandCallback, IntPtr.Zero);
private void RegisterCustomCommandEvent()
{
- _customCommandCallback = (string clientName, string command, IntPtr bundle, IntPtr userData) =>
+ _customCommandCallback = (IntPtr clientName, IntPtr command, IntPtr bundle, IntPtr userData) =>
{
- SafeBundleHandle bundleHandle = new SafeBundleHandle(bundle, true);
- Applications.Bundle _bundle = new Bundle(bundleHandle);
- CustomCommandEventArgs eventArgs = new CustomCommandEventArgs(clientName, command, _bundle);
+ SafeBundleHandle safeBundleHandle = new SafeBundleHandle(bundle, true);
+ Bundle bundleData = new Bundle(safeBundleHandle);
+ CustomCommandEventArgs eventArgs = new CustomCommandEventArgs(Marshal.PtrToStringAnsi(clientName), Marshal.PtrToStringAnsi(command), bundleData);
_customCommand?.Invoke(this, eventArgs);
- };
+ };
Interop.MediaControllerServer.SetCustomCmdRecvCb(_handle, _customCommandCallback, IntPtr.Zero);
}
/// </remarks>
public class MetadataUpdatedEventArgs : EventArgs
{
- internal MetadataUpdatedEventArgs (string name, IntPtr handle)
+ internal MetadataUpdatedEventArgs(string name, IntPtr handle)
{
ServerName = name;
- Metadata = new MediaControllerMetadata (handle);
+ Metadata = new MediaControllerMetadata(handle);
}
/// <summary>
/// </remarks>
public class PlaybackStateCommandEventArgs : EventArgs
{
- internal PlaybackStateCommandEventArgs (string name, MediaControllerPlaybackState state)
+ internal PlaybackStateCommandEventArgs(string name, MediaControllerPlaybackState state)
{
ClientName = name;
State = state;
/// </remarks>
public class PlaybackUpdatedEventArgs : EventArgs
{
- internal PlaybackUpdatedEventArgs (string name, IntPtr handle)
+ internal PlaybackUpdatedEventArgs(string name, IntPtr handle)
{
ServerName = name;
- PlaybackInfo = new MediaControllerPlayback (handle);
+ PlaybackInfo = new MediaControllerPlayback(handle);
}
/// <summary>
/// </remarks>
public class RepeatModeUpdatedEventArgs : EventArgs
{
- internal RepeatModeUpdatedEventArgs (string name, MediaControllerRepeatMode mode)
+ internal RepeatModeUpdatedEventArgs(string name, MediaControllerRepeatMode mode)
{
ServerName = name;
RepeatMode = mode;
{
internal ServerUpdatedEventArgs(string name, MediaControllerServerState state)
{
- ServerInfo = new ServerInformation (name, state);
+ ServerInfo = new ServerInformation(name, state);
}
/// <summary>
/// </remarks>
public class ShuffleModeUpdatedEventArgs : EventArgs
{
- internal ShuffleModeUpdatedEventArgs (string name, MediaControllerShuffleMode mode)
+ internal ShuffleModeUpdatedEventArgs(string name, MediaControllerShuffleMode mode)
{
ServerName = name;
ShuffleMode = mode;
projects / platform / core / csapi / tizenfx.git / commitdiff