/// <summary>
/// Handle when the action is clicked in context menu or action pane
/// </summary>
/// <param name="action"></param>
/// <param name="status"></param>
protected override void OnAction(Action action, AsyncStatus status)
{
if ((string)action.Tag == "ShowError")
{
// trigger MMC to show the new view
((ViewSwitchingScopeNode)this.ScopeNode).SwapView(this, "Simulated Error Message", typeof(ErrorMessageView));
}
}
void OnMessageDialogShowAsyncCompleted(IAsyncOperation<IUICommand> asyncInfo, AsyncStatus asyncStatus) {
// Get the Color value
IUICommand command = asyncInfo.GetResults();
clr = (Color)command.Id;
// Use a Dispatcher to run in the UI thread
IAsyncAction asyncAction = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
OnDispatcherRunAsyncCallback);
}
async private void GetConnectivityIntervalsAsyncHandler(IAsyncOperation<IReadOnlyList<ConnectivityInterval>> asyncInfo, AsyncStatus asyncStatus)
{
if (asyncStatus == AsyncStatus.Completed)
{
try
{
String outputString = string.Empty;
IReadOnlyList<ConnectivityInterval> connectivityIntervals = asyncInfo.GetResults();
if (connectivityIntervals == null)
{
rootPage.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser("The Start Time cannot be later than the End Time, or in the future", NotifyType.StatusMessage);
});
return;
}
// Get the NetworkUsage for each ConnectivityInterval
foreach (ConnectivityInterval connectivityInterval in connectivityIntervals)
{
outputString += PrintConnectivityInterval(connectivityInterval);
DateTimeOffset startTime = connectivityInterval.StartTime;
DateTimeOffset endTime = startTime + connectivityInterval.ConnectionDuration;
IReadOnlyList<NetworkUsage> networkUsages = await InternetConnectionProfile.GetNetworkUsageAsync(startTime, endTime, Granularity, NetworkUsageStates);
foreach (NetworkUsage networkUsage in networkUsages)
{
outputString += PrintNetworkUsage(networkUsage, startTime);
startTime += networkUsage.ConnectionDuration;
}
}
rootPage.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser(outputString, NotifyType.StatusMessage);
});
}
catch (Exception ex)
{
rootPage.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser("An unexpected error occurred: " + ex.Message, NotifyType.ErrorMessage);
});
}
}
else
{
rootPage.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser("GetConnectivityIntervalsAsync failed with message:\n" + asyncInfo.ErrorCode.Message, NotifyType.ErrorMessage);
});
}
}
/// <summary>
/// Handle triggered action
/// </summary>
/// <param name="action">triggered action</param>
/// <param name="status">asynchronous status to update console</param>
protected override void OnSelectionAction(Action action, AsyncStatus status)
{
switch ((string)action.Tag)
{
case "ShowSelection":
{
selectionControl.ShowSelection();
break;
}
}
}
/// <summary>
/// Handles the view level actions
/// </summary>
/// <param name="action">action that was triggered</param>
/// <param name="status">asynchronous status for updating the console</param>
protected override void OnAction(Action action, AsyncStatus status)
{
switch ((string)action.Tag)
{
case "Refresh":
{
this.Refresh();
break;
}
}
}
/// <summary>
/// Handle any setup necessary
/// </summary>
/// <param name="status">asynchronous status for updating the console</param>
protected override void OnInitialize(AsyncStatus status)
{
// handle any basic stuff
base.OnInitialize(status);
// get typed reference to the hosted control
// setup by the FormViewDescription
selectionControl = (SelectionControl)this.Control;
//// load data in
Refresh();
}
private async void Completed(IAsyncAction asyncInfo, AsyncStatus asyncStatus)
{
if (asyncStatus == AsyncStatus.Canceled)
return;
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.High, () =>
{
HyperlinkButton.Visibility = _isCompleted
? Visibility.Visible
: Visibility.Collapsed;
greeting.Text = "bitti!";
});
}
void AppServiceConnectionCompleted(IAsyncOperation<AppServiceConnectionStatus> operation, AsyncStatus asyncStatus)
{
var status = operation.GetResults();
if (status == AppServiceConnectionStatus.Success)
{
var secondOperation = _appServiceConnection.SendMessageAsync(null);
secondOperation.Completed = (_, __) =>
{
_appServiceConnection.Dispose();
_appServiceConnection = null;
};
}
}
private void GeoLocationCompleted(IAsyncOperation<Geoposition> asyncInfo, AsyncStatus asyncStatus)
{
if (asyncStatus == AsyncStatus.Completed)
{
var deviceLocation = (Geoposition)asyncInfo.GetResults();
try
{
DeviceLocation = GeoLocationAdapter.GetLocationFromDeviceGeoPositionObject(deviceLocation);
}
catch (Exception ex)
{
DeviceLocation = GeoLocationAdapter.GetDefaultLocaiton();
}
OnLocationLoadSuccess(new LocationEventArgs(DeviceLocation));
}
}
/// <summary>
/// Define the ListView's structure and actions
/// </summary>
/// <param name="status">asynchronous status for updating the console</param>
protected override void OnInitialize(AsyncStatus status)
{
// do default handling
base.OnInitialize(status);
// Create a set of columns for use in the list view
// Define the default column title
this.Columns[0].Title = "User";
this.Columns[0].SetWidth(300);
// Add detail column
this.Columns.Add(new MmcListViewColumn("Birthday", 200));
// Set to show all columns
this.Mode = MmcListViewMode.Report;
// Load the list with values
Refresh();
}
private void OnConnected(IAsyncAction action, AsyncStatus target)
{
if (target == AsyncStatus.Completed)
{
this.connection.Connected();
this.writer = new DataWriter(this.socket.OutputStream);
this.reader = new DataReader(this.socket.InputStream);
NetworkMessage m = new NetworkMessage();
m.MessageCategory = SystemMessages.SystemPrefix;
m.MessageType = SystemMessages.Connect;
AuthenticationInfo auth = new AuthenticationInfo();
auth.Username = this.id;
m.MessageContent = NetworkSerializer.Serialize(auth);
this.SendMessage(m);
this.reader.InputStreamOptions = InputStreamOptions.Partial;
DataReaderLoadOperation operation = this.reader.LoadAsync(256);
operation.Completed = new AsyncOperationCompletedHandler<uint>(this.ReaderHasData);
}
}
async private void GeocodingCompleted(IAsyncOperation<MapLocationFinderResult> asyncInfo, AsyncStatus asyncStatus)
{
// Get the result
MapLocationFinderResult result = asyncInfo.GetResults();
//
// Update the UI thread by using the UI core dispatcher.
//
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// Update the status
Status = result.Status;
// Update th Address
Address = result.Locations[0].Address.FormattedAddress;
// If there are Name and/or description provided and they are not set yet, set them!
if (Name == NameDefault && result.Locations[0].DisplayName != null && result.Locations[0].DisplayName != "") Name = result.Locations[0].DisplayName;
if (Description == DescriptionDefault && result.Locations[0].Description != null && result.Locations[0].Description != "") Description = result.Locations[0].Description;
// If the Name is still empty, use the Address
if (Name == NameDefault || Name == "") Name = Address;
});
}
/// <summary>
/// Load in any saved data
/// </summary>
/// <param name="status">asynchronous status for updating the console</param>
/// <param name="persistenceData">binary data stored in the console file</param>
protected override void OnLoadCustomData(AsyncStatus status, byte[] persistenceData)
{
status.ReportProgress(0, 10, "Loading..");
// Deserialize the object
try
{
MemoryStream stream = new MemoryStream(persistenceData);
BinaryFormatter deserializer = new BinaryFormatter();
mgrConfig.SetInitData((InitialisationData)deserializer.Deserialize(stream));
// Initialise the config object
mgrConfig.Initialise();
// Load the CA data into the root node
((OSCAroot)RootNode).Load();
status.Complete("Manager configuration: " + mgrConfig.InitData.configFile, true);
}
catch (SerializationException)
{
MessageBox.Show("No configuration data defined", "OSCA", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
//Successfull network connection handler on hololens
#if !UNITY_EDITOR
public void NetworkConnectedHandler(IAsyncAction asyncInfo, AsyncStatus status)
{
// Status completed is successful.
if (status == AsyncStatus.Completed)
{
//Creating the writer that will be repsonsible to send a message through Rosbridge
dataWriter = new DataWriter(messageWebSocket.OutputStream);
//Connect to all topics in _subscribers and _publishers
foreach (Type p in _subscribers)
{
dataWriter.WriteString(ROSBridgeMsg.Subscribe(GetMessageTopic(p), GetMessageType(p)));
dataWriter.StoreAsync();
Debug.Log("Sending " + ROSBridgeMsg.Subscribe(GetMessageTopic(p), GetMessageType(p)));
}
foreach (Type p in _publishers)
{
dataWriter.WriteString(ROSBridgeMsg.Advertise(GetMessageTopic(p), GetMessageType(p)));
dataWriter.StoreAsync();
Debug.Log("Sending " + ROSBridgeMsg.Advertise(GetMessageTopic(p), GetMessageType(p)));
}
_connected = true;
}
}
/// <summary>
/// Called when [expand].
/// </summary>
/// <param name="status">The status.</param>
protected override void OnExpand(AsyncStatus status)
{
StandardCollectionExpand(status, new DatabaseModel.Fetch(), (m => new DatabaseNode(m)));
}
protected override void OnRefresh(AsyncStatus status)
{
base.OnRefresh(status);
Refresh();
}
internal override void OnCompleted(AsyncActionWithProgressCompletedHandler <TProgress> userCompletionHandler, AsyncStatus asyncStatus)
{
Debug.Assert(userCompletionHandler != null);
userCompletionHandler(this, asyncStatus);
}
protected override void OnShutdown(AsyncStatus status)
{
_bootstrapper.Shutdown();
}
public void CompletedStart(IAsyncAction asyncInfo, AsyncStatus asyncStatus)
{
if (asyncStatus == AsyncStatus.Completed)
{
_recordingStatus = RecordingStatus.recording;
}
}
public abstract void TraceOperationCompletion(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, AsyncStatus status);
/// <summary>
/// Called when [expand].
/// </summary>
/// <param name="status">The status.</param>
protected override void OnExpand(AsyncStatus status)
{
var databaseModel = ((DatabaseNode)Parent.Parent).DatabaseModel;
StandardCollectionExpand(status, new DatabaseSecurityLoginModel.Fetch(databaseModel), (m => new DatabaseSecurityLoginNode(m)));
}
internal virtual void OnCompleted(TCompletedHandler userCompletionHandler, AsyncStatus asyncStatus)
{
Debug.Assert(false, "This (sub-)type of IAsyncInfo does not support completion notifications "
+ " (" + this.GetType().ToString() + ")");
}
/// <summary>Bridge to Completed handler on IAsyncOperation{TResult}.</summary>
internal void CompleteFromAsyncOperation(IAsyncOperation <TResult> asyncInfo, AsyncStatus asyncStatus)
{
Complete(asyncInfo, ai => ((IAsyncOperation <TResult>)ai).GetResults(), asyncStatus); // delegate cached by compiler
}
public void Cancel()
{
Status = AsyncStatus.Canceled;
Complete();
}
public void HandleCompilationCompleted(IAsyncOperation<SpeechRecognitionCompilationResult> opInfo, AsyncStatus status)
{
if (status == AsyncStatus.Completed)
{
System.Diagnostics.Debug.WriteLine("Compilation Complete");
var result = opInfo.GetResults();
System.Diagnostics.Debug.WriteLine(result.Status.ToString());
}
}
// Event handler when item recognition is completed
private void ItemRecognitionCompletedHandler(IAsyncOperation<SpeechRecognitionResult> asyncInfo, AsyncStatus asyncStatus)
{
isListening = false;
var results = asyncInfo.GetResults();
if (results.Status != SpeechRecognitionResultStatus.Success)
{
TextToSpeech.Speak("Sorry, I wasn't able to hear you. Try again later.");
return;
}
if (results.Confidence == SpeechRecognitionConfidence.High | results.Confidence == SpeechRecognitionConfidence.Medium)
{
requestedItems.Add(requestor + " wants " + results.Text);
TextToSpeech.Speak(results.Text + "\n" + "Got it. I have added it your Christmas list" + requestor);
}
else
{
TextToSpeech.Speak("Sorry, I did not get that.");
}
}
// Event handler when name recognition is completed
private void NameRecognitionCompletedHandler(IAsyncOperation<SpeechRecognitionResult> asyncInfo, AsyncStatus asyncStatus)
{
isListening = false;
var results = asyncInfo.GetResults();
if (results.Status != SpeechRecognitionResultStatus.Success)
{
TextToSpeech.Speak("Sorry, I wasn't able to hear you. Try again later.");
return;
}
if (results.Confidence == SpeechRecognitionConfidence.High | results.Confidence == SpeechRecognitionConfidence.Medium)
{
requestor = results.Text;
if (requestor == listOfNames.First())
{
if (requestedItems.Count == 0)
{
TextToSpeech.Speak("Hello" + requestor + "\n" + "The list is empty.");
}
else
{
TextToSpeech.Speak("Hello" + requestor + "\n" + "Here is the list");
foreach (string item in requestedItems)
{
Task.Delay(4000).Wait();
TextToSpeech.Speak(item);
}
}
}
else
{
TextToSpeech.Speak("Hello" + requestor + "\n" + "What would you like for Christmas?");
Task.Delay(4000).Wait();
RecognizeChristmasListItem();
}
}
else
{
TextToSpeech.Speak("Sorry, I do not recognize you.");
}
}
public async void CompletedStop(IAsyncAction asyncInfo, AsyncStatus asyncStatus)
{
if (asyncStatus == AsyncStatus.Completed)
{
if (_recordingStatus == RecordingStatus.recording)
{
_recordingStatus = RecordingStatus.sucessful;
var file = await ApplicationData.Current.LocalFolder.GetFileAsync("recording.mp4");
var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
mediaElement.SetSource(stream, "");
mediaElement.Play();
});
_recordingStatus = RecordingStatus.stopped;
}
if (_recordingStatus == RecordingStatus.failed)
{
// Recording has failed somewhere. Set the recording status to stopped.
_recordingStatus = RecordingStatus.stopped;
}
}
}
/// <summary>
/// Speech recognition completed.
/// </summary>
private async void Recognition_Completed(IAsyncOperation<SpeechRecognitionResult> asyncInfo, AsyncStatus asyncStatus)
{
var results = asyncInfo.GetResults();
if (results.Confidence != SpeechRecognitionConfidence.Rejected)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new DispatchedHandler(
() =>
{
this.txtCortanaMessages.Text = "Je recherche : " + results.Text + "...";
CortanaSearchViewModel viewModel = DataContext as CortanaSearchViewModel;
viewModel.PropertyChanged += viewModel_PropertyChanged;
viewModel.LoadResults(SettingsValues.SiteUrl, results.Text, SettingsValues.LoginName, SettingsValues.Password);
}));
}
else
{
this.txtCortanaMessages.Text = "Désolé, je n'ai pas compris.";
}
}
/// <summary>Completes the task from the completed asynchronous operation.</summary>
/// <param name="asyncInfo">The asynchronous operation.</param>
/// <param name="getResultsFunction">A function used to retrieve the TResult from the async operation; may be null.</param>
/// <param name="asyncStatus">The status of the asynchronous operation.</param>
private void Complete(IAsyncInfo asyncInfo, Func <IAsyncInfo, TResult> getResultsFunction, AsyncStatus asyncStatus)
{
if (asyncInfo == null)
{
throw new ArgumentNullException(nameof(asyncInfo));
}
Contract.EndContractBlock();
AsyncCausalitySupport.RemoveFromActiveTasks(this.Task);
try
{
Debug.Assert(asyncInfo.Status == asyncStatus,
"asyncInfo.Status does not match asyncStatus; are we dealing with a faulty IAsyncInfo implementation?");
// Assuming a correct underlying implementation, the task should not have been
// completed yet. If it is completed, we shouldn't try to do any further work
// with the operation or the task, as something is horked.
bool taskAlreadyCompleted = Task.IsCompleted;
Debug.Assert(!taskAlreadyCompleted, "Expected the task to not yet be completed.");
if (taskAlreadyCompleted)
{
throw new InvalidOperationException(SR.InvalidOperation_InvalidAsyncCompletion);
}
// Clean up our registration with the cancellation token, noting that we're now in the process of cleaning up.
CancellationTokenRegistration ctr;
lock (StateLock)
{
_completing = true;
ctr = _ctr; // under lock to avoid torn reads
_ctr = default(CancellationTokenRegistration);
}
ctr.TryDeregister(); // It's ok if we end up unregistering a not-initialized registration; it'll just be a nop.
try
{
// Find out how the async operation completed. It must be in a terminal state.
bool terminalState = asyncStatus == AsyncStatus.Completed ||
asyncStatus == AsyncStatus.Canceled ||
asyncStatus == AsyncStatus.Error;
Debug.Assert(terminalState, "The async operation should be in a terminal state.");
if (!terminalState)
{
throw new InvalidOperationException(SR.InvalidOperation_InvalidAsyncCompletion);
}
// Retrieve the completion data from the IAsyncInfo.
TResult result = default(TResult);
Exception error = null;
if (asyncStatus == AsyncStatus.Error)
{
error = asyncInfo.ErrorCode;
// Defend against a faulty IAsyncInfo implementation:
if (error == null)
{
Debug.Assert(false, "IAsyncInfo.Status == Error, but ErrorCode returns a null Exception (implying S_OK).");
error = new InvalidOperationException(SR.InvalidOperation_InvalidAsyncCompletion);
}
else
{
error = asyncInfo.ErrorCode.AttachRestrictedErrorInfo();
}
}
else if (asyncStatus == AsyncStatus.Completed && getResultsFunction != null)
{
try
{
result = getResultsFunction(asyncInfo);
}
catch (Exception resultsEx)
{
// According to the WinRT team, this can happen in some egde cases, such as marshalling errors in GetResults.
error = resultsEx;
asyncStatus = AsyncStatus.Error;
}
}
// Nothing to retrieve for a canceled operation or for a completed operation with no result.
// Complete the task based on the previously retrieved results:
bool success = false;
switch (asyncStatus)
{
case AsyncStatus.Completed:
if (AsyncCausalitySupport.LoggingOn)
{
AsyncCausalitySupport.TraceOperationCompletedSuccess(this.Task);
}
success = base.TrySetResult(result);
break;
case AsyncStatus.Error:
Debug.Assert(error != null, "The error should have been retrieved previously.");
success = base.TrySetException(error);
break;
case AsyncStatus.Canceled:
success = base.TrySetCanceled(_ct.IsCancellationRequested ? _ct : new CancellationToken(true));
break;
}
Debug.Assert(success, "Expected the outcome to be successfully transfered to the task.");
}
catch (Exception exc)
{
// This really shouldn't happen, but could in a variety of misuse cases
// such as a faulty underlying IAsyncInfo implementation.
Debug.Assert(false, string.Format("Unexpected exception in Complete: {0}", exc.ToString()));
if (AsyncCausalitySupport.LoggingOn)
{
AsyncCausalitySupport.TraceOperationCompletedError(this.Task);
}
// For these cases, store the exception into the task so that it makes its way
// back to the caller. Only if something went horribly wrong and we can't store the exception
// do we allow it to be propagated out to the invoker of the Completed handler.
if (!base.TrySetException(exc))
{
Debug.Assert(false, "The task was already completed and thus the exception couldn't be stored.");
throw;
}
}
}
finally
{
// We may be called on an STA thread which we don't own, so make sure that the RCW is released right
// away. Otherwise, if we leave it up to the finalizer, the apartment may already be gone.
if (Marshal.IsComObject(asyncInfo))
{
Marshal.ReleaseComObject(asyncInfo);
}
}
} // private void Complete(..)
protected override void OnRefresh(AsyncStatus status)
{
PopulateChildren();
}
private void BackgroundTaskInitializationCompleted(IAsyncAction action, AsyncStatus status)
{
if (status == AsyncStatus.Completed)
{
Debug.WriteLine("Background Audio Task initialized");
}
else if (status == AsyncStatus.Error)
{
Debug.WriteLine("Background Audio Task could not initialized due to an error ::" + action.ErrorCode.ToString());
}
}
protected override void OnSelectionAction(Microsoft.ManagementConsole.Action action, AsyncStatus status)
{
switch ((int)action.Tag)
{
case ACTION_SHOW_PROPERTIES:
ShowProperties();
break;
}
}
protected override void OnExpand(AsyncStatus status)
{
base.OnExpand(status);
}
private void OnRecognitionCompleteHandler(IAsyncOperation<SpeechRecognitionResult> asyncInfo, AsyncStatus asyncStatus)
{
asyncInfo.Close();
}
private static void DoTestWrite(Func <Stream> createStreamFunc, bool mustInvokeProgressHandler)
{
Stream backingStream = createStreamFunc();
using (IOutputStream stream = backingStream.AsOutputStream())
{
// Create test data
Random rnd = new Random(20100720); // Must be a different seed than used for TestStreamProvider.ModelStreamContents
byte[] modelWriteData = new byte[0xA000];
rnd.NextBytes(modelWriteData);
// Start test
IBuffer buffer = modelWriteData.AsBuffer();
// ibuffer.Length for IBuffer created by Array.ToBuffer(void) must equal to array.Length
Assert.Equal((uint)modelWriteData.Length, buffer.Length);
// ibuffer.Capacity for IBuffer created by Array.ToBuffer(void) must equal to array.Length
Assert.Equal((uint)modelWriteData.Length, buffer.Capacity);
IAsyncOperationWithProgress <uint, uint> writeOp = stream.WriteAsync(buffer);
// Note the race. By the tie we get here, the status of the op may be started or already completed.
AsyncStatus writeOpStatus = writeOp.Status;
Assert.True(writeOpStatus == AsyncStatus.Completed || writeOpStatus == AsyncStatus.Started, "New writeOp must have Status = Started or Completed (race)");
uint writeOpId = writeOp.Id;
bool progressCallbackInvoked = false;
bool completedCallbackInvoked = false;
uint resultBytesWritten = 0;
EventWaitHandle waitHandle = new ManualResetEvent(false);
writeOp.Progress = (asyncWriteOp, bytesCompleted) =>
{
progressCallbackInvoked = true;
// asyncWriteOp.Id in a progress callback must match the ID of the asyncWriteOp to which the callback was assigned
Assert.Equal(writeOpId, asyncWriteOp.Id);
// asyncWriteOp.Status must be 'Started' for an asyncWriteOp in progress
Assert.Equal(AsyncStatus.Started, asyncWriteOp.Status);
// bytesCompleted must be in range [0, maxBytesToWrite] asyncWriteOp in progress
Assert.InRange(bytesCompleted, 0u, (uint)TestStreamProvider.ModelStreamLength);
};
writeOp.Completed = (asyncWriteOp, passedStatus) =>
{
try
{
completedCallbackInvoked = true;
// asyncWriteOp.Id in a completion callback must match the ID of the asyncWriteOp to which the callback was assigned
Assert.Equal(writeOpId, asyncWriteOp.Id);
// asyncWriteOp.Status must match passedStatus for a completed asyncWriteOp
Assert.Equal(passedStatus, asyncWriteOp.Status);
// asyncWriteOp.Status must be 'Completed' for a completed asyncWriteOp
Assert.Equal(AsyncStatus.Completed, asyncWriteOp.Status);
uint bytesWritten = asyncWriteOp.GetResults();
// asyncWriteOp.GetResults() must return that all required bytes were written for a completed asyncWriteOp
Assert.Equal((uint)modelWriteData.Length, bytesWritten);
resultBytesWritten = bytesWritten;
}
finally
{
waitHandle.Set();
}
};
// Now, let's block until the write op is complete.
// We speculate that it will complete within 3500 msec, although under high load it may not be.
// If the test fails we should use a better way to determine if callback is really not invoked, or if it's just too slow.
waitHandle.WaitOne(500);
waitHandle.WaitOne(1000);
waitHandle.WaitOne(2000);
if (mustInvokeProgressHandler)
{
Assert.True(progressCallbackInvoked,
"Progress callback specified to WriteAsync callback must be invoked when reading from this kind of stream");
}
Assert.True(completedCallbackInvoked, "Completion callback specified to WriteAsync callback must be invoked");
// writeOp.Status must be 'Completed' for a completed async writeOp
Assert.Equal(AsyncStatus.Completed, writeOp.Status);
// writeOp.GetResults() must return that all required bytes were written for a completed async writeOp
Assert.Equal((uint)modelWriteData.Length, resultBytesWritten);
// Check contents
backingStream.Seek(0, SeekOrigin.Begin);
byte[] verifyBuff = new byte[modelWriteData.Length + 1024];
int r = backingStream.Read(verifyBuff, 0, verifyBuff.Length);
for (int i = 0; i < modelWriteData.Length; i++)
{
Assert.Equal(modelWriteData[i], verifyBuff[i]);
}
}
}
public void Start()
{
Status = AsyncStatus.Started;
}
/// <summary>
/// Completed Channel creation handler
/// </summary>
/// <param name="operation"></param>
/// <param name="status"></param>
void OnChannelCreationCompleted(IAsyncOperation<PushNotificationChannel> operation, AsyncStatus status)
{
if (operation.Status == AsyncStatus.Completed)
{
pushNotificationChannel = operation.GetResults();
// Send these values together with user data to your server of choice
var notificationUri = pushNotificationChannel.Uri;
var expirationTime = pushNotificationChannel.ExpirationTime;
}
}
protected override void OnRefresh(AsyncStatus status)
{
// TODO: Not implemented yet
}
private void ReaderHasData(IAsyncOperation<uint> operation, AsyncStatus target)
{
uint len = operation.GetResults();
byte[] buffer = new byte[len];
this.reader.ReadBytes(buffer);
this.ProcessBytes(buffer, (int)len);
DataReaderLoadOperation operation2 = this.reader.LoadAsync(256);
operation2.Completed = new AsyncOperationCompletedHandler<uint>(this.ReaderHasData);
}
protected override void OnExpand(AsyncStatus status)
{
base.OnExpand(status);
AddAllServers();
}
/// <summary>
/// Completion callback for the asynchronous call:
/// it is called whether the drop succeeded, or the user released the pointer on a non-target
/// or else we cancelled the operation from the timer's callback
/// </summary>
/// <param name="asyncInfo"></param>
/// <param name="asyncStatus"></param>
private void DragCompleted(IAsyncOperation<DataPackageOperation> asyncInfo, AsyncStatus asyncStatus)
{
_dragOperation = null;
if (_timer != null) _timer.Stop();
EndRound((asyncStatus == AsyncStatus.Completed) && (asyncInfo.GetResults() == DataPackageOperation.Copy));
}
/// <summary>Bridge to Completed handler on IAsyncActionWithProgress{TProgress}.</summary>
internal void CompleteFromAsyncActionWithProgress <TProgress>(IAsyncActionWithProgress <TProgress> asyncInfo, AsyncStatus asyncStatus)
{
Complete(asyncInfo, null, asyncStatus);
}
/// <summary>
/// The spoken stream is ready.
/// </summary>
private async void SpokenStreamCompleted(IAsyncOperation<SpeechSynthesisStream> asyncInfo, AsyncStatus asyncStatus)
{
//Debug.WriteLine("SpokenStreamCompleted");
// Make sure to be on the UI Thread.
var synthesisStream = asyncInfo.GetResults();
await media.Dispatcher.RunAsync(
Windows.UI.Core.CoreDispatcherPriority.Normal,
new DispatchedHandler(() => { media.AutoPlay = true; media.SetSource(synthesisStream, synthesisStream.ContentType); media.Play(); })
);
}
/// <summary>Bridge to Completed handler on IAsyncOperationWithProgress{TResult,TProgress}.</summary>
internal void CompleteFromAsyncOperationWithProgress <TProgress>(IAsyncOperationWithProgress <TResult, TProgress> asyncInfo, AsyncStatus asyncStatus)
{
// delegate cached by compiler:
Complete(asyncInfo, ai => ((IAsyncOperationWithProgress <TResult, TProgress>)ai).GetResults(), asyncStatus);
}
private void GetConnectivityIntervalsAsyncHandler(IAsyncOperation<IReadOnlyList<ConnectivityInterval>> asyncInfo, AsyncStatus asyncStatus)
{
if (asyncStatus == AsyncStatus.Completed)
{
try
{
String outputString = string.Empty;
IReadOnlyList<ConnectivityInterval> connectivityIntervals = asyncInfo.GetResults();
if (connectivityIntervals == null)
{
PrintErrorAsync("The Start Time cannot be later than the End Time, or in the future");
return;
}
// Get the NetworkUsage for each ConnectivityInterval
foreach (ConnectivityInterval connectivityInterval in connectivityIntervals)
{
outputString += PrintConnectivityInterval(connectivityInterval);
}
PrintOutputAsync(outputString);
PrintStatusAsync("Success");
}
catch (Exception ex)
{
PrintErrorAsync("An unexpected error occurred: " + ex.Message);
}
}
else
{
PrintErrorAsync("GetConnectivityIntervalsAsync failed with message:\n" + asyncInfo.ErrorCode.Message);
}
}
/// <summary>Bridge to Completed handler on IAsyncAction.</summary>
internal void CompleteFromAsyncAction(IAsyncAction asyncInfo, AsyncStatus asyncStatus)
{
Complete(asyncInfo, null, asyncStatus);
}
public abstract void TraceOperationCompletion(CausalityTraceLevel traceLevel, CausalitySource source, Guid platformId, ulong operationId, AsyncStatus status);
protected override void OnExpand(AsyncStatus status)
{
//override and do nothing
}
public int Invoke([NativeTypeName("IAsyncOperationWithProgress<TResult_logical, TProgress_logical> *")] IAsyncOperationWithProgress <TResult, TProgress> *asyncInfo, [NativeTypeName("Windows::Foundation::AsyncStatus")] AsyncStatus status)
{
return(((delegate * unmanaged <IAsyncOperationWithProgressCompletedHandler <TResult, TProgress> *, IAsyncOperationWithProgress <TResult, TProgress> *, AsyncStatus, int>)(lpVtbl[3]))((IAsyncOperationWithProgressCompletedHandler <TResult, TProgress> *)Unsafe.AsPointer(ref this), asyncInfo, status));
}
private static void DoTestRead(Func <IInputStream> createStreamFunc, InputStreamOptions inputStreamOptions, bool mustInvokeProgressHandler, bool completesSynchronously)
{
IInputStream stream = createStreamFunc();
IBuffer buffer = WindowsRuntimeBuffer.Create(TestStreamProvider.ModelStreamLength);
IAsyncOperationWithProgress <IBuffer, uint> readOp = stream.ReadAsync(buffer, (uint)TestStreamProvider.ModelStreamLength, inputStreamOptions);
if (completesSynchronously)
{
// New readOp for a stream where we know that reading is sycnhronous must have Status = Completed
Assert.Equal(AsyncStatus.Completed, readOp.Status);
}
else
{
// Note the race. By the tie we get here, the status of the op may be started or already completed.
AsyncStatus readOpStatus = readOp.Status;
Assert.True(readOpStatus == AsyncStatus.Completed || readOpStatus == AsyncStatus.Started, "New readOp must have Status = Started or Completed (race)");
}
bool progressCallbackInvoked = false;
bool completedCallbackInvoked = false;
uint readOpId = readOp.Id;
EventWaitHandle waitHandle = new ManualResetEvent(false);
readOp.Progress = (asyncReadOp, bytesCompleted) =>
{
progressCallbackInvoked = true;
// asyncReadOp.Id in a progress callback must match the ID of the asyncReadOp to which the callback was assigned
Assert.Equal(readOpId, asyncReadOp.Id);
// asyncReadOp.Status must be 'Started' for an asyncReadOp in progress
Assert.Equal(AsyncStatus.Started, asyncReadOp.Status);
// bytesCompleted must be in range [0, maxBytesToRead] asyncReadOp in progress
Assert.InRange(bytesCompleted, 0u, (uint)TestStreamProvider.ModelStreamLength);
};
readOp.Completed = (asyncReadOp, passedStatus) =>
{
try
{
completedCallbackInvoked = true;
// asyncReadOp.Id in a completion callback must match the ID of the asyncReadOp to which the callback was assigned
Assert.Equal(readOpId, asyncReadOp.Id);
// asyncReadOp.Status must match passedStatus for a completed asyncReadOp
Assert.Equal(passedStatus, asyncReadOp.Status);
// asyncReadOp.Status must be 'Completed' for a completed asyncReadOp
Assert.Equal(AsyncStatus.Completed, asyncReadOp.Status);
IBuffer resultBuffer = asyncReadOp.GetResults();
// asyncReadOp.GetResults() must not return null for a completed asyncReadOp
Assert.NotNull(resultBuffer);
AssertExtensions.GreaterThan(resultBuffer.Capacity, 0u, "resultBuffer.Capacity should be more than zero in completed callback");
AssertExtensions.GreaterThan(resultBuffer.Length, 0u, "resultBuffer.Length should be more than zero in completed callback");
AssertExtensions.LessThanOrEqualTo(resultBuffer.Length, resultBuffer.Capacity, "resultBuffer.Length should be <= Capacity in completed callback");
if (inputStreamOptions == InputStreamOptions.None)
{
// resultBuffer.Length must be equal to requested number of bytes when an asyncReadOp with
// InputStreamOptions.None completes successfully
Assert.Equal(resultBuffer.Length, (uint)TestStreamProvider.ModelStreamLength);
}
if (inputStreamOptions == InputStreamOptions.Partial)
{
AssertExtensions.LessThanOrEqualTo(resultBuffer.Length, (uint)TestStreamProvider.ModelStreamLength,
"resultBuffer.Length must be <= requested number of bytes with InputStreamOptions.Partial in completed callback");
}
buffer = resultBuffer;
}
finally
{
waitHandle.Set();
}
};
// Now, let's block until the read op is complete.
// We speculate that it will complete within 3500 msec, although under high load it may not be.
// If the test fails we should use a better way to determine if callback is really not invoked, or if it's just too slow.
waitHandle.WaitOne(500);
waitHandle.WaitOne(1000);
waitHandle.WaitOne(2000);
if (mustInvokeProgressHandler)
{
Assert.True(progressCallbackInvoked,
"Progress callback specified to ReadAsync callback must be invoked when reading from this kind of stream");
}
Assert.True(completedCallbackInvoked,
"Completion callback specified to ReadAsync callback must be invoked");
// readOp.Status must be 'Completed' for a completed async readOp
Assert.Equal(AsyncStatus.Completed, readOp.Status);
AssertExtensions.GreaterThan(buffer.Capacity, 0u, "buffer.Capacity should be greater than zero bytes");
AssertExtensions.GreaterThan(buffer.Length, 0u, "buffer.Length should be greater than zero bytes");
AssertExtensions.LessThanOrEqualTo(buffer.Length, buffer.Capacity, "buffer.Length <= buffer.Capacity is required for a completed async readOp");
if (inputStreamOptions == InputStreamOptions.None)
{
// buffer.Length must be equal to requested number of bytes when an async readOp with
// InputStreamOptions.None completes successfully
Assert.Equal((uint)TestStreamProvider.ModelStreamLength, buffer.Length);
}
if (inputStreamOptions == InputStreamOptions.Partial)
{
AssertExtensions.LessThanOrEqualTo(buffer.Length, (uint)TestStreamProvider.ModelStreamLength,
"resultBuffer.Length must be <= requested number of bytes with InputStreamOptions.Partial");
}
byte[] results = new byte[buffer.Length];
buffer.CopyTo(0, results, 0, (int)buffer.Length);
Assert.True(TestStreamProvider.CheckContent(results, 0, (int)buffer.Length),
"Result data returned from AsyncRead must be the same as expected from the test data source");
}
private void ConnectionCompletedHandler(IAsyncOperation <ConnectionSession> asyncInfo, AsyncStatus asyncStatus)
{
if (asyncInfo.Status == AsyncStatus.Completed)
{
rootPage.g_ConnectionSession = asyncInfo.GetResults();
UpdateOutputText("Connected to " + rootPage.g_ConnectionSession.ConnectionProfile.ProfileName + "\n" +
"Connectivity Level: " + rootPage.g_ConnectionSession.ConnectionProfile.GetNetworkConnectivityLevel());
// Transition button to Disconnect state
UpdateButtonText("Disconnect");
connectionResult.Close();
connectionResult = null;
}
else
{
UpdateOutputText(asyncStatus.ToString() + ": " + asyncInfo.ErrorCode.Message);
UpdateButtonText("Connect");
connectionResult = null;
}
}
public void Invoke(IAsyncAction asyncInfo, AsyncStatus asyncStatus)
{
_parent.Tick?.Invoke(_st.Elapsed);
using var act = _parent._compositor5.RequestCommitAsync();
act.SetCompleted(this);
}
/// <summary>
/// 获取用户位置后，触发本函数
/// </summary>
/// <param name="asyncInfo"></param>
/// <param name="asyncStatus"></param>
private void GetCurrentPosition(IAsyncOperation<Geoposition> asyncInfo, AsyncStatus asyncStatus)
{
Debug.WriteLine("获取到位置信息");
Geoposition currentGeoposition =asyncInfo.GetResults();
Geocoordinate coordinate= currentGeoposition.Coordinate;
//获取的数据有偏差
LatLng currentLatLng = new LatLng(coordinate.Latitude + 0.000423, coordinate.Longitude + 0.006090);
_daBeiJing = currentLatLng;
Debug.WriteLine(currentLatLng);
if(_amap!=null)
{
_amap.Dispatcher.BeginInvoke(() =>
{
_amap.AnimateCamera(CameraUpdateFactory.NewCameraPosition(currentLatLng, 17, _bearing, _tile), 2);//移动视角(动画效果)
_cameraIsNew = false;
if (_locationMarker == null)
{
//添加圆
_circle = _amap.AddCircle(new AMapCircleOptions
{
Center = currentLatLng, //圆点位置
Radius = (float)20, //半径
FillColor = Color.FromArgb(80, 100, 150, 255),//圆的填充颜色
StrokeWidth = 1, //边框粗细
StrokeColor = Color.FromArgb(80, 100, 150, 255) //圆的边框颜色
});
//添加点标注，用于标注地图上的点
_locationMarker = _amap.AddMarker(new AMapMarkerOptions
{
Position = currentLatLng, //图标的位置
//待修改，更换IconUri的图标//
IconUri = new Uri("Images/myLocationIcon.png", UriKind.RelativeOrAbsolute), //图标的URL
Anchor = new Point(0.5, 0.5) //图标中心点
});
}
else
{
//点标注和圆的位置在当前经纬度
_locationMarker.Position = currentLatLng;
_circle.Center = currentLatLng;
_circle.Radius = (float)20; //圆半径
}
});
}
}
internal void StreamOperationCompletedCallback(IAsyncInfo completedOperation, AsyncStatus unusedCompletionStatus)
{
try
{
if (_callbackInvoked)
{
throw new InvalidOperationException(SR.InvalidOperation_MultipleIOCompletionCallbackInvocation);
}
_callbackInvoked = true;
// This happens in rare stress cases in Console mode and the WinRT folks said they are unlikely to fix this in Dev11.
// Moreover, this can happen if the underlying WinRT stream has a faulty user implementation.
// If we did not do this check, we would either get the same exception without the explaining message when dereferencing
// completedOperation later, or we will get an InvalidOperation when processing the Op. With the check, they will be
// aggregated and the user will know what went wrong.
if (completedOperation == null)
{
throw new NullReferenceException(SR.NullReference_IOCompletionCallbackCannotProcessNullAsyncInfo);
}
_completedOperation = completedOperation;
// processCompletedOperationInCallback == false indicates that the stream is doing a blocking wait on the waitHandle of this IAsyncResult.
// In that case calls on completedOperation may deadlock if completedOperation is not free threaded.
// By setting processCompletedOperationInCallback to false the stream that created this IAsyncResult indicated that it
// will call ProcessCompletedOperation after the waitHandle is signalled to fetch the results.
if (_processCompletedOperationInCallback)
{
ProcessCompletedOperation();
}
}
catch (Exception ex)
{
_bytesCompleted = 0;
_errorInfo = ExceptionDispatchInfo.Capture(ex);
}
finally
{
_completed = true;
Interlocked.MemoryBarrier();
// From this point on, AsyncWaitHandle would create a handle that is readily set,
// so we do not need to check if it is being produced asynchronously.
if (_waitHandle != null)
{
_waitHandle.Set();
}
}
if (_userCompletionCallback != null)
{
_userCompletionCallback(this);
}
}
/// <summary>
///
/// </summary>
/// <param name="status"></param>
protected override void OnRefresh(AsyncStatus status)
{
Refresh();
}
protected override void OnShutdown(AsyncStatus status)
{
VMCASnapInEnvironment.Instance.SaveLocalData();
}
/// <summary>
/// Handle short cut style menu actions for selection
/// </summary>
/// <param name="action">triggered action</param>
/// <param name="status">asynchronous status used to update the console</param>
protected override void OnSelectionAction(Microsoft.ManagementConsole.Action action, AsyncStatus status)
{
X509Certificate cert = (X509Certificate)this.SelectedNodes[0].Tag;
switch ((string)action.Tag)
{
case "ViewCert":
SystemX509.X509Certificate2UI.DisplayCertificate(new SystemX509.X509Certificate2(cert.GetEncoded()));
break;
case "ExportCert":
CertSave certSave = new CertSave(context.caInfo);
certSave.cert = cert;
this.SnapIn.Console.ShowDialog(certSave);
break;
case "RevokeCert":
revokeCert revoke = new revokeCert(cert);
if (this.SnapIn.Console.ShowDialog(revoke) == DialogResult.OK)
{
context.caInfo.RevokeCertificate(cert, (CRLReason)revoke.cbReason.SelectedIndex);
Refresh();
}
break;
case "RenewCert":
break;
case "RekeyCert":
RekeyCert rekey = new RekeyCert(context.caInfo, cert);
if (this.SnapIn.Console.ShowDialog(rekey) == DialogResult.OK)
{
certSave = new CertSave(context.caInfo);
certSave.cert = rekey.cert;
this.SnapIn.Console.ShowDialog(certSave);
Refresh();
}
break;
case "UnRevokeCert":
context.caInfo.UnRevokeCertificate(cert);
Refresh();
break;
}
}
public void Cancel()
{
this.current.Cancel();
this.Status = AsyncStatus.Canceled;
}
public AsyncStatusTransition(AsyncStatus oldStatus, AsyncStatus newStatus)
{
this.oldStatus = oldStatus;
this.newStatus = newStatus;
}
