public static void Stop()
{
Utils.RunOnWindowsUIThread(async() =>
{
try
{
if (speechRecognizer != null)
{
try
{
if (isListening)
{
await speechRecognizer.ContinuousRecognitionSession.StopAsync();
isListening = false;
}
}
catch (Exception)
{
speechRecognizer.Dispose();
speechRecognizer = null;
isListening = false;
}
}
}
catch (Exception ex)
{
// If stoping diction crashes, the assumption is that it is ok to ignore it since the scenario is anyways done
DebugLog.Log(LogLevel.Error, "Hit an exception in Speech::Stop and ignoring it.." + ex.ToString());
return;
}
});
}
public static void RequestAppPurchase(bool requireReceipt, Action <CallbackResponse <string> > OnAppPurchaseFinished)
{
string result = String.Empty;
bool didPurchaseSucceed = false;
Utils.RunOnWindowsUIThread(async() =>
{
try
{
if (_isLicenseSimulationOn)
{
result = await CurrentAppSimulator.RequestAppPurchaseAsync(requireReceipt);
if (CurrentAppSimulator.LicenseInformation.IsActive && !CurrentAppSimulator.LicenseInformation.IsTrial)
{
didPurchaseSucceed = true;
}
}
else
{
result = await CurrentApp.RequestAppPurchaseAsync(requireReceipt);
if (CurrentApp.LicenseInformation.IsActive && !CurrentApp.LicenseInformation.IsTrial)
{
didPurchaseSucceed = true;
}
}
}
catch (Exception ex)
{
DebugLog.Log(LogLevel.Error, "Error purchasing the app " + ex.ToString());
Utils.RunOnUnityAppThread(() =>
{
if (OnAppPurchaseFinished != null)
{
OnAppPurchaseFinished(
new CallbackResponse <string>
{
Status = CallbackStatus.Failure,
Result = null,
Exception = ex
});
}
});
return;
}
Utils.RunOnUnityAppThread(() =>
{
if (OnAppPurchaseFinished != null)
{
OnAppPurchaseFinished(new CallbackResponse <string>
{
Status = didPurchaseSucceed ? CallbackStatus.Success : CallbackStatus.Failure,
Result = result,
Exception = null
});
}
});
});
}
/// <summary>
/// Put an event handler for notifications.
/// </summary>
/// <param name="OnPushNotification"></param>
/// <param name="cancelDefaultBehavior"></param>
public static void RegisterForNotifications(Action <CallbackResponse <object> > OnPushNotification, bool cancelDefaultBehavior)
{
Utils.RunOnWindowsUIThread(async() =>
{
try
{
var channel = await Windows.Networking.PushNotifications.PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
channel.PushNotificationReceived += (s, e) =>
{
String notificationContent = String.Empty;
switch (e.NotificationType)
{
case Windows.Networking.PushNotifications.PushNotificationType.Badge:
notificationContent = e.BadgeNotification.Content.GetXml();
break;
case Windows.Networking.PushNotifications.PushNotificationType.Tile:
notificationContent = e.TileNotification.Content.GetXml();
break;
case Windows.Networking.PushNotifications.PushNotificationType.Toast:
notificationContent = e.ToastNotification.Content.GetXml();
break;
case Windows.Networking.PushNotifications.PushNotificationType.Raw:
notificationContent = e.RawNotification.Content;
break;
}
if (cancelDefaultBehavior)
{
e.Cancel = true;
}
Utils.RunOnUnityAppThread(() =>
{
if (OnPushNotification != null)
{
OnPushNotification(new CallbackResponse <object> {
Result = notificationContent, Status = CallbackStatus.Success, Exception = null
});
}
});
};
}
catch (Exception ex)
{
DebugLog.Log(LogLevel.Error, "Error registering for notifications");
if (OnPushNotification != null)
{
OnPushNotification(new CallbackResponse <object> {
Result = null, Status = CallbackStatus.Failure, Exception = ex
});
}
return;
}
});
}
//public delegate void SetInputFocusOnUnity(bool enabled);
//public static SetInputFocusOnUnity handler;
/// <summary>
/// A bit of primer on how executing delegates on different threads works. When one thread wants to execute something
/// on the other thread, it takes the work item and inserts it in the "dispatch" queue for the other thread. The other
/// thread picks whatever is in its work queue and runs/dispatches it. So, we can keep bouncing between threads as much
/// as we want.
/// </summary>
/// <param name="delegateToExecute"></param>
public static void RunOnUnityAppThread(Action delegateToExecute)
{
if (delegateToExecute == null)
{
throw new ArgumentNullException("delegateToExecute", "You must pass a non-null delegate to execute on the Unity thread when invoking RunOnUnityAppThread");
}
try
{
_unityAppThreadInvokerDelegate(delegateToExecute);
}
catch (Exception ex)
{
DebugLog.Log(LogLevel.Error, "Error running task on the Unity thread " + ex.ToString());
}
}
public static void ReportConsumableFulfillment(string productId, Guid transactionId,
Action <CallbackResponse <FulfillmentResult> > OnReportConsumableFulfillmentFinished)
{
Utils.RunOnWindowsUIThread(async() =>
{
Windows.ApplicationModel.Store.FulfillmentResult result = Windows.ApplicationModel.Store.FulfillmentResult.ServerError;
try
{
if (_isLicenseSimulationOn)
{
result = await CurrentAppSimulator.ReportConsumableFulfillmentAsync(productId, transactionId);
}
else
{
result = await CurrentApp.ReportConsumableFulfillmentAsync(productId, transactionId);
}
}
catch (Exception ex)
{
DebugLog.Log(LogLevel.Error, "Error while reporting consumable fulfillment " + ex.ToString());
Utils.RunOnUnityAppThread(() => { if (OnReportConsumableFulfillmentFinished != null)
{
OnReportConsumableFulfillmentFinished(new CallbackResponse <FulfillmentResult> {
Status = CallbackStatus.Failure, Exception = ex, Result = FulfillmentResult.ServerError
});
}
});
return;
}
// This should not really be throwing exceptions.. If it does, they will be raised on the Unity thread anyways, so game should handle it
Utils.RunOnUnityAppThread(() =>
{
if (OnReportConsumableFulfillmentFinished != null)
{
OnReportConsumableFulfillmentFinished(
new CallbackResponse <FulfillmentResult>
{
Result = (Microsoft.UnityPlugins.FulfillmentResult)result,
Exception = null,
Status = CallbackStatus.Success
});
}
});
});
}
private static void InterstitialAd_Completed(object sender, object e)
{
DebugLog.Log(LogLevel.Info, "Completed");
// request the next ad
lastPlayed = DateTime.Now;
Utils.RunOnWindowsUIThread(() =>
{
try
{
interstitialAd.RequestAd(AdType.Video, adAppId, adUnitId);
}
catch (Exception x)
{
DebugLog.Log(LogLevel.Error, x.ToString());
}
});
isShowRequested = false;
}
/// <summary>
///
/// </summary>
/// <param name="callback"></param> It is best not to set the callback parameter to null. The reason being you don't know
/// when the license loading is finished. Best set it properly to avoid tricky race conditions
/// <param name="licenseFilePath"></param>
///
public static void LoadLicenseXMLFile(Action <CallbackResponse> callback, string licenseFilePath = null)
{
DebugLog.Log(LogLevel.Info, "entered LoadLicenseXmlFile");
Utils.RunOnWindowsUIThread(async() =>
{
try
{
licenseFilePath = (licenseFilePath == null) ? "WindowsStoreProxy.xml" : licenseFilePath;
StorageFile licenseFile;
if (System.IO.Path.IsPathRooted(licenseFilePath))
{
licenseFile = await StorageFile.GetFileFromPathAsync(licenseFilePath);
}
else
{
licenseFile = await Package.Current.InstalledLocation.GetFileAsync(licenseFilePath);
}
await CurrentAppSimulator.ReloadSimulatorAsync(licenseFile);
// switch on the license simulation
_isLicenseSimulationOn = true;
if (callback != null)
{
Utils.RunOnUnityAppThread(() =>
{
callback(new CallbackResponse {
Exception = null, Status = CallbackStatus.Success
});
});
}
}
catch (Exception ex)
{
DebugLog.Log(LogLevel.Fatal, "Error loading license file. License simulator will give incorrect results!" + ex.ToString());
callback(new CallbackResponse {
Exception = ex, Status = CallbackStatus.Failure
});
return;
}
});
}
private static void InterstitialAd_AdReady(object sender, object e)
{
DebugLog.Log(LogLevel.Info, "AdReady");
// wait until canPlay == true
Utils.RunOnWindowsUIThread(() =>
{
if (interstitialAd.State == InterstitialAdState.Ready && isShowRequested)
{
isShowRequested = false;
try
{
interstitialAd.Show();
}
catch (Exception x) {
DebugLog.Log(LogLevel.Error, x.ToString());
}
}
});
}
public static void LoadUnfulfilledConsumables(Action <CallbackResponse <List <UnfulfilledConsumable> > > OnLoadUnfulfilledConsumablesFinished)
{
Utils.RunOnWindowsUIThread(async() =>
{
IReadOnlyList <Windows.ApplicationModel.Store.UnfulfilledConsumable> unfulfilledConsumables = null;
List <UnfulfilledConsumable> deliveryFormatUnfulfilledConsumables = new List <UnfulfilledConsumable>();
try
{
if (_isLicenseSimulationOn)
{
unfulfilledConsumables = await CurrentAppSimulator.GetUnfulfilledConsumablesAsync();
}
else
{
unfulfilledConsumables = await CurrentApp.GetUnfulfilledConsumablesAsync();
}
foreach (var oneUnfConsumable in unfulfilledConsumables)
{
deliveryFormatUnfulfilledConsumables.Add(new UnfulfilledConsumable(oneUnfConsumable));
}
}
catch (Exception ex)
{
DebugLog.Log(LogLevel.Error, "Error while reporting consumable fulfillment " + ex.ToString());
Utils.RunOnUnityAppThread(() => { OnLoadUnfulfilledConsumablesFinished(new CallbackResponse <List <UnfulfilledConsumable> > {
Status = CallbackStatus.Failure, Exception = ex, Result = null
}); });
return;
}
// deliver all the unfulfilled consumables at once
Utils.RunOnUnityAppThread(() => { if (OnLoadUnfulfilledConsumablesFinished != null)
{
OnLoadUnfulfilledConsumablesFinished(new CallbackResponse <List <UnfulfilledConsumable> > {
Status = CallbackStatus.Success, Result = deliveryFormatUnfulfilledConsumables, Exception = null
});
}
});
});
}
/// <summary>
///
/// </summary>
/// <param name="delegateToExecute"></param>
public static void RunOnWindowsUIThread(Action delegateToExecute)
{
if (delegateToExecute == null)
{
throw new ArgumentNullException("delegateToExecute", "You must pass a non-null delegate to execute on the Unity thread when invoking RunOnWindowsUIThread");
}
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
try
{
delegateToExecute(); // run the action now
}
catch (Exception ex)
{
DebugLog.Log(LogLevel.Error, "Error running task on the Windows UI thread " + ex.ToString());
}
});
}
public static void VerifyReceipt(string receiptWebserviceUrl, string receipt, Action <CallbackResponse <ReceiptResponse> > OnReceiptVerified)
{
Task.Run(async() =>
{
try
{
var httpClient = new HttpClient();
var content = new StringContent(receipt, Encoding.UTF8, "application/xml");
DebugLog.Log(LogLevel.Info, "Sending out receipt for verification");
var response = await httpClient.PostAsync(new Uri(receiptWebserviceUrl, UriKind.RelativeOrAbsolute), content);
var responseString = await response.Content.ReadAsStringAsync();
DebugLog.Log(LogLevel.Info, "received response: " + responseString);
var responseObject = JsonConvert.DeserializeObject <ReceiptResponse>(responseString);
// TODO: Is this right? We created a new thread to accommodate the async/await.. Then we marshal the callback back to the app thread
if (OnReceiptVerified != null)
{
Utils.RunOnUnityAppThread(() => OnReceiptVerified(new CallbackResponse <ReceiptResponse> {
Result = responseObject, Exception = null, Status = CallbackStatus.Success
}));
return;
}
}
catch (Exception ex)
{
if (OnReceiptVerified != null)
{
// return the results back on the Unity app thread
Utils.RunOnUnityAppThread(() => OnReceiptVerified(new CallbackResponse <ReceiptResponse> {
Result = null, Exception = ex, Status = CallbackStatus.Failure
}));
return;
}
}
});
}
public static void RequestProductPurchase(string productId, Action <CallbackResponse <PurchaseResults> > OnProductPurchaseFinished)
{
PurchaseResults result = null;
Utils.RunOnWindowsUIThread(async() =>
{
try
{
if (_isLicenseSimulationOn)
{
result = new PurchaseResults(await CurrentAppSimulator.RequestProductPurchaseAsync(productId));
}
else
{
result = new PurchaseResults(await CurrentApp.RequestProductPurchaseAsync(productId));
}
}
catch (Exception ex)
{
DebugLog.Log(LogLevel.Error, "Error purchasing the product " + ex.ToString());
Utils.RunOnUnityAppThread(() => { if (OnProductPurchaseFinished != null)
{
OnProductPurchaseFinished(new CallbackResponse <PurchaseResults> {
Exception = ex, Status = CallbackStatus.Failure, Result = null
});
}
});
return;
}
Utils.RunOnUnityAppThread(() => { if (OnProductPurchaseFinished != null)
{
OnProductPurchaseFinished(new CallbackResponse <PurchaseResults> {
Exception = null, Status = CallbackStatus.Success, Result = result
});
}
});
});
}
/// <summary>
/// Initialize the interstitial ad and request the first ad
/// </summary>
/// <param name="appId">Microsoft Advertising application Id (set up in pubcenter)</param>
/// <param name="unitId">Microsoft Advertising interstitial video ad id (set up in pubcenter)</param>
public static void Init(string appId, string unitId)
{
Utils.RunOnWindowsUIThread(() =>
{
DebugLog.Log(LogLevel.Info, "Initializing interstitial ads...");
interstitialAd = new InterstitialAd();
interstitialAd.AdReady += InterstitialAd_AdReady;
interstitialAd.ErrorOccurred += InterstitialAd_ErrorOccurred;
interstitialAd.Completed += InterstitialAd_Completed;
interstitialAd.Cancelled += InterstitialAd_Cancelled;
if (interstitialAd != null)
{
adAppId = appId;
adUnitId = unitId;
// automatically request the first ad
DebugLog.Log(LogLevel.Info, "Requesting interstitial ads...");
interstitialAd.RequestAd(AdType.Video, adAppId, adUnitId);
isAdRequested = true;
}
});
}
/// <summary>
/// You can call show, when the ad is ready it will be started automatically
/// Interstitial documentation recommends at least 60 seconds between ads
/// </summary>
public static void Show()
{
DebugLog.Log(LogLevel.Info, "Show");
Utils.RunOnWindowsUIThread(() =>
{
if (interstitialAd.State == InterstitialAdState.Ready)
{
isShowRequested = false;
try
{
interstitialAd.Show();
}
catch (Exception x) {
DebugLog.Log(LogLevel.Error, x.ToString());
}
}
else
{
isShowRequested = true;
}
});
}
public static void ListenForCommands(IEnumerable <string> commands, Action <CallbackResponse <SpeechArguments> > OnSpeechResults)
{
Utils.RunOnWindowsUIThread(async() =>
{
try
{
Stop();
speechRecognizer = new SpeechRecognizer();
speechRecognizer.Constraints.Add(new SpeechRecognitionListConstraint(commands, "Commands"));
var compilationResult = await speechRecognizer.CompileConstraintsAsync();
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
throw new Exception();
}
DebugLog.Log(LogLevel.Info, "ListenForCommands");
speechRecognizer.ContinuousRecognitionSession.Completed += (sender, args) =>
{
DebugLog.Log(LogLevel.Info, "ListenForCommands " + args.Status.ToString());
if (args.Status != SpeechRecognitionResultStatus.Success)
{
if (OnSpeechResults != null)
{
Utils.RunOnUnityAppThread(
() =>
{
OnSpeechResults(new CallbackResponse <SpeechArguments> {
Result = new SpeechArguments {
Status = SpeechResultStatus.Complete
}, Status = CallbackStatus.Success, Exception = null
});
});
}
isListening = false;
}
};
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += (sender, args) =>
{
DebugLog.Log(LogLevel.Info, "ListenForCommands " + args.Result.Text);
var command = args.Result.Text;
if (!String.IsNullOrEmpty(command))
{
command = command.ToLower();
}
if (commands != null && commands.Count() > 0)
{
foreach (var c in commands)
{
if (args != null && args.Result != null && args.Result.Text != null && c.ToLower() == command)
{
DebugLog.Log(LogLevel.Info, "ListenForCommands command " + command);
if (OnSpeechResults != null)
{
Utils.RunOnUnityAppThread(
() =>
{
OnSpeechResults(new CallbackResponse <SpeechArguments> {
Result = new SpeechArguments {
Status = SpeechResultStatus.Command, Text = command
}, Status = CallbackStatus.Success, Exception = null
});
});
}
break;
}
}
}
};
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
isListening = true;
}
catch (Exception ex)
{
DebugLog.Log(LogLevel.Error, "Hit Exception in Speech::ListenForCommands..." + ex.ToString());
if (OnSpeechResults != null)
{
Utils.RunOnUnityAppThread(
() =>
{
OnSpeechResults(new CallbackResponse <SpeechArguments> {
Result = null, Status = CallbackStatus.Failure, Exception = ex
});
});
}
return;
}
});
}
public static void ListenForDictation(Action <CallbackResponse <SpeechArguments> > OnSpeechResults)
{
Utils.RunOnWindowsUIThread(async() =>
{
try
{
Stop();
speechRecognizer = new SpeechRecognizer();
speechRecognizer.Constraints.Add(new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "Dictation"));
var compilationResult = await speechRecognizer.CompileConstraintsAsync();
if (compilationResult.Status != SpeechRecognitionResultStatus.Success)
{
throw new Exception();
}
DebugLog.Log(LogLevel.Info, "ListenForDictation");
speechRecognizer.HypothesisGenerated += (sender, args) =>
{
string hypothesis = args.Hypothesis.Text;
DebugLog.Log(LogLevel.Info, "ListenForDictation Hypothesis " + hypothesis + "...");
if (OnSpeechResults != null)
{
Utils.RunOnUnityAppThread(
() =>
{
OnSpeechResults(new CallbackResponse <SpeechArguments> {
Result = new SpeechArguments {
Status = SpeechResultStatus.Hypothesis, Text = hypothesis
}, Status = CallbackStatus.Success, Exception = null
});
});
}
};
speechRecognizer.ContinuousRecognitionSession.Completed += (sender, args) =>
{
DebugLog.Log(LogLevel.Info, "ListenForDictation " + args.Status.ToString());
if (args.Status != SpeechRecognitionResultStatus.Success)
{
if (OnSpeechResults != null)
{
Utils.RunOnUnityAppThread(
() =>
{
OnSpeechResults(new CallbackResponse <SpeechArguments> {
Result = new SpeechArguments {
Status = SpeechResultStatus.Complete
}, Status = CallbackStatus.Success, Exception = null
});
});
}
isListening = false;
}
};
speechRecognizer.ContinuousRecognitionSession.ResultGenerated += (sender, args) =>
{
DebugLog.Log(LogLevel.Info, args.Result.Text);
DebugLog.Log(LogLevel.Info, "ListenForDictation " + args.Result.Text);
if (OnSpeechResults != null)
{
Utils.RunOnUnityAppThread(
() =>
{
OnSpeechResults(new CallbackResponse <SpeechArguments> {
Result = new SpeechArguments {
Status = SpeechResultStatus.Dictation, Text = args.Result.Text
}, Status = CallbackStatus.Success, Exception = null
});
});
}
};
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
isListening = true;
}
catch (Exception ex)
{
OnSpeechResults(new CallbackResponse <SpeechArguments> {
Result = null, Status = CallbackStatus.Failure, Exception = ex
});
return;
}
});
}
private static void InterstitialAd_ErrorOccurred(object sender, AdErrorEventArgs e)
{
DebugLog.Log(LogLevel.Info, "ErrorOccurred " + e.ErrorMessage);
isShowRequested = false;
}
private static void InterstitialAd_Cancelled(object sender, object e)
{
DebugLog.Log(LogLevel.Info, "Cancelled");
isShowRequested = false;
}
