public void Init() { gtkWin = new Window("DRAL Retag"); var size = gtkWin.Display.PrimaryMonitor.Workarea.Size; gtkWin.Resize(size.Width, size.Width / 4 + 30); Box vbox = new Box(Orientation.Vertical, 0); Box images = new Box(Orientation.Horizontal, 2); Box buttons = new Box(Orientation.Horizontal, 2); buttons.BaselinePosition = BaselinePosition.Center; vbox.Add(images); vbox.Add(buttons); var siz = new MoyskleyTech.ImageProcessing.Image.Size(size.Width / 3, size.Width / 4); iOri = new FixedSizeImage(siz); iActivation = new FixedSizeImage(siz); iActivated = new FixedSizeImage(siz); images.Add(iOri); images.Add(iActivation); images.Add(iActivated); gtkWin.DeleteEvent += delegate { result.TrySetResult(false); }; Button btnOK = new Button() { Label = "OK" }; btnOK.Clicked += delegate { result.TrySetResult(true); gtkWin.Dispose(); }; Button btnCancel = new Button() { Label = "Cancel" }; btnCancel.Clicked += delegate { result.TrySetResult(false); gtkWin.Dispose(); }; buttons.Add(btnOK); buttons.Add(btnCancel); gtkWin.Add(vbox); }
public static void TransferCompletionToTask <T>(System.Threading.Tasks.TaskCompletionSource <T> tcs, System.ComponentModel.AsyncCompletedEventArgs e, Func <T> getResult, Action unregisterHandler) { if (e.UserState != tcs) { return; } try { unregisterHandler(); } finally { if (e.Cancelled) { tcs.TrySetCanceled(); } else if (e.Error != null) { tcs.TrySetException(e.Error); } else { tcs.TrySetResult(getResult()); } } }
public System.Threading.Tasks.Task <FluentHttpAsyncResult> ExecuteTaskAsync(object state) { var tcs = new System.Threading.Tasks.TaskCompletionSource <FluentHttpAsyncResult>(state); try { ExecuteAsync(ar => { if (ar.IsCancelled) { tcs.TrySetCanceled(); } if (ar.Exception != null) { tcs.TrySetException(ar.Exception); } else { tcs.TrySetResult(ar); } }, state); } catch (Exception ex) { tcs.TrySetException(ex); } return(tcs.Task); }
public System.Threading.Tasks.Task <HttpWebHelperAsyncResult> ExecuteTaskAsync(IHttpWebRequest httpWebRequest, Stream requestBody, object state) { var tcs = new System.Threading.Tasks.TaskCompletionSource <HttpWebHelperAsyncResult>(state); try { ExecuteAsync(httpWebRequest, requestBody, ar => { var asyncResult = (HttpWebHelperAsyncResult)ar; if (asyncResult.IsCancelled) { tcs.TrySetCanceled(); } if (asyncResult.Exception != null) { tcs.TrySetException(asyncResult.Exception); } else { tcs.TrySetResult(asyncResult); } }, state); } catch (Exception ex) { tcs.TrySetException(ex); } return(tcs.Task); }
// GET IMAGE FROM WEB URL ASYNC // ============================================================================= public static async System.Threading.Tasks.Task <Image> GetImageAsync(string url) { var tcs = new System.Threading.Tasks.TaskCompletionSource <Image>(); Image webImage = null; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url); request.Method = "GET"; await System.Threading.Tasks.Task.Factory.FromAsync <WebResponse>(request.BeginGetResponse, request.EndGetResponse, null) .ContinueWith(task => { var webResponse = (HttpWebResponse)task.Result; System.IO.Stream responseStream = webResponse.GetResponseStream(); /* * if (webResponse.ContentEncoding.ToLower().Contains("gzip")) * responseStream = new GZipStream(responseStream, CompressionMode.Decompress); * else if (webResponse.ContentEncoding.ToLower().Contains("deflate")) * responseStream = new DeflateStream(responseStream, CompressionMode.Decompress); */ if (responseStream != null) { webImage = Image.FromStream(responseStream); } tcs.TrySetResult(webImage); webResponse.Close(); responseStream.Close(); }); return(tcs.Task.Result); }
public static System.Threading.Tasks.Task <T> ExecuteTaskAsync <T>(this RestClient @this, RestRequest request) where T : new() { if (@this == null) { throw new NullReferenceException(); } var tcs = new System.Threading.Tasks.TaskCompletionSource <T>(); @this.ExecuteAsync <T>(request, (response) => { string rr = response.Content; if (response.StatusCode != System.Net.HttpStatusCode.OK) { tcs = null; } else { tcs.TrySetResult(response.Data); } }); return(tcs.Task); }
public void OnComplete(Task task) { if (task.IsSuccessful) { var docsObj = task.Result; if (docsObj is QuerySnapshot docs) { _tcs.TrySetResult(docs.Convert <T>()); } } }
public new IAsyncOperation <ContentDialogResult> ShowAsync() { var tcs = new System.Threading.Tasks.TaskCompletionSource <ContentDialogResult>(); nameBox.KeyDown += (sender, args) => { if (args.Key != Windows.System.VirtualKey.Enter) { return; } tcs.TrySetResult(ContentDialogResult.Primary); Hide(); args.Handled = true; }; var asyncOperation = base.ShowAsync(); asyncOperation.AsTask().ContinueWith(task => tcs.TrySetResult(task.Result)); return(tcs.Task.AsAsyncOperation()); }
public static System.Threading.Tasks.Task <System.Net.WebResponse> GetResponseAsync(this System.Net.WebRequest wr) { var tcs = new System.Threading.Tasks.TaskCompletionSource <System.Net.WebResponse>(); wr.BeginGetResponse((result) => { var source = (System.Net.WebRequest)result.AsyncState; tcs.TrySetResult(source.EndGetResponse(result)); }, wr); return(tcs.Task); }
public static void WaitForState <TActor, TState, TTrigger>(this IStatefulActor <TActor, TState, TTrigger> actor, TState desired, int timeout) where TState : struct { var completionSource = new System.Threading.Tasks.TaskCompletionSource <bool>(); void waitForUnstarted(TState oldState, StateMachine <TState, TTrigger> .Transition transition) { if (actor.InState(desired)) { completionSource.TrySetResult(true); } }; actor.StateChanged += waitForUnstarted; // Check for synchronous completion if (actor.InState(desired)) { completionSource.TrySetResult(true); } completionSource.Task.Wait(timeout); actor.StateChanged -= waitForUnstarted; }
public static System.Threading.Tasks.Task <System.IO.Stream> GetRequestStreamAsync(this System.Net.WebRequest wr) { if (wr.ContentLength < 0) { throw new InvalidOperationException("The ContentLength property of the WebRequest must first be set to the length of the content to be written to the stream."); } var tcs = new System.Threading.Tasks.TaskCompletionSource <System.IO.Stream>(); wr.BeginGetRequestStream((result) => { var source = (System.Net.WebRequest)result.AsyncState; tcs.TrySetResult(source.EndGetRequestStream(result)); }, wr); return(tcs.Task); }
/// <summary> /// Get a metadata item with a key. The key can't be null or an empty string. /// </summary> /// <param name="key">The key to use to reference the metadata item.</param> /// <returns>A Task<MetadataItem>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <MetadataItem> GetAsync(string key) { var tcs = new System.Threading.Tasks.TaskCompletionSource <MetadataItem>(); this.GetInternal(key, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Record runtime crash information for this app. This could be exceptions, errors or your own custom crash information. /// </summary> /// <param name="methodName">The method name or location where the error happend. This could also be a descriptive string of the error.</param> /// <param name="osVersion">The OS version of the device runnign this code. On some .NET platforms you can use System.Environment.OSVersion to get this information.</param> /// <param name="deviceType">The type of device running this app. On Windows Phone 7 for example you can use DeviceExtendedProperties to retrieve this information.</param> /// <param name="user">The user that's registering this device information.</param> /// <param name="stackTrace">The optional stack trace of where the error happened.</param> /// <param name="appVersion">The optional version of this application.</param> /// <param name="latitude">The optional latitude where this report was submitted.</param> /// <param name="longitude">The optional longiture where this report was submitted.</param> /// <param name="metadata">An optional application specific metadata string to include with the report.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <Boolean> RecordCrashAsync(string methodName, string osVersion, string deviceType, Buddy.AuthenticatedUser user, string stackTrace = "", string appVersion = "1.0", double latitude = 0, double longitude = 0, string metadata = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource <Boolean>(); RecordCrashInternal(methodName, osVersion, deviceType, user, stackTrace, appVersion, latitude, longitude, metadata, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Get a paged list of registered devices for this Application. This list can then be used to iterate over the devices and send each user a push notification. /// </summary> /// <param name="forGroup">Optionally filter only devices in a certain group.</param> /// <param name="pageSize">Set the number of devices that will be returned for each call of this method.</param> /// <param name="currentPage">Set the current page.</param> /// <returns>A Task<IEnumerable<RegisteredDevice> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <IEnumerable <RegisteredDevice> > GetRegisteredDevicesAsync(string forGroup = "", int pageSize = 10, int currentPage = 1) { var tcs = new System.Threading.Tasks.TaskCompletionSource <IEnumerable <RegisteredDevice> >(); GetRegisteredDevicesInternal(forGroup, pageSize, currentPage, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Get a photo album by its name. Note that there can be more than one album with the same name. This method will only return the first one. /// Call PhotoAlbums.All to get all the albums. /// </summary> /// <param name="albumName">The name of the albul to retrieve. Can't be null or empty.</param> /// <returns>A Task<PhotoAlbum>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <PhotoAlbum> GetAsync(string albumName) { var tcs = new System.Threading.Tasks.TaskCompletionSource <PhotoAlbum>(); GetInternal(albumName, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Return all photo albums for this user. Note that this can be an expensive operation since all the Picture data is retrieved as well. /// </summary> /// <param name="afterDate">Optionally return all albums created after a date.</param> /// <returns>A Task<IEnumerable<PhotoAlbum> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <IEnumerable <PhotoAlbum> > GetAllAsync(System.DateTime afterDate = default(DateTime)) { var tcs = new System.Threading.Tasks.TaskCompletionSource <IEnumerable <PhotoAlbum> >(); GetAllInternal(afterDate, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Add a new picture to this album. Note that this method internally does two web-service calls, and the IAsyncResult object /// returned is only valid for the first one. /// </summary> /// <param name="photoStream">A stream containing the photo's contents..</param> /// <param name="comment">An optional comment for this picture.</param> /// <param name="latitude">An optional latitude for the picture.</param> /// <param name="longitude">An optional longitude for the picture.</param> /// <param name="appTag">An optional application tag.</param> /// <param name="watermarkmessage">An optional message to watermark the image with.</param> /// <returns>A Task<Picture>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <Picture> AddPictureWithWatermarkAsync(Stream photoStream, string comment = "", double latitude = 0, double longitude = 0, string appTag = "", string watermarkmessage = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource <Picture>(); AddPictureWithWatermarkInternal(photoStream, comment, latitude, longitude, appTag, watermarkmessage, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// This method is used create a new album. The album will be owned by this user. Multiple albums can be created with the same name. Note that this method internally does two web-service calls, and the IAsyncResult object /// returned is only valid for the first one. /// </summary> /// <param name="name">The name of the new album.</param> /// <param name="isPublic">Make the album publicly visible to other users.</param> /// <param name="appTag">Optionally add a custom application tag for this user.</param> /// <returns>A Task<PhotoAlbum>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <PhotoAlbum> CreateAsync(string name, bool isPublic = false, string appTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource <PhotoAlbum>(); CreateInternal(name, isPublic, appTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Set a metadata item value for a key. You can additional add latitude and longitude coordinate to record the location /// from where this item was set, or tag the item with a custom tag. /// The item doesn't have to exist to be set, this method acts as an Add method in cases where the item doesn't exist. /// </summary> /// <param name="key">The key of the metadata item, can't be null or empty.</param> /// <param name="value">The value of the metadata item, can't be null.</param> /// <param name="latitude">The optional latitude of the metadata item.</param> /// <param name="longitude">The optional longitude of the metadata item.</param> /// <param name="appTag">The optional application tag for this item.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <Boolean> SetAsync(string key, string value, double latitude = 0, double longitude = 0, string appTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource <Boolean>(); this.SetInternal(key, value, latitude, longitude, appTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Delete this photo album. /// </summary> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <Boolean> DeleteAsync() { var tcs = new System.Threading.Tasks.TaskCompletionSource <Boolean>(); DeleteInternal((bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Send a image tile to a windows phone device. The tile is represented by a image URL, you can take a look at the Windows phone docs for image dimensions and formats. /// </summary> /// <param name="imageUri">The URL of the tile image.</param> /// <param name="senderUserId">The ID of the user that sent the notification.</param> /// <param name="messageCount">The message count for this tile.</param> /// <param name="messageTitle">The message title for the tile.</param> /// <param name="deliverAfter">Schedule the message to be delivered after a certain date.</param> /// <param name="groupName">Send messages to an entire group of users, not just a one.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <Boolean> SendTileAsync(string imageUri, int senderUserId, int messageCount = -1, string messageTitle = "", System.DateTime deliverAfter = default(DateTime), string groupName = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource <Boolean>(); SendTileInternal(imageUri, senderUserId, messageCount, messageTitle, deliverAfter, groupName, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Gets a list of profile photos for this user. /// </summary> /// <returns>A Task<IEnumerable<PicturePublic> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <IEnumerable <PicturePublic> > GetProfilePhotosAsync() { var tcs = new System.Threading.Tasks.TaskCompletionSource <IEnumerable <PicturePublic> >(); GetProfilePhotosInternal((bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Get all the metadata items for this application. Note that this can be a very expensive method, try to retrieve specific items if possible /// or do a search. /// </summary> /// <returns>A Task<IDictionary<String,MetadataItem> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <IDictionary <String, MetadataItem> > GetAllAsync() { var tcs = new System.Threading.Tasks.TaskCompletionSource <IDictionary <String, MetadataItem> >(); this.GetAllInternal((bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// This method returns the sum of a set of metadata items that correspond to a certain key wildcard. Note that the values of these items /// need to be numbers or floats, otherwise this method will fail. /// Unlike the 'Sum' method this method can take a list of keys separated by semicolons and will return a list of sums for all of those keys. /// </summary> /// <param name="forKeys">The key to use to filter the items that need to be summed. Is always treated as a wildcard.</param> /// <param name="withinDistance">Optionally sum only items within a certain number of meters from lat/long.</param> /// <param name="latitude">Optionally provide a latitude where the search can be started from.</param> /// <param name="longitude">Optionally provide a longitude where the search can be started from.</param> /// <param name="updatedMinutesAgo">Optionally sum only on items that have been update a number of minutes ago.</param> /// <param name="withAppTag">Optionally sum only items that have a certain application tag.</param> /// <returns>A Task<IEnumerable<MetadataSum> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <IEnumerable <MetadataSum> > BatchSumAsync(string forKeys, string withinDistance = "-1", double latitude = -1, double longitude = -1, int updatedMinutesAgo = -1, string withAppTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource <IEnumerable <MetadataSum> >(); this.BatchSumInternal(forKeys, withinDistance, latitude, longitude, updatedMinutesAgo, withAppTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Begins to show the MetroWindow's overlay effect. /// </summary> /// <returns>A task representing the process.</returns> public System.Threading.Tasks.Task ShowOverlayAsync() { if (overlayBox == null) { throw new InvalidOperationException("OverlayBox can not be founded in this MetroWindow's template. Are you calling this before the window has loaded?"); } var tcs = new System.Threading.Tasks.TaskCompletionSource <object>(); if (IsOverlayVisible() && overlayStoryboard == null) { //No Task.FromResult in .NET 4. tcs.SetResult(null); return(tcs.Task); } Dispatcher.VerifyAccess(); overlayBox.Visibility = Visibility.Visible; var sb = (Storyboard)this.Template.Resources["OverlayFastSemiFadeIn"]; sb = sb.Clone(); EventHandler completionHandler = null; completionHandler = (sender, args) => { sb.Completed -= completionHandler; if (overlayStoryboard == sb) { overlayStoryboard = null; } tcs.TrySetResult(null); }; sb.Completed += completionHandler; overlayBox.BeginStoryboard(sb); overlayStoryboard = sb; return(tcs.Task); }
/// <summary> /// Search for metadata items in this application. Note that this method will only find app-level metadata items. /// </summary> /// <param name="searchDistanceMeters">The distance in meters from the latitude and longitude to search in. To ignore this distance pass in 40075000 (the circumferance of the earth).</param> /// <param name="latitude">The latitude from where the saerch will start.</param> /// <param name="longitude">The longitude from where the saerch will start.</param> /// <param name="numberOfResults">Optionally limit the number of returned metadata items.</param> /// <param name="withKey">Optionally search for items with a specific key. The value of this parameter is treated as a wildcard.</param> /// <param name="withValue">Optionally search for items with a specific value. The value of this parameter is treated as a wildcard.</param> /// <param name="updatedMinutesAgo">Optionally return only items that were updated some minutes ago.</param> /// <param name="valueMin">Optionally search for metadata item values that are bigger than this number.</param> /// <param name="valueMax">Optionally search for metadata item values that are smaller than this number.</param> /// <param name="searchAsFloat">Optionally treat all metadata values as floats. Useful for min/max searches.</param> /// <param name="sortAscending">Optionally sort the results ascending.</param> /// <param name="disableCache">Optionally disable cache searches.</param> /// <returns>A Task<IDictionary<String,MetadataItem> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <IDictionary <String, MetadataItem> > FindAsync(int searchDistanceMeters, double latitude, double longitude, int numberOfResults = 10, string withKey = "", string withValue = "", int updatedMinutesAgo = -1, double valueMin = 0, double valueMax = 100, bool searchAsFloat = false, bool sortAscending = false, bool disableCache = false) { var tcs = new System.Threading.Tasks.TaskCompletionSource <IDictionary <String, MetadataItem> >(); this.FindInternal(searchDistanceMeters, latitude, longitude, numberOfResults, withKey, withValue, updatedMinutesAgo, valueMin, valueMax, searchAsFloat, sortAscending, disableCache, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Send toast message to a windows phone device. If the app is active the user will recieve this message in the toast message callback. Otherwise the message /// appears as a notification on top of the screen. Clicking it will launch the app. /// </summary> /// <param name="toastTitle">The title of the toast message/</param> /// <param name="toastSubtitle">The subtitle of the toast message.</param> /// <param name="toastParameter">An optional parameter for the toast message.</param> /// <param name="senderUserId">The ID of the user that sent the notification.</param> /// <param name="deliverAfter">Schedule the message to be delivered after a certain date.</param> /// <param name="groupName">Send messages to an entire group of users, not just a one.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <Boolean> SendToastMessageAsync(string toastTitle, string toastSubtitle, int senderUserId, string toastParameter = "", System.DateTime deliverAfter = default(DateTime), string groupName = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource <Boolean>(); SendToastMessageInternal(toastTitle, toastSubtitle, senderUserId, toastParameter, deliverAfter, groupName, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
public async override System.Threading.Tasks.Task OnEntry() { // log UnityEngine.Debug.Log( "<color=Blue>Info: </color> ApollonAgencyAndThresholdPerceptionPhase0.OnEntry() : begin" ); // if active condition if (this.FSM.CurrentSettings.bIsActive) { // synchronisation mechanism (TCS + local function) var sync_point = new System.Threading.Tasks.TaskCompletionSource <bool>(); void sync_local_function(object sender, gameplay.control.ApollonAgencyAndThresholdPerceptionControlDispatcher.EventArgs e) => sync_point?.TrySetResult(true); // register our synchronisation function ( gameplay.ApollonGameplayManager.Instance.getBridge( gameplay.ApollonGameplayManager.GameplayIDType.AgencyAndThresholdPerceptionControl ) as gameplay.control.ApollonAgencyAndThresholdPerceptionControlBridge ).Dispatcher.UserNeutralCommandTriggeredEvent += sync_local_function; // show grey cross & frame frontend.ApollonFrontendManager.Instance.setActive(frontend.ApollonFrontendManager.FrontendIDType.GreyFrameGUI); frontend.ApollonFrontendManager.Instance.setActive(frontend.ApollonFrontendManager.FrontendIDType.GreyCrossGUI); // wait synchronisation point indefinitely & reset it once hit await sync_point.Task; // hide grey cross & frame frontend.ApollonFrontendManager.Instance.setInactive(frontend.ApollonFrontendManager.FrontendIDType.GreyCrossGUI); frontend.ApollonFrontendManager.Instance.setInactive(frontend.ApollonFrontendManager.FrontendIDType.GreyFrameGUI); // unregister our synchronisation function ( gameplay.ApollonGameplayManager.Instance.getBridge( gameplay.ApollonGameplayManager.GameplayIDType.AgencyAndThresholdPerceptionControl ) as gameplay.control.ApollonAgencyAndThresholdPerceptionControlBridge ).Dispatcher.UserNeutralCommandTriggeredEvent -= sync_local_function; } /* if() */ // log UnityEngine.Debug.Log( "<color=Blue>Info: </color> ApollonAgencyAndThresholdPerceptionPhase0.OnEntry() : end" ); } /* OnEntry() */
/// <summary> /// Gets a list of lowest scores for a specific game board. /// </summary> /// <param name="boardName">The board name can be a specific string or a 'LIKE' pattern using %.</param> /// <param name="recordLimit">The maximum number of scores to return.</param> /// <returns>A Task<IEnumerable<GameScore> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <IEnumerable <GameScore> > GetLowScoresAsync(string boardName, int recordLimit = 100) { var tcs = new System.Threading.Tasks.TaskCompletionSource <IEnumerable <GameScore> >(); GetLowScoresInternal(boardName, recordLimit, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Search for game scores based on a number of different parameters. /// </summary> /// <param name="user">Optionally limit the search to a spcific user.</param> /// <param name="distanceInMeters">Optionally specify a distance from a lat/long to search on. By default this is ignored.</param> /// <param name="latitude">Optional latitude where we can start the search.</param> /// <param name="longitude">Optional longitude where we can start the search.</param> /// <param name="recordLimit">Optionally limit the number of records returned by this search.</param> /// <param name="boardName">Optionally filter on a specific board name.</param> /// <param name="daysOld">Optionally only return scores that are X number of days old.</param> /// <param name="minimumScore">Optionally only return scores that are above a certain minimum score.</param> /// <param name="appTag">Optionally return only scores that have a certain app tag.</param> /// <returns>A Task<IEnumerable<GameScore> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task <IEnumerable <GameScore> > FindScoresAsync(Buddy.User user = null, int distanceInMeters = -1, double latitude = 0, double longitude = 0, int recordLimit = 100, string boardName = "", int daysOld = 999999, double minimumScore = -1, string appTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource <IEnumerable <GameScore> >(); this.FindScoresInternal(user, distanceInMeters, latitude, longitude, recordLimit, boardName, daysOld, minimumScore, appTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return(tcs.Task); }
/// <summary> /// Record runtime crash information for this app. This could be exceptions, errors or your own custom crash information. /// </summary> /// <param name="methodName">The method name or location where the error happend. This could also be a descriptive string of the error.</param> /// <param name="osVersion">The OS version of the device runnign this code. On some .NET platforms you can use System.Environment.OSVersion to get this information.</param> /// <param name="deviceType">The type of device running this app. On Windows Phone 7 for example you can use DeviceExtendedProperties to retrieve this information.</param> /// <param name="user">The user that's registering this device information.</param> /// <param name="stackTrace">The optional stack trace of where the error happened.</param> /// <param name="appVersion">The optional version of this application.</param> /// <param name="latitude">The optional latitude where this report was submitted.</param> /// <param name="longitude">The optional longiture where this report was submitted.</param> /// <param name="metadata">An optional application specific metadata string to include with the report.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> RecordCrashAsync( string methodName, string osVersion, string deviceType, Buddy.AuthenticatedUser user, string stackTrace = "", string appVersion = "1.0", double latitude = 0, double longitude = 0, string metadata = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); RecordCrashInternal(methodName, osVersion, deviceType, user, stackTrace, appVersion, latitude, longitude, metadata, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Get all the player info for this user. /// </summary> /// <returns>A Task<GamePlayer>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<GamePlayer> GetInfoAsync() { var tcs = new System.Threading.Tasks.TaskCompletionSource<GamePlayer>(); this.GetInfoInternal((bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Search for metadata items in this user. Note that this method will only find user-level metadata items. /// </summary> /// <param name="searchDistanceMeters">The distance in meters from the latitude and longitude to search in. To ignore this distance pass in 40075000 (the circumferance of the earth).</param> /// <param name="latitude">The latitude from where the saerch will start.</param> /// <param name="longitude">The longitude from where the saerch will start.</param> /// <param name="numberOfResults">Optionally limit the number of returned metadata items.</param> /// <param name="withKey">Optionally search for items with a specific key. The value of this parameter is treated as a wildcard.</param> /// <param name="withValue">Optionally search for items with a specific value. The value of this parameter is treated as a wildcard.</param> /// <param name="updatedMinutesAgo">Optionally return only items that were updated some minutes ago.</param> /// <param name="searchAsFloat">Optionally treat all metadata values as floats. Useful for min/max searches.</param> /// <param name="sortAscending">Optionally sort the results ascending.</param> /// <param name="disableCache">Optionally disable cache searches.</param> /// <returns>A Task<IDictionary<String,MetadataItem> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<IDictionary<String, MetadataItem>> FindAsync( int searchDistanceMeters, double latitude, double longitude, int numberOfResults = 10, string withKey = "", string withValue = "", int updatedMinutesAgo = -1, bool searchAsFloat = false, bool sortAscending = false, bool disableCache = false) { var tcs = new System.Threading.Tasks.TaskCompletionSource<IDictionary<String, MetadataItem>>(); this.FindInternal(searchDistanceMeters, latitude, longitude, numberOfResults, withKey, withValue, updatedMinutesAgo, searchAsFloat, sortAscending, disableCache, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// /// </summary> /// <returns></returns> private System.Threading.Tasks.Task<bool> DownloadNewImageTest() { var taskComplete = new System.Threading.Tasks.TaskCompletionSource<bool>(); List<Image> allImages = StorageHelper.GetImagesAux(); if (allImages.Count == 0) { taskComplete.TrySetResult(false); return taskComplete.Task; } Image pendingImage = allImages .Where(i => String.IsNullOrEmpty(i.UrlLocal)) .First<Image>(); string[] tokens = pendingImage.URL.Split('.'); string extension = tokens[tokens.Length - 1]; string[] fileName = tokens[tokens.Length - 2].Split('/'); string file = fileName[fileName.Length - 1]; // Si no es jpg o png no se descargará nada if (!extension.Equals("jpg") && !extension.Equals("png")) { allImages.Remove(pendingImage); StorageHelper.SaveImagesAux(allImages); taskComplete.TrySetResult(false); return taskComplete.Task; } Uri remote = new Uri(pendingImage.URL, UriKind.Absolute); Uri local = new Uri(String.Format("Shared/ShellContent/{0}.{1}", file, extension), UriKind.Relative); WebRequest request = HttpWebRequest.Create(remote.ToString()); request.Method = "GET"; request.BeginGetResponse((async) => { HttpWebRequest webRequest = (HttpWebRequest)async.AsyncState; var response = webRequest.EndGetResponse(async); using (var stream = response.GetResponseStream()) { using (var isf = IsolatedStorageFile.GetUserStoreForApplication()) { if(isf.FileExists(local.ToString())) { isf.DeleteFile(local.ToString()); } using (var newFileStream = isf.CreateFile(local.ToString())) { stream.CopyTo(newFileStream); } } } allImages.Remove(pendingImage); StorageHelper.SaveImagesAux(allImages); pendingImage.UrlLocal = local.ToString(); var downloadedImages = StorageHelper.GetImages(); if (downloadedImages.Count == 9) { var imageToDelete = downloadedImages.First(); downloadedImages.Remove(imageToDelete); } downloadedImages.Add(pendingImage); StorageHelper.SaveImages(downloadedImages); taskComplete.TrySetResult(true); },request); return taskComplete.Task; }
/// <summary> /// Get a paged list of registered devices for this Application. This list can then be used to iterate over the devices and send each user a push notification. /// </summary> /// <param name="forGroup">Optionally filter only devices in a certain group.</param> /// <param name="pageSize">Set the number of devices that will be returned for each call of this method.</param> /// <param name="currentPage">Set the current page.</param> /// <returns>A Task<IEnumerable<RegisteredDevice> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<IEnumerable<RegisteredDevice>> GetRegisteredDevicesAsync(string forGroup = "", int pageSize = 10, int currentPage = 1) { var tcs = new System.Threading.Tasks.TaskCompletionSource<IEnumerable<RegisteredDevice>>(); GetRegisteredDevicesInternal(forGroup, pageSize, currentPage, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Register a Windows device for notificatons with Buddy. The URL is the notifications channel link that provided by the platform. Most of the time /// you don't need to call this API directly, you can use ConfigurePushAsync instead which will configure everyting for you. Note that if you call this method, /// you are responsible to configure the device for push notifications. /// </summary> /// <param name="deviceUri">The device notification channel URI.</param> /// <param name="enableTile">Optionally enable tile notifications</param> /// <param name="enableRaw">Optionally enable raw notifications.</param> /// <param name="enableToast">Optionally enable toast notifications.</param> /// <param name="groupName">Register this device as part of a group, so that you can send the whole group messages.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> RegisterDeviceAsync(string deviceUri, bool enableTile = true, bool enableRaw = true, bool enableToast = true, string groupName = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); RegisterDeviceInternal(deviceUri, enableTile, enableRaw, enableToast, groupName, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Returns a list of supported filters that can be applied to this picture. Example filters are: Hue Shift, Crop, etc. /// </summary> /// <returns>A Task<IDictionary<String,String> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<IDictionary<String, String>> SupportedFiltersAsync() { var tcs = new System.Threading.Tasks.TaskCompletionSource<IDictionary<String, String>>(); SupportedFiltersInternal((bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Get a metadata item with a key. The key can't be null or an empty string. /// </summary> /// <param name="key">The key to use to reference the metadata item.</param><exception cref="T:System.ArgumentException">When key is null or empty.</exception> /// <returns>A Task<MetadataItem>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<MetadataItem> GetAsync( string key) { var tcs = new System.Threading.Tasks.TaskCompletionSource<MetadataItem>(); this.GetInternal(key, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Gets a list of profile photos for this user. /// </summary> /// <returns>A Task<IEnumerable<PicturePublic> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<IEnumerable<PicturePublic>> GetProfilePhotosAsync() { var tcs = new System.Threading.Tasks.TaskCompletionSource<IEnumerable<PicturePublic>>(); GetProfilePhotosInternal((bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Searches for Player objects stored in the Buddy system. Searches can optionally be performed based on location. /// </summary> /// <param name="searchDistanceInMeters">The radius (in meters) around the specified location in which to look for locations. Pass in -1 to ignore this field. </param> /// <param name="latitude">The latitude of the location around which to search for locations within the specified SearchDistance. </param> /// <param name="longitude">The longitude of the location around which to search for locations within the specified SearchDistance. </param> /// <param name="recordLimit">The maximum number of search results to return or -1 to return all search results. </param> /// <param name="boardName">Searches for scores which contain the specified board. Leave empty or pass in null if no board filter is to be used. </param> /// <param name="onlyForLastNumberOfDays">The number of days into the past for which to look for scores. ie: passing in 5 will filter scores to include those which were added/updated on or after 5 days ago. Pass in -1 to ignore this filter. </param> /// <param name="minimumScore">The minimum score value to search for. Pass in -1 to ignore this filter. </param> /// <param name="appTag">Searches for scores with the specified ApplicationTag stored with them. Leave empty or pass in null to ignore this filter. </param> /// <param name="rank">Optionally search for a player rank.</param> /// <returns>A Task<IEnumerable<GamePlayer> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<IEnumerable<GamePlayer>> FindAsync( int searchDistanceInMeters = -1, double latitude = 0, double longitude = 0, int recordLimit = 100, string boardName = "", int onlyForLastNumberOfDays = -1, int minimumScore = -1, string appTag = "", string rank = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<IEnumerable<GamePlayer>>(); this.FindInternal(searchDistanceInMeters, latitude, longitude, recordLimit, boardName, onlyForLastNumberOfDays, minimumScore, appTag, rank, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Get all the metadata items for this user. Note that this can be a very expensive method, try to retrieve specific items if possible /// or do a search. /// </summary> /// <returns>A Task<IDictionary<String,MetadataItem> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<IDictionary<String, MetadataItem>> GetAllAsync() { var tcs = new System.Threading.Tasks.TaskCompletionSource<IDictionary<String, MetadataItem>>(); this.GetAllInternal((bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Configure this Windows Phone device for push notifications /// </summary> /// <param name="channelName"></param> /// <param name="enableTiles"></param> /// <param name="enableToastMessages"></param> /// <param name="groupName"></param> /// <param name="allowedDomains"></param> /// <param name="rawMessageCallback"></param> /// <param name="toastMessageCallback"></param> public System.Threading.Tasks.Task<Boolean> ConfigurePushAsync(bool enableTiles, bool enableToastMessages, string groupName = "", List<string> allowedDomains = null, Action<string> rawMessageCallback = null, Action<IDictionary<string, string>> toastMessageCallback = null, string channelName = null) { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); Action<bool, Exception> finish = (result, ex) => { if (ex != null) { tcs.TrySetException(ex); } else { tcs.TrySetResult(result); } }; if (allowedDomains == null) allowedDomains = new List<string>(); allowedDomains.Add("http://buddyplatform.s3.amazonaws.com/"); channelName = this.GetChannelName(channelName); HttpNotificationChannel channel = null; bool done = false; if ((channel = HttpNotificationChannel.Find(channelName)) == null) { channel = new HttpNotificationChannel(channelName, "www.buddy.com"); if (channel == null) { Deployment.Current.Dispatcher.BeginInvoke(() => { finish(false, new Exception("Couldn't create HttpNotificationChannel.")); }); done = true; } else { channel.Open(); } } if (!done && rawMessageCallback != null) channel.HttpNotificationReceived += (s, ev) => { StreamReader reader = new StreamReader(ev.Notification.Body); Deployment.Current.Dispatcher.BeginInvoke(() => { rawMessageCallback(reader.ReadToEnd()); }); }; if (!done && toastMessageCallback != null) channel.ShellToastNotificationReceived += (s, ev) => { Deployment.Current.Dispatcher.BeginInvoke(() => { toastMessageCallback(ev.Collection); }); }; Action<HttpNotificationChannel> registerUri = (newChannel) => { if (enableTiles) { BindTile(newChannel, allowedDomains); } if (enableToastMessages) { BindToast(newChannel); } this.RegisterDeviceInternal(newChannel.ChannelUri.ToString(), enableTiles, rawMessageCallback != null, enableToastMessages, groupName, (bcr) => { finish(bcr.Result, bcr.Error == BuddyError.None ? null : new BuddyServiceException(bcr.Error.ToString())); }); }; if (!done) { channel.ChannelUriUpdated += (s, ev) => { registerUri(channel); }; if (channel.ChannelUri != null) { registerUri(channel); } } return tcs.Task; }
/// <summary> /// Set metadata item values for keys. You can additionally add a latitude and longitude coordinate to record the location /// from where these items were set, or tag all items with a custom tag. /// The item doesn't have to exist to be set, this method acts as an Add method in cases where the item doesn't exist. /// </summary> /// <param name="keys">The keys of the metadata items, can't be null or empty.</param> /// <param name="values">The values of the metadata items, can't be null or empty.</param> /// <param name="latitude">The optional latitude of the metadata items.</param> /// <param name="longitude">The optional longitude of the metadata items.</param> /// <param name="appTag">The optional application tag for these items.</param><exception cref="T:System.ArgumentException">When any key is null or empty.</exception><exception cref="T:System.ArgumentNullException">When any value is or empty.</exception> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> BatchSetAsync( string keys, string values, double latitude = 0, double longitude = 0, string appTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); this.BatchSetInternal(keys, values, latitude, longitude, appTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Delete this photo album. /// </summary> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> DeleteAsync() { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); DeleteInternal((bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// This method returns the sum of a set of metadata items that correspond to a certain key wildcard. Note that the values of these items /// need to be numbers or floats, otherwise this method will fail. /// Unlike the 'Sum' method this method can take a list of keys separated by semicolons and will return a list of sums for all of those keys. /// </summary> /// <param name="forKeys">The key to use to filter the items that need to be summed. Is always treated as a wildcard.</param> /// <param name="withinDistance">Optionally sum only items within a certain number of meters from lat/long.</param> /// <param name="latitude">Optionally provide a latitude where the search can be started from.</param> /// <param name="longitude">Optionally provide a longitude where the search can be started from.</param> /// <param name="updatedMinutesAgo">Optionally sum only on items that have been update a number of minutes ago.</param> /// <param name="withAppTag">Optionally sum only items that have a certain application tag.</param> /// <returns>A Task<IEnumerable<MetadataSum> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<IEnumerable<MetadataSum>> BatchSumAsync( string forKeys, string withinDistance = "-1", double latitude = -1, double longitude = -1, int updatedMinutesAgo = -1, string withAppTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<IEnumerable<MetadataSum>>(); this.BatchSumInternal(forKeys, withinDistance, latitude, longitude, updatedMinutesAgo, withAppTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Find the public profile of a user from their unique User ID. This method can be used to find any user associated with this Application. /// </summary> /// <param name="id">The ID of the user, must be bigger than 0.</param><exception cref="T:Buddy.BuddyServiceException">With value: InvalidUserId, when the user ID doesn't exist in the system.</exception> /// <returns>A Task<User>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<User> FindUserAsync(int id) { var tcs = new System.Threading.Tasks.TaskCompletionSource<User>(); FindUserInternal(id, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Search for public albums from other users. /// </summary> /// <param name="searchDistanceInMeters">Optionally search only within a certain distance from the supplied lat/long.</param> /// <param name="latitude">Optionally search for photos added near a latitude.</param> /// <param name="longitude">Optionally search for photos added near a longitude.</param> /// <param name="limitResults">Optionally limit the number of returned photos. Note that this parameter limits the photos returned, not albums. It's possible /// that a partial album is returned.</param> /// <returns>A Task<IEnumerable<PhotoAlbumPublic> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<IEnumerable<PhotoAlbumPublic>> SearchForAlbumsAsync(int searchDistanceInMeters = 99999999, double latitude = 0, double longitude = 0, int limitResults = 50) { var tcs = new System.Threading.Tasks.TaskCompletionSource<IEnumerable<PhotoAlbumPublic>>(); SearchForAlbumsInternal(searchDistanceInMeters, latitude, longitude, limitResults, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Updates one or more fields of an existing Player object which was previously created. /// </summary> /// <param name="name">The name of the new player.</param> /// <param name="board">An optional name of a "Board" for the game. Used for grouping scores together either by user group, levels, or some other method relevant to the game. Although optional, a value is recommended such as "Default" for use in later searches of scores. If no board is to be stored, then pass in null or leave empty.</param> /// <param name="rank">An optional ranking to associate with the score. Can be any string ie: descriptions of achievements, ranking strings like "excellent", etc. Pass in null or an empty string if you do not wish to store a rank</param> /// <param name="latitude">The latitude of the location where the Player object is being updated.</param> /// <param name="longitude">The longitude of the location where the Player object is being updated. </param> /// <param name="appTag">Optional metadata to store with the Player object. ie: a list of players, game state, etc. Leave empty or set to null if there is no data to store with the score.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> UpdateAsync( string name, string board = "", string rank = "", double latitude = 0, double longitude = 0, string appTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); this.UpdateInternal(name, board, rank, latitude, longitude, appTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Add a new picture to this album. Note that this method internally does two web-service calls, and the IAsyncResult object /// returned is only valid for the first one. /// </summary> /// <param name="photoStream">A stream containing the photo's contents..</param> /// <param name="comment">An optional comment for this picture.</param> /// <param name="latitude">An optional latitude for the picture.</param> /// <param name="longitude">An optional longitude for the picture.</param> /// <param name="appTag">An optional application tag.</param> /// <param name="watermarkmessage">An optional message to watermark the image with.</param> /// <returns>A Task<Picture>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Picture> AddPictureWithWatermarkAsync(Stream photoStream, string comment = "", double latitude = 0, double longitude = 0, string appTag = "", string watermarkmessage = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Picture>(); AddPictureWithWatermarkInternal(photoStream, comment, latitude, longitude, appTag, watermarkmessage, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Set a new "active" profile photo from the list of profile photos that the user has uploaded. The photo needs to be already uploaded. /// </summary> /// <param name="picture">The photo to set as the "active" profile photo.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> SetProfilePhotoAsync(Buddy.PicturePublic picture) { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); SetProfilePhotoInternal(picture, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Update the profile of this user. /// </summary> /// <param name="name">Optional new name for the user, can't be null or empty.</param> /// <param name="password">Optional new password for the user, can't be null.</param> /// <param name="gender">Optional new gender for the user.</param> /// <param name="age">Optional new age for the user.</param> /// <param name="email">Optional new email for the user.</param> /// <param name="status">Optional new status for the user.</param> /// <param name="fuzzLocation">Optional change in location fuzzing for this user. If location fuzzing is enable, user location will be /// randomized in all searches by other users.</param> /// <param name="celebrityMode">Optional change in celebrity mode for this user. If celebrity mode is enabled the user will be hidden from all searches in the system.</param> /// <param name="appTag">Optional update to the custom application tag for this user.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> UpdateAsync(string name = "", string password = "", Buddy.UserGender gender = UserGender.Any, int age = 0, string email = "", Buddy.UserStatus status = UserStatus.Any, bool fuzzLocation = false, bool celebrityMode = false, string appTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); UpdateInternal(name, password, gender, age, email, status, fuzzLocation, celebrityMode, appTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Retrieve a picture by its unique ID. Any picture that the user owns or is publicly available can be retrieved. /// </summary> /// <param name="pictureId">The id of the picture to retrieve.</param> /// <returns>A Task<Picture>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Picture> GetPictureAsync(int pictureId) { var tcs = new System.Threading.Tasks.TaskCompletionSource<Picture>(); GetPictureInternal(pictureId, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Get a list of user check-in locations. /// </summary> /// <param name="afterDate">Filter the list to return only check-in after a date.</param> /// <returns>A Task<IEnumerable<CheckInLocation> >that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<IEnumerable<CheckInLocation>> GetCheckInsAsync(System.DateTime afterDate = default(DateTime)) { var tcs = new System.Threading.Tasks.TaskCompletionSource<IEnumerable<CheckInLocation>>(); GetCheckInsInternal(afterDate, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
public System.Threading.Tasks.Task<Buddy.User> FindUser(string userNameToFetch) { var tcs = new System.Threading.Tasks.TaskCompletionSource<User>(); this.FindUserInternal(userNameToFetch, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Add a profile photo for this user. /// </summary> /// <param name="photoSteam">An array of bytes that represent the image you are adding.</param> /// <param name="appTag">An optional tag for the photo.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> AddProfilePhotoAsync(Stream photoSteam, string appTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); AddProfilePhotoInternal(photoSteam, appTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Check-in the user at a location. /// </summary> /// <param name="latitude">The latitude of the location.</param> /// <param name="longitude">The longitude of the location.</param> /// <param name="comment">An optional comment for the check-in.</param> /// <param name="appTag">An optional application specific tag for the location.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> CheckInAsync(double latitude, double longitude, string comment = "", string appTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); CheckInInternal(latitude, longitude, comment, appTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
/// <summary> /// Send a image tile to a windows phone device. The tile is represented by a image URL, you can take a look at the Windows phone docs for image dimensions and formats. /// </summary> /// <param name="imageUri">The URL of the tile image.</param> /// <param name="senderUserId">The ID of the user that sent the notification.</param> /// <param name="messageCount">The message count for this tile.</param> /// <param name="messageTitle">The message title for the tile.</param> /// <param name="deliverAfter">Schedule the message to be delivered after a certain date.</param> /// <param name="groupName">Send messages to an entire group of users, not just a one.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> SendTileAsync(string imageUri, int senderUserId, int messageCount = -1, string messageTitle = "", System.DateTime deliverAfter = default(DateTime), string groupName = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); SendTileInternal(imageUri, senderUserId, messageCount, messageTitle, deliverAfter, groupName, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
public System.Threading.Tasks.Task<IEnumerable<User>> FindUserAsync(double latitude = 0, double longitude = 0, uint searchDistance = 2147483647, uint recordLimit = 10, Buddy.UserGender gender = UserGender.Any, uint ageStart = 0, uint ageStop = 200, Buddy.UserStatus status = UserStatus.Any, uint checkinsWithinMinutes = 2147483647, string appTag = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<IEnumerable<User>>(); FindUserInternal(latitude, longitude, searchDistance, recordLimit, gender, ageStart, ageStop, status, checkinsWithinMinutes, appTag, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }
public System.Threading.Tasks.Task<HttpWebHelperAsyncResult> ExecuteTaskAsync(IHttpWebRequest httpWebRequest, Stream requestBody, object state) { var tcs = new System.Threading.Tasks.TaskCompletionSource<HttpWebHelperAsyncResult>(state); try { ExecuteAsync(httpWebRequest, requestBody, ar => { var asyncResult = (HttpWebHelperAsyncResult)ar; if (asyncResult.IsCancelled) tcs.TrySetCanceled(); if (asyncResult.Exception != null) tcs.TrySetException(asyncResult.Exception); else tcs.TrySetResult(asyncResult); }, state); } catch (Exception ex) { tcs.TrySetException(ex); } return tcs.Task; }
/// <summary> /// Send toast message to a windows phone device. If the app is active the user will recieve this message in the toast message callback. Otherwise the message /// appears as a notification on top of the screen. Clicking it will launch the app. /// </summary> /// <param name="toastTitle">The title of the toast message/</param> /// <param name="toastSubtitle">The subtitle of the toast message.</param> /// <param name="toastParameter">An optional parameter for the toast message.</param> /// <param name="senderUserId">The ID of the user that sent the notification.</param> /// <param name="deliverAfter">Schedule the message to be delivered after a certain date.</param> /// <param name="groupName">Send messages to an entire group of users, not just a one.</param> /// <returns>A Task<Boolean>that can be used to monitor progress on this call.</returns> public System.Threading.Tasks.Task<Boolean> SendToastMessageAsync(string toastTitle, string toastSubtitle, int senderUserId, string toastParameter = "", System.DateTime deliverAfter = default(DateTime), string groupName = "") { var tcs = new System.Threading.Tasks.TaskCompletionSource<Boolean>(); SendToastMessageInternal(toastTitle, toastSubtitle, senderUserId, toastParameter, deliverAfter, groupName, (bcr) => { if (bcr.Error != BuddyServiceClient.BuddyError.None) { tcs.TrySetException(new BuddyServiceException(bcr.Error)); } else { tcs.TrySetResult(bcr.Result); } }); return tcs.Task; }