public override void Play(ResourceActivationContext activationContext, PlayableContent playable, Action onClose = null)
{
if (playable.Content is LocalizedAudioContent)
{
QueueAudioContent(activationContext, playable, playable.Content as LocalizedAudioContent, onClose);
}
else if (playable.Content is LocativeAudioContent)
{
m_locativeAudioProcessor.ActivateResource(activationContext, playable.Content as LocativeAudioContent);
}
else if (IsScreenContent(playable))
{
QueueScreenContent(activationContext, playable, onClose);
}
else
{
m_logger.Warning("Unhandled content type {0} (playable.Id={1})",
playable.Content != null ? playable.Content.Type : null,
playable.Id);
if (onClose != null)
{
onClose();
}
}
}
protected virtual void PlayNotification(ResourceActivationContext context, PlayableContent playable, Notification notification, ResourcePanelData <Notification> data, Action onClose)
{
if (Platform.Instance.IsInBackground)
{
context.Open();
if (!BackgroundNotifier.Instance.HasNotification(context.InstanceId))
{
var localNotification = new Motive.Core.Notifications.LocalNotification();
localNotification.Title = notification.Title;
localNotification.Text = notification.Message;
Platform.Instance.LocalNotificationManager.PostNotification(playable.Id, localNotification);
}
BackgroundNotifier.Instance.RemoveNotification(context.InstanceId);
/*
* if (notification.SoundUrl != null)
* {
* var path = WebServices.Instance.MediaDownloadManager.GetPathForItem(notification.SoundUrl);
* m_channel.Play(new Uri(path));
* }*/
if (onClose != null)
{
onClose();
}
}
else
{
if (notification.Title != null ||
notification.Message != null)
{
Push(context, PanelStack, NotificationPanel, data, onClose);
}
else
{
context.Open();
if (notification.Vibrate)
{
Platform.Instance.LocalNotificationManager.Vibrate();
}
if (notification.Sound != null)
{
Platform.Instance.PlaySound(notification.Sound.Url);
}
if (onClose != null)
{
onClose();
}
}
}
}
void Play(BatchContext context, PlayableContent playable, Action onClose)
{
if (!context.ActivationContext.IsClosed)
{
// If there's a script timer, use the activation time as a base to
// play this content later.
if (playable.Timer != null)
{
// Use clock manager so that we can use debug clock features
var fireTime = playable.Timer.GetNextFireTime(context.ActivationContext.ActivationTime);
var delta = ClockManager.Instance.GetTimespanFromNow(fireTime);
if (delta.TotalSeconds > 0)
{
// Actual play time is real Now + delta - this can be different from the
// computed fire time above if we're using a debug clock.
var actualPlayTime = DateTime.Now + delta;
Delegate.Preview(context.ActivationContext, playable, actualPlayTime);
}
context.Timer = Timer.Call(delta,
() =>
{
m_logger.Debug("Fired timer!");
Delegate.Play(context.ActivationContext, playable, () =>
{
context.ActivationContext.Close();
if (onClose != null)
{
onClose();
}
});
});
}
else
{
Delegate.Play(context.ActivationContext, playable, () =>
{
context.ActivationContext.Close();
if (onClose != null)
{
onClose();
}
});
}
}
else
{
if (onClose != null)
{
onClose();
}
}
}
protected virtual void PlayScreenContent(ResourceActivationContext context, PlayableContent playable, Action onClose)
{
if (playable.Content is ScreenMessage)
{
var screenMsg = playable.Content as ScreenMessage;
var data = new ResourcePanelData <ScreenMessage>(context, screenMsg);
if (screenMsg.Responses != null && screenMsg.Responses.Length > 0)
{
PushScreenDialogPanel(context, playable, screenMsg, data, onClose);
}
else
{
PushScreenMessagePanel(context, playable, screenMsg, data, onClose);
}
}
else if (playable.Content is CharacterMessage)
{
var charMsg = playable.Content as CharacterMessage;
var data = new ResourcePanelData <CharacterMessage>(context, charMsg);
if (charMsg.Responses != null && charMsg.Responses.Length > 0)
{
PushCharacterDialogPanel(context, playable, charMsg, data, onClose);
}
else
{
PushCharacterMessagePanel(context, playable, charMsg, data, onClose);
}
}
else if (playable.Content is Notification)
{
var notification = playable.Content as Notification;
var data = new ResourcePanelData <Notification>(context, notification);
PlayNotification(context, playable, playable.Content as Notification, data, onClose);
}
else if (playable.Content is MediaContent)
{
var media = playable.Content as MediaContent;
var data = new ResourcePanelData <MediaContent>(context, media);
PlayMediaContent(context, playable, media, data, onClose);
}
else
{
m_logger.Error("Unsupported content type with route=screen: {0}",
playable.Content == null ? "null" : playable.Content.Type);
}
}
protected virtual bool IsScreenContent(PlayableContent playable)
{
if (playable.Content is ScreenMessage ||
playable.Content is CharacterMessage ||
playable.Content is Notification ||
playable.Route == "screen")
{
return(true);
}
return(IsVideoContent(playable.Content) || IsImageContent(playable.Content));
}
void QueueAudioContent(ResourceActivationContext activationContext, PlayableContent playable, LocalizedAudioContent localizedAudio, Action onClose)
{
var audioRoute = GetRouteForAudioContent(playable);
if (audioRoute == AudioContentRoute.Narrator)
{
AddToQueue(m_narratorQueue, activationContext, playable, PlayAudioContent, onClose);
}
else
{
PlayAudioContent(activationContext, playable, onClose);
}
}
internal void Remove(PlayableContent playable)
{
lock (m_queuedPlayables)
{
if (CurrentlyPlaying != null && CurrentlyPlaying.Playable == playable)
{
LastPlayFinish = DateTime.Now;
CurrentlyPlaying = null;
}
m_queuedPlayables.RemoveAll((_ctxt) => _ctxt.Playable == playable);
}
}
public override void Activate(LocationAttraction attraction, bool autoplay)
{
// Activate (with autoplay)
if (autoplay && Item != null)
{
var playable = new PlayableContent
{
Content = Item,
Route = PlayableContentRoute.Screen
};
PlayableContentHandler.Instance.Play(ActivationContext, playable);
}
}
/// <summary>
/// Play the specified playable. NOTE that this is called off-thread! Any
/// interaction with Unity needs to use ThreadHelper.
/// </summary>
/// <param name="ctxt">Ctxt.</param>
/// <param name="playable">Playable.</param>
/// <param name="onClose">On close.</param>
public void Play(ResourceActivationContext ctxt, PlayableContent playable, Action onClose = null)
{
m_logger.Debug("Play {0}", playable.Type);
BatchContext playableContext = new BatchContext
{
ActivationContext = ctxt,
Playables = new PlayableContent[] { playable }
};
m_containers[ctxt.InstanceId] = playableContext;
Play(playableContext, playable, onClose);
}
protected virtual AudioContentRoute GetRouteForAudioContent(PlayableContent playable)
{
switch (playable.Route)
{
case PlayableContentRoute.Narrator:
return(AudioContentRoute.Narrator);
case PlayableContentRoute.Soundtrack:
return(AudioContentRoute.Soundtrack);
case PlayableContentRoute.Ambient:
return(AudioContentRoute.Ambient);
}
return(AudioContentRoute.Ambient);
}
public override void StopPlaying(ResourceActivationContext ctxt, PlayableContent playable, bool interrupt = false)
{
PlayableContentQueue queue = null;
lock (m_queues)
{
m_queues.TryGetValue(ctxt.InstanceId, out queue);
}
var audioContent = playable.Content as LocalizedAudioContent;
if (audioContent != null)
{
if (AudioContentPlayer.Instance.StopPlaying(ctxt.InstanceId, interrupt))
{
// If audio content player didn't stop in this call, the playable will
// stop playing and call back, we can remove it from the queue then
if (queue != null)
{
queue.Remove(playable);
}
}
}
else if (playable.Content is LocativeAudioContent)
{
m_locativeAudioProcessor.DeactivateResource(ctxt, playable.Content as LocativeAudioContent);
}
else
{
if (queue != null)
{
queue.Remove(playable);
}
}
lock (m_queues)
{
m_queues.Remove(ctxt.InstanceId);
}
if (queue != null)
{
PlayNextSequentialContent(queue);
}
}
protected virtual void PlayMediaContent(ResourceActivationContext context, PlayableContent playable, MediaContent media, ResourcePanelData <MediaContent> data, Action onClose)
{
if (IsAudioContent(playable.Content))
{
PushAudioPanel(context, playable, media, data, onClose);
}
else if (IsImageContent(playable.Content))
{
PushImagePanel(context, playable, media, data, onClose);
}
else if (IsVideoContent(media))
{
PushVideoPanel(context, playable, media, data, onClose);
}
else
{
m_logger.Error("Unsupported content type with route=screen: {0}",
playable.Content == null ? "null" : playable.Content.Type);
}
}
protected virtual Panel GetScreenDialogPanel(ResourceActivationContext context, PlayableContent playable)
{
return(ScreenDialogPanel);
}
protected virtual void QueueNotification(ResourceActivationContext activationContext, PlayableContent playable, Action onClose)
{
var notification = (Notification)playable.Content;
PlayNotification(activationContext, playable, notification, new ResourcePanelData <Notification>(activationContext, notification), onClose);
}
protected virtual Panel GetCharacterDialogPanel(ResourceActivationContext context, PlayableContent playable)
{
return(CharacterDialogPanel);
}
protected virtual void PushAudioPanel(ResourceActivationContext context, PlayableContent playable, MediaContent media, ResourcePanelData <MediaContent> data, Action onClose)
{
Push(context, PanelStack, GetAudioPanel(context, playable), data, onClose);
}
protected virtual void PushCharacterMessagePanel(ResourceActivationContext context, PlayableContent playable, CharacterMessage charMsg, ResourcePanelData <CharacterMessage> data, Action onClose)
{
Push(context, PanelStack, GetCharacterMessagePanel(context, playable), data, onClose);
}
public abstract void Play(ResourceActivationContext activationContext, PlayableContent playable, Action onClose);
public override void Preview(ResourceActivationContext activationContext, PlayableContent playable, DateTime playTime)
{
// Preview is called for playables that will be played in the future.
// This can be useful for setting up system notifications.
}
public virtual void PlayAudioContent(ResourceActivationContext activationContext, PlayableContent playable, Action onClose)
{
activationContext.Open();
AudioContentPlayer.Instance.PlayAudioContent(activationContext.InstanceId, playable.Content as LocalizedAudioContent, GetRouteForAudioContent(playable), (whenDone) =>
{
BeforePlayAudio(activationContext, playable, whenDone);
},
() =>
{
AfterPlayAudio(activationContext, playable, onClose);
});
}
protected virtual void AfterPlayAudio(ResourceActivationContext activationContext, PlayableContent playable, Action onComplete)
{
onComplete();
}
protected PlayableContentQueue GetQueue(ResourceActivationContext activationContext, PlayableContent playable)
{
if (playable.Content is ScreenMessage || playable.Content is CharacterMessage)
{
return(m_screenQueue);
}
return(null);
}
protected virtual Panel GetVideoPanel(ResourceActivationContext context, PlayableContent playable)
{
return(VideoPanel);
}
public abstract void Preview(ResourceActivationContext activationContext, PlayableContent playable, DateTime playTime);
protected virtual PlayableContentQueue GetScreenContentQueue(ResourceActivationContext activationContext, PlayableContent playable)
{
return(m_screenQueue);
}
public abstract void StopPlaying(ResourceActivationContext activationContext, PlayableContent playable, bool interrupt);
protected virtual void AddToQueue(PlayableContentQueue queue, ResourceActivationContext activationContext, PlayableContent playable, PlayContentDelegate onPlay, Action onClose)
{
lock (m_queues)
{
m_queues.Add(activationContext.InstanceId, queue);
}
switch (playable.Priority)
{
case PlayableContentPriority.High:
// Todo: actually want to be a bit more clever and *don't* move in front of
// other high priority ones.
queue.AddToFront(
new QueuedPlayableContext
{
ActivationContext = activationContext,
Playable = playable,
OnClose = onClose,
OnPlay = onPlay
});
PlayNextSequentialContent(queue);
break;
case PlayableContentPriority.Interrupt:
QueuedPlayableContext toStop = null;
lock (queue.SyncRoot)
{
toStop = queue.CurrentlyPlaying;
}
if (toStop != null)
{
StopPlaying(toStop.ActivationContext, toStop.Playable, true);
toStop.ActivationContext.Close();
}
queue.AddToFront(
new QueuedPlayableContext
{
ActivationContext = activationContext,
Playable = playable,
OnClose = onClose,
OnPlay = onPlay
});
PlayNextSequentialContent(queue);
break;
case PlayableContentPriority.Filler:
// Only if nothing has played on this queue for a while...
bool doPlay = false;
lock (queue.SyncRoot)
{
doPlay = queue.CurrentlyPlaying == null &&
(DateTime.Now - queue.LastPlayFinish).TotalSeconds >= MinFillerDelay;
}
if (doPlay)
{
queue.Add(
new QueuedPlayableContext
{
ActivationContext = activationContext,
Playable = playable,
OnClose = onClose,
OnPlay = onPlay
});
PlayNextSequentialContent(queue);
}
break;
case PlayableContentPriority.Normal:
default:
queue.Add(
new QueuedPlayableContext
{
ActivationContext = activationContext,
Playable = playable,
OnClose = onClose,
OnPlay = onPlay
});
PlayNextSequentialContent(queue);
break;
}
}
protected virtual void QueueScreenContent(ResourceActivationContext activationContext, PlayableContent playable, Action onClose)
{
var queue = GetScreenContentQueue(activationContext, playable);
if (queue != null)
{
AddToQueue(queue, activationContext, playable, PlayScreenContent, onClose);
}
else
{
PlayScreenContent(activationContext, playable, onClose);
}
}
protected virtual void PushScreenMessagePanel(ResourceActivationContext context, PlayableContent playable, ScreenMessage screenMsg, ResourcePanelData <ScreenMessage> data, Action onClose)
{
Push(context, PanelStack, GetScreenMessagePanel(context, playable), data, onClose);
}
