private async Task GetValueAsync(CancellationToken token, ITaskListener listener, string propertyName)
{
listener.NotifyTaskStarting();
T value = default(T);
bool?isSuccess;
try
{
value = await _getValueAsync(token);
isSuccess = true;
}
catch (OperationCanceledException)
{
isSuccess = null;
}
catch
{
isSuccess = false;
}
finally
{
_isCalculating = false;
}
if (isSuccess == true)
{
DoSetValue(value, propertyName);
}
listener.NotifyTaskCompleted(isSuccess);
}
// Start is called before the first frame update
void Start()
{
masterCanvas.SetActive(true); //In case of AR canvas needs to be set to active
scatterPlotManager.SetActive(true);
taskFactory = TaskFactory.Instance; //singleton
taskListener = new TaskListener(taskFactory, masterCanvas, scatterPlotManager, selector, controlerType);
taskFactory.getTask(COUNTER).init(taskListener, masterCanvas, scatterPlotManager);
}
private void CalculateValue(CancellationToken token, ITaskListener listener, string propertyName)
{
if (!_isCalculating)
{
_isCalculating = true;
StartGetValue(token, listener, propertyName);
}
}
private void StartGetValue(CancellationToken token, ITaskListener listener, string propertyName)
{
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
listener = listener ?? AggregateTaskListener.Empty;
Task.Factory.StartNew(() => GetValueAsync(token, listener, propertyName),
CancellationToken.None, TaskCreationOptions.None, scheduler);
}
public override void init(ITaskListener taskListener, GameObject masterCanvas, GameObject scatterPlotManager)
{
setType(TaskType.TYPE_2);
base.init(taskListener, masterCanvas, scatterPlotManager);
setState(TaskState.INIT);
question = questionFactory.getQuestion(2);
execute();
}
/// <summary>
/// Gets the value of an asynchronous property.
/// </summary>
/// <typeparam name="T">The type of the property value.</typeparam>
/// <param name="getValueAsync">The delegate used to calculate the property value.</param>
/// <param name="listener">The optional task listener.</param>
/// <param name="propertyName">The name of the property.</param>
public T Get <T>(Func <Task <T> > getValueAsync, ITaskListener listener = null,
[CallerMemberName] string propertyName = null)
{
if (getValueAsync == null)
{
throw new ArgumentNullException("getValueAsync");
}
return(Get(_ => getValueAsync(), CancellationToken.None, listener, propertyName));
}
protected internal virtual void InitExecutionListeners(IHistoryEventProducer historyEventProducer,
IHistoryLevel historyLevel)
{
ProcessInstanceStartListener = new ProcessInstanceStartListener(historyEventProducer, historyLevel);
ProcessInstanceEndListener = new ProcessInstanceEndListener(historyEventProducer, historyLevel);
ActivityInstanceStartListener = new ActivityInstanceStartListener(historyEventProducer, historyLevel);
ActivityInstanceEndListener = new ActivityInstanceEndListener(historyEventProducer, historyLevel);
UserTaskAssignmentHandler = new ActivityInstanceUpdateListener(historyEventProducer, historyLevel);
UserTaskIdHandler = UserTaskAssignmentHandler;
}
/// <summary>
/// Gets the property value.
/// </summary>
/// <param name="token">The optional cancellation token.</param>
/// <param name="listener">The optional task listener.</param>
/// <param name="propertyName">The name of the property.</param>
public T GetValue(CancellationToken token, ITaskListener listener, string propertyName)
{
if (propertyName == null)
{
throw new ArgumentNullException("propertyName");
}
if (!IsValueValid)
{
CalculateValue(token, listener, propertyName);
}
return(DoGetValue());
}
// Task listener
public virtual void Notify(IDelegateTask delegateTask)
{
if (taskListenerInstance == null)
{
taskListenerInstance = TaskListenerInstance;
}
try
{
Context.ProcessEngineConfiguration.DelegateInterceptor.HandleInvocation(new TaskListenerInvocation(taskListenerInstance, delegateTask));
}
catch (Exception e)
{
throw new ActivitiException("Exception while invoking TaskListener: " + e.Message, e);
}
}
public string baseQuestionPopup = "Popup - InputQuestion"; //Default
public virtual void init(ITaskListener taskListener, GameObject masterCanvas, GameObject scatterPlotManager)
{
this.taskListener = taskListener;
this.masterCanvas = masterCanvas;
this.scatterplotManager = scatterPlotManager;
baseOverlay = (taskType == TaskType.TYPE_1) ? "Overlay - Input" : "Overlay - Option";
baseQuestionPopup = (taskType == TaskType.TYPE_1) ? "Popup - InputQuestion" : "Popup - OptionQuestion";
masterCanvas.transform.Find("Overlay - Input").gameObject.SetActive(!(taskType == TaskType.TYPE_1));
masterCanvas.transform.Find("Overlay - Option").gameObject.SetActive(!(taskType == TaskType.TYPE_2));
masterCanvas.transform.Find("Overlay - Input").gameObject.SetActive(taskType == TaskType.TYPE_1);
masterCanvas.transform.Find("Overlay - Option").gameObject.SetActive(taskType == TaskType.TYPE_2);
try
{
questionObject = masterCanvas.transform.Find(baseOverlay + "/" + baseQuestionPopup + "/Container/Question").gameObject;
submitButton = masterCanvas.transform.Find(baseOverlay + "/" + baseQuestionPopup + "/Container/Button - Submit").GetComponent <Button>();
hideOverlayButton = masterCanvas.transform.Find(baseOverlay + "/" + baseQuestionPopup + "/Container/Button - HideOverlay").GetComponent <Button>();
}
catch (NullReferenceException ex)
{
questionObject = masterCanvas.transform.Find(baseQuestionPopup + "/Container/Question").gameObject;
submitButton = masterCanvas.transform.Find(baseQuestionPopup + "/Container/Button - Submit").GetComponent <Button>();
hideOverlayButton = masterCanvas.transform.Find(baseQuestionPopup + "/Container/Button - HideOverlay").GetComponent <Button>();
//questionObject.transform.SetParent(masterCanvas.transform.Find(baseQuestionPopup).transform);
masterCanvas.transform.Find("Popup - InputQuestion").gameObject.SetActive(!(taskType == TaskType.TYPE_1));
masterCanvas.transform.Find("Popup - OptionQuestion").gameObject.SetActive(!(taskType == TaskType.TYPE_2));
masterCanvas.transform.Find("Popup - InputQuestion").gameObject.SetActive(taskType == TaskType.TYPE_1);
masterCanvas.transform.Find("Popup - OptionQuestion").gameObject.SetActive(taskType == TaskType.TYPE_2);
}
submitButton.onClick.AddListener(result);
showOverlayButton = masterCanvas.transform.Find(baseOverlay + "/Button - ShowOverlay").GetComponent <Button>();
showOverlayButton.onClick.Invoke();
}
/**
* Adds a task listener to this task. When there is a relevant change in the
* status of this task, the listener will be notified by calling its
* {@link ITaskListener#statusChanged(TaskEvent)} method.
*
* @param listener
* the listener to add.
*/
public void AddTaskListener(ITaskListener listener)
{
_listeners.Add(listener);
}
public void Unsubscribe(ITaskListener taskListener)
{
_listeners.Remove(taskListener);
}
T IAsyncProperty <T> .GetValue(CancellationToken token, ITaskListener listener, string propertyName)
{
SetPropertyName(propertyName);
DependencyTracker.Instance.Register(this);
return(_property.GetValue(token, listener, propertyName));
}
/**
* Removes a listener from this task.
*
* @param listener
* the task listener to remove.
*/
public void RemoveTaskListener(ITaskListener listener)
{
_listeners.Remove(listener);
}
public TaskListenerInvocation(ITaskListener taskListenerInstance, IDelegateTask delegateTask,
IBaseDelegateExecution contextExecution) : base(contextExecution, null)
{
this.TaskListenerInstance = taskListenerInstance;
this.DelegateTask = delegateTask;
}
public virtual void AddBuiltInTaskListener(string eventName, ITaskListener taskListener)
{
CollectionUtil.AddToMapOfLists(TaskListeners, eventName, taskListener);
CollectionUtil.AddToMapOfLists(builtinTaskListeners, eventName, taskListener);
}
public TaskListenerInvocation(ITaskListener executionListenerInstance, IDelegateTask delegateTask)
: this(executionListenerInstance, delegateTask, null)
{
}
/// <summary>
///
/// </summary>
/// <param name="executionListenerInstance"></param>
/// <param name="delegateTask"></param>
public TaskListenerInvocation(ITaskListener executionListenerInstance, IDelegateTask delegateTask)
{
this.executionListenerInstance = executionListenerInstance;
this.delegateTask = delegateTask;
}
/// <summary>
/// Gets the value of an asynchronous property.
/// </summary>
/// <typeparam name="T">The type of the property value.</typeparam>
/// <param name="getValueAsync">The delegate used to calculate the property value.</param>
/// <param name="token">The optional cancellation token.</param>
/// <param name="listener">The optional task listener.</param>
/// <param name="propertyName">The name of the property.</param>
public T Get <T>(Func <CancellationToken, Task <T> > getValueAsync, CancellationToken token = default(CancellationToken),
ITaskListener listener = null, [CallerMemberName] string propertyName = null)
{
return(GetOrAddAsyncProperty(getValueAsync, propertyName).GetValue(token, listener, propertyName));
}
/**
* Removes a listener from this task.
*
* @param listener
* the task listener to remove.
*/
public void RemoveTaskListener(ITaskListener listener)
{
_listeners.Remove(listener);
}
public void Subscribe(ITaskListener taskListener)
{
_listeners.Add(taskListener);
}
/**
* Adds a task listener to this task. When there is a relevant change in the
* status of this task, the listener will be notified by calling its
* {@link ITaskListener#statusChanged(TaskEvent)} method.
*
* @param listener
* the listener to add.
*/
public void AddTaskListener(ITaskListener listener)
{
_listeners.Add(listener);
}
public ICompleted SetListener(ITaskListener listener)
{
this.listener = listener;
return(this);
}
static IEnumerable<ICommandOutput> Wrap(IEnumerable<ICommandOutput> execute, ITaskListener eventListener)
{
foreach (var value in execute)
yield return value;
eventListener.Stop();
}
public Application(IRegistrar registrar, ITaskListener listener, ILog logger)
{
_registrar = registrar;
_listener = listener;
_logger = logger;
}
