private async void TestCaliperNetEventAsync()
{
// this is the example code from the caliper-net readme file with some small changes.
// this code will run from the editor and successfully send a caliper event to the
// endpoint specified but does not work correctly when built to an iOS device.
var sensor = new CaliperSensor("milk-unity-caliper-test");
System.Uri endpointURI = new System.Uri("https://lti.tools/caliper/event?key=milk");
string endpointID = sensor.RegisterEndpoint(new CaliperEndpointOptions(endpointURI));
var now = System.DateTime.Now;
Debug.Log(">>>>> Attempt async at: " + now);
// dummy event taken from example
var mediaEvent = new MediaEvent("event id", ImsGlobal.Caliper.Events.Action.Paused)
{
Actor = new Person(deviceID),
Object = new VideoObject("https://example.com/super-media-tool/video/1225"),
Target = new MediaLocation("Action button"),
EventTime = Instant.FromUtc(now.Year, now.Month, now.Day, now.TimeOfDay.Hours, now.TimeOfDay.Minutes),
EdApp = new SoftwareApplication("https://example.com/super-media-tool")
{
Name = "Super Media Tool"
}
};
bool success = await sensor.SendAsync(mediaEvent);
Debug.Log(">>>>> Success: " + success);
}
private void OnMediaSessionEvent(MediaEvent mEvent)
{
var type = mEvent.TypeInfo;
//Console.WriteLine("MediaEvent {0}", type);
//Console.Out.Flush();
switch (type)
{
case MediaEventTypes.SessionClosed:
musicMediaEvents.Enqueue(new SoundMusicEventNotification(SoundMusicEvent.MusicPlayerClosed, mEvent));
break;
case MediaEventTypes.SessionEnded:
musicMediaEvents.Enqueue(new SoundMusicEventNotification(SoundMusicEvent.EndOfTrackReached, mEvent));
break;
case MediaEventTypes.SessionTopologyStatus:
if (mEvent.Get(EventAttributeKeys.TopologyStatus) == TopologyStatus.Ready)
{
musicMediaEvents.Enqueue(new SoundMusicEventNotification(SoundMusicEvent.ReadyToBePlayed, mEvent));
}
break;
case MediaEventTypes.Error:
break;
case MediaEventTypes.SourceMetadataChanged:
break;
}
}
void UIE_DeleteEvent(object sender, MediaEvent e)
{
if (e != null)
{
if (MessageBox.Show("Bạn có muốn xóa media này không?", "Thông báo", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
e.delete();
this.LoadUI(this.playlist);
}
}
}
public void GetEvent(uint dwFlags, /*IMFMediaEvent*/ out IntPtr ppEvent)
{
MediaEvent ev = null;
try {
_eventQueue.GetEvent((int)dwFlags, out ev);
ppEvent = ev.Detach();
} finally {
ev?.Dispose();
}
}
public void OnMediaEvent(MediaEvent e)
{
if (e is PlaybackBufferStateEvent)
{
var evt = e as PlaybackBufferStateEvent;
if (evt.BufferState == PlaybackBufferStateEvent.State.Low)
{
_pushDataEvent.Set();
}
}
}
/// <summary>
/// The OnTimestampEventRight method.
/// </summary>
/// <param name="timeEvent">The <paramref name="timeEvent"/> parameter.</param>
private static void OnTimestampEventRight(MediaEvent timeEvent)
{
// Note that the timestamp is in UTC by default, so you must convert it to local time
// if that is the format required.
var timestamp = timeEvent.Timestamp.ToLocalTime().ToString("s");
MainForm.Instance.lblTimestampRight.BeginInvoke((MethodInvoker) delegate
{
MainForm.Instance.lblTimestampRight.Text = timestamp;
});
}
private void EventProc()
{
logger.Debug("EventProc() BEGIN");
MediaEventGenerator eventGen = null;
try
{
eventGen = encoder.QueryInterface <MediaEventGenerator>();
while (!closing)
{
MediaEvent mediaEvent = null;
try
{
mediaEvent = eventGen.GetEvent(true);
if (closing)
{
break;
}
HandleMediaEvent(mediaEvent);
}
catch (Exception ex)
{
logger.Error(ex);
Thread.Sleep(10);
}
finally
{
if (mediaEvent != null)
{
mediaEvent.Dispose();
mediaEvent = null;
}
}
}
}
finally
{
using (var shutdown = eventGen.QueryInterface <Shutdownable>())
{
shutdown.Shutdown();
}
eventGen?.Dispose();
Close();
}
logger.Debug("EventProc() END");
}
public override void Invoke(AsyncResult asyncResult)
{
MediaEvent ev = _player._session.EndGetEvent(asyncResult);
// Trigger an "on Video Ended" event here if needed
if (ev.TypeInfo == MediaEventTypes.SessionTopologyStatus &&
ev.Get(EventAttributeKeys.TopologyStatus) == TopologyStatus.Ready)
{
_player.OnTopologyReady();
}
_player._session.BeginGetEvent(this, null);
}
private static int OnSynchronizedEventImpl(IntPtr thisPtr, IntPtr mediaEvent)
{
try
{
var shadow = ToShadow <CaptureEngineOnSampleCallback2Shadow>(thisPtr);
var callback = (CaptureEngineOnSampleCallback2)shadow.Callback;
var eventRef = new MediaEvent(mediaEvent);
callback.OnSynchronizedEvent(eventRef);
}
catch (Exception exception)
{
return((int)SharpDX.Result.GetResultFromException(exception));
}
return(Result.Ok.Code);
}
public void MediaEvent_MatchesReferenceJson()
{
var mediaEvent = new MediaEvent(Action.Paused)
{
Actor = TestEntities.User554433,
Object = TestEntities.VideoWithLearningObjective,
Target = TestEntities.VideoWithLearningObjective_Location710,
EventTime = TestEntities.DefaultStartedAtTime,
EdApp = TestEntities.SuperMediaTool,
Group = TestEntities.AmRev101_Group001,
Membership = TestEntities.User554433_AmRev101_CourseSection001_Membership
};
JsonAssertions.AssertSameObjectJson(mediaEvent, "caliperMediaEvent");
}
public async Task <IActionResult> EditMediaEvent([Bind("ID,Title,Time,Image,Image_Title,Caption,Description1,Description2")] MediaEvent mediaEvent)
{
if (ModelState.IsValid)
{
try
{
_context.Update(mediaEvent);
await _context.SaveChangesAsync();
}
catch (DbUpdateException ex)
{
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persister " +
"see your system administrator for assitance.");
}
}
return(View(mediaEvent));
}
public void EndGetEvent(/*IMFAsyncResult*/ IntPtr pResult, /*IMFMediaEvent*/ out IntPtr ppEvent)
{
if (pResult == IntPtr.Zero)
{
throw new ArgumentNullException();
}
var ar = new AsyncResult(pResult);
MediaEvent ev = null;
try {
_eventQueue.EndGetEvent(ar, out ev);
ppEvent = ev.Detach();
} finally {
ev?.Dispose();
ar.NativePointer = IntPtr.Zero;
ar.Dispose();
}
}
private void ProcessMediaEvent(MediaEvent mediaEvent)
{
switch (mediaEvent.ObjectType)
{
case enMediaEventObjectTypes.MediaEventObjectType_AgentStatus:
IAgentStatusEvent statusEvent = (IAgentStatusEvent)mediaEvent;
ProcessAgentStatusEvent(statusEvent);
break;
case enMediaEventObjectTypes.MediaEventObjectType_Delivered:
var objDeliveredEvent = mediaEvent as DeliveredEvent;
_logger.Info("MediaEventObjectType_Delivered callID: " + objDeliveredEvent.CallID);
break;
case enMediaEventObjectTypes.MediaEventObjectType_Established:
var objEstablishedEvent = mediaEvent as EstablishedEvent;
_logger.Info("MediaEventObjectType_Established " + objEstablishedEvent.CallID);
break;
case enMediaEventObjectTypes.MediaEventObjectType_Queued:
var objQueuedEvent = mediaEvent as QueuedEvent;
_logger.Info("MediaEventObjectType_Queued " + objQueuedEvent.CallID);
break;
case enMediaEventObjectTypes.MediaEventObjectType_Diverted:
var objDivertedEvent = mediaEvent as DivertedEvent;
_logger.Info("MediaEventObjectType_Diverted " + objDivertedEvent.CallID);
break;
case enMediaEventObjectTypes.MediaEventObjectType_Disconnected:
var objDisconnectEvent = mediaEvent as DisconnectedEvent;
_logger.Info("MediaEventObjectType_Disconnected CallID: " + objDisconnectEvent.CallID + " Reason " + objDisconnectEvent.Reason);
callDetailGridUpdateEvent?.Invoke(true, objDisconnectEvent.CallID);
lock (activeCallsDict)
activeCallsDict.Remove(objDisconnectEvent.CallID);
break;
case enMediaEventObjectTypes.MediaEventObjectType_ManagerStateChanged:
IManagerStateChangedEvent stateEvent = (IManagerStateChangedEvent)mediaEvent;
_logger.Info("MediaEvent ManagerStateChanged ## " + stateEvent.State);
break;
}
}
private void HandleMediaEvent(MediaEvent mediaEvent)
{
// logger.Debug("GetEvent(...) " + mediaEvent.TypeInfo);
if (closing)
{
logger.Warn("HandleMediaEvent(...) " + mediaEvent.ToString());
return;
}
if (mediaEvent.TypeInfo == MediaEventTypes.TransformNeedInput)
{
Interlocked.Increment(ref inputRequests);
syncEvent.Set();
//logger.Debug("inputRequests " + inputRequests);
}
else if (mediaEvent.TypeInfo == MediaEventTypes.TransformHaveOutput)
{
Interlocked.Increment(ref outputRequests);
syncEvent.Set();
}
else if (mediaEvent.TypeInfo == MediaEventTypes.TransformDrainComplete)
{
logger.Warn("_MediaEventTypes.TransformDrainComplete ");
closing = true;
//Close();
}
else if (mediaEvent.TypeInfo == MediaEventTypes.TransformMarker)
{
logger.Warn("_MediaEventTypes.TransformMarker");
}
else if (mediaEvent.TypeInfo == MediaEventTypes.TransformInputStreamStateChanged)
{
logger.Warn("_MediaEventTypes.TransformInputStreamStateChanged");
}
else
{
logger.Warn("_MediaEventTypes " + mediaEvent.TypeInfo);
}
}
private void HandleMediaEvent(MediaEvent mediaEvent)
{
// logger.Debug("GetEvent(...) " + mediaEvent.TypeInfo);
if (closing)
{
logger.Warn("HandleMediaEvent(...) " + mediaEvent.ToString());
return;
}
if (mediaEvent.TypeInfo == MediaEventTypes.TransformNeedInput)
{
OnTransformNeedInput();
//logger.Debug("inputRequests " + inputRequests);
}
else if (mediaEvent.TypeInfo == MediaEventTypes.TransformHaveOutput)
{
OnTransformHaveOutput();
}
else if (mediaEvent.TypeInfo == MediaEventTypes.TransformDrainComplete)
{
logger.Warn("_MediaEventTypes.TransformDrainComplete ");
OnTransformDrainComplete();
}
else if (mediaEvent.TypeInfo == MediaEventTypes.TransformMarker)
{
logger.Warn("_MediaEventTypes.TransformMarker");
}
else if (mediaEvent.TypeInfo == MediaEventTypes.TransformInputStreamStateChanged)
{
logger.Warn("_MediaEventTypes.TransformInputStreamStateChanged");
}
else
{
logger.Warn("_MediaEventTypes " + mediaEvent.TypeInfo);
}
}
public static MediaEvent toMediaEvent(this MySqlDataReader reader)
{
if (reader.HasRows)
{
MediaEvent d = null;
while (reader.Read())
{
if (!reader.IsDBNull(0))
{
d = new MediaEvent();
d.ID = reader.GetInt32(Define.detail_id);
d.media_id = reader.GetInt32(Define.media_id);
d.playlist_id = reader.GetInt32(Define.playlist_id);
d.TimeBegin = reader.GetTimeSpan(Define.time_begin);
d.TimeEnd = reader.GetTimeSpan(Define.time_end);
d.Time = reader.GetDateTime(Define.detail_date);
}
}
return(d);
}
return(null);
}
/// <summary>
/// Actualy run the graph
/// </summary>
private void RunGraph()
{
try
{
Running = true;
while (Running)
{
Thread.Sleep(500);
EventCode ev;
IntPtr p1, p2;
Application.DoEvents();
while (MediaEvent.GetEvent(out ev, out p1, out p2, 0) == 0)
{
if (ev == EventCode.Complete || ev == EventCode.UserAbort || ev == EventCode.ErrorAbort)
{
if (ev == EventCode.ErrorAbort)
{
string msg = DecodeHrResult((uint)p1.ToInt64());
Program.LogError("ERROR: HRESULT={0:X} {1}", p1, msg);
Trace("ERROR: HRESULT={0:X} {1}", p1, msg);
}
MediaControl.Stop();
Running = false;
Trace("Done!");
Program.LogSuccess("Done!");
}
MediaEvent.FreeEventParams(ev, p1, p2);
}
}
Graph.Abort();
Trace("Graph Closed");
}
catch (Exception ex)
{
ExceptionHelper.HandleException(ex);
Trace("ERROR: Running Graph");
}
}
public void UsbAdded(object sender, EventArrivedEventArgs e)
{
var pd = e.NewEvent.Properties["TargetInstance"];
{
var mbo = pd.Value as ManagementBaseObject;
if (mbo != null)
{
var drivePath = mbo.Properties["Caption"].Value.ToString();
var drive = new DriveInfo(drivePath);
if (drive.IsReady)
{
InitForm(UsbStateChange.Added, drivePath);
}
else
{
MediaEvent = new MediaEvent();
MediaEvent.MediaWatcher += MediaEventMediaWatcher;
MediaEvent.Monitor(drivePath, MediaEvent);
}
}
}
}
private void OnMediaEvent(MediaEvent ev)
{
Trace.WriteLine($"HwndRenderSession::OnMediaEvent(): {ev.TypeInfo} {ev.Status}");
switch (ev.TypeInfo)
{
case MediaEventTypes.SessionClosed:
// cleanup
AfterClose();
_isSessionReady.OnNext(false);
break;
case MediaEventTypes.SessionTopologyStatus:
if (ev.Status.Failure)
{
_playFailed.OnNext(ev.Status.Code);
return;
}
Trace.WriteLine($"HwndRenderSession::OnMediaEvent(): => TopologyStatus={ev.Get(EventAttributeKeys.TopologyStatus)}");
if (ev.Status.Success && ev.Get(EventAttributeKeys.TopologyStatus) == TopologyStatus.Ready)
{
using (var sp = _mediaSession.QueryInterface <ServiceProvider>()) {
_videoControl = sp.GetService <VideoDisplayControl>(CustomServiceKeys.VideoRender);
_audioVolume = sp.GetService <SimpleAudioVolume>(MediaServiceKeys.PolicyVolume);
}
_isSessionReady.OnNext(true);
}
break;
//case MediaEventTypes.SessionStarted:
//case MediaEventTypes.EndOfPresentation:
//case MediaEventTypes.SessionStopped:
default:
break;
}
}
void mediaSession_OnSessionTopologyStatus(MediaEvent mediaEvent)
{
if (mediaEvent.EventTopologyStatus == MFTopoStatus.Ready)
{
videoDisplayControl = VideoDisplayControl.Create(mediaSession);
mediaSession.Start();
}
}
/// <summary>
/// <see cref="ISink.PushEvent(MediaEvent)"/>
/// </summary>
/// <param name="e"></param>
public virtual void PushEvent(MediaEvent e)
{
OnMediaEvent(e);
}
public void ValidateEvent(MediaEvent mediaEvent)
{
var expectedState = (MediaState)_mediaState;
//Debug.WriteLine("MediaStreamFsm.ValidateEvent({0}) state {1}", mediaEvent, expectedState);
for (; ; )
{
var newState = Find(expectedState, mediaEvent);
if (!newState.HasValue)
{
var message = string.Format("ValidateEvent Invalid state transition: state {0} event {1}", expectedState, mediaEvent);
Debug.WriteLine(message);
return;
//throw new InvalidOperationException(message);
}
#pragma warning disable 0420
var oldState = (MediaState)Interlocked.CompareExchange(ref _mediaState, (int)newState.Value, (int)expectedState);
#pragma warning restore 0420
if (oldState == expectedState)
{
if (NoisyLogging || oldState != newState.Value)
Debug.WriteLine("Media {0}: {1} -> {2} at {3}", mediaEvent, oldState, newState, DateTimeOffset.Now);
return;
}
expectedState = oldState;
}
}
private static void OnMediaEvent(MediaActionEventArgs e)
{
MediaEvent?.Invoke(null, e);
}
/// <summary>
/// <see cref="ISource.OnMediaEvent(MediaEvent)"/>
/// </summary>
/// <param name="e"></param>
public virtual void OnMediaEvent(MediaEvent e)
{
UpstreamLink?.OnMediaEvent(e);
}
MediaState? Find(MediaState source, MediaEvent mediaEvent)
{
Dictionary<MediaEvent, MediaState> transitions;
if (!ValidTransitions.TryGetValue(source, out transitions))
return null;
MediaState newState;
if (!transitions.TryGetValue(mediaEvent, out newState))
return null;
return newState;
}
private void OnMediaSessionEvent(MediaEvent mEvent)
{
var type = mEvent.TypeInfo;
//Console.WriteLine("MediaEvent {0}", type);
//Console.Out.Flush();
switch (type)
{
case MediaEventTypes.SessionClosed:
musicMediaEvents.Enqueue(new SoundMusicEventNotification(SoundMusicEvent.MusicPlayerClosed, mEvent));
break;
case MediaEventTypes.SessionEnded:
musicMediaEvents.Enqueue(new SoundMusicEventNotification(SoundMusicEvent.EndOfTrackReached, mEvent));
break;
case MediaEventTypes.SessionTopologyStatus:
if (mEvent.Get(EventAttributeKeys.TopologyStatus) == TopologyStatus.Ready)
musicMediaEvents.Enqueue(new SoundMusicEventNotification(SoundMusicEvent.ReadyToBePlayed, mEvent));
break;
case MediaEventTypes.Error:
break;
case MediaEventTypes.SourceMetadataChanged:
break;
}
}
private void OnEngineEvent(CaptureEngine engine, MediaEvent mediaEvent)
{
throw new NotImplementedException();
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MediaEvent obj)
{
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
public void OnEvent(MediaEvent mediaEvent)
{
captureEngine.OnEvent(mediaEvent);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
if (this.MediaSelect.SelectedItem == null)
{
MessageBox.Show("Hãy chọn Media mà bạn muốn thêm.", "Thông báo");
return;
}
if (this.UITimeBegin >= this.UITimeEnd)
{
MessageBox.Show("Thời gian bắt đầu phải nhỏ hơn thời gian kết thúc", "Thông báo");
return;
}
#region Validate
bool validate = true;
List <MediaEvent> Medias = this.playlist.LoadMediaEvent();
if (Medias != null)
{
foreach (MediaEvent mE in Medias)
{
if (this.Event == null || ((this.Event != null) && this.Event.ID != mE.ID))
{
if ((mE.TimeBegin <= this.UITimeBegin.Time.TimeOfDay && mE.TimeEnd >= this.UITimeBegin.Time.TimeOfDay) || (mE.TimeBegin <= this.UITimeEnd.Time.TimeOfDay && mE.TimeEnd >= this.UITimeEnd.Time.TimeOfDay) || (mE.TimeBegin >= this.UITimeBegin.Time.TimeOfDay && mE.TimeEnd <= this.UITimeEnd.Time.TimeOfDay))
{
validate = false;
break;
}
}
}
}
if (validate)
{
MediaEvent tmp = new MediaEvent();
tmp.media_id = Convert.ToInt32(this.MediaSelect.SelectedItem.key);
tmp.playlist_id = this.playlist.ID;
tmp.TimeBegin = this.UITimeBegin.Time.TimeOfDay;
tmp.TimeEnd = this.UITimeEnd.Time.TimeOfDay;
int result = 0;
if (this.Event == null)
{
result = MediaEvent.Insert(tmp);
}
else
{
tmp.ID = this._event.ID;
result = tmp.Save();
}
if (result != 1)
{
MessageBox.Show("Lưu dữ liệu không thành công", "Thông báo");
return;
}
else
{
this.Event = null;
this.LoadUI(this.playlist);
}
}
else
{
MessageBox.Show("Không thể thêm media trong thời gian này", "Thông báo");
}
#endregion
}
public void PushEvent(MediaEvent e)
{
UpstreamLink?.OnMediaEvent(e);
}
void UIE_ViewMediaEvent(object sender, MediaEvent e)
{
this.Event = e;
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MediaEvent obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
private void OnEvent(MediaEvent mediaEvent)
{
CaptureEngineEvent?.Invoke(mediaEvent);
}
