/// <summary>
/// Updates an event in the player's incoming event mailbox.
/// </summary>
/// <remarks>
/// Service Name - Event
/// Service Operation - UpdateEventData
/// </remarks>
/// <param name="in_fromPlayerId">
/// The id of the player who sent the event
/// </param>
/// <param name="in_eventId">
/// The event id
/// </param>
/// <param name="in_jsonEventData">
/// The user-defined data for this event encoded in JSON.
/// </param>
/// <param name="in_success">
/// The success callback.
/// </param>
/// <param name="in_failure">
/// The failure callback.
/// </param>
/// <param name="in_cbObject">
/// The user object sent to the callback.
/// </param>
/// <returns> The JSON returned in the callback is as follows:
/// {
/// "status":200,
/// "data":null
/// }
/// </returns>
public void UpdateIncomingEventData(
string in_fromPlayerId,
ulong in_eventId,
string in_jsonEventData,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.EventServiceUpdateEventDataFromId.Value] = in_fromPlayerId;
data[OperationParam.EventServiceUpdateEventDataEventId.Value] = in_eventId;
if (Util.IsOptionalParameterValid(in_jsonEventData))
{
Dictionary <string, object> eventData = JsonReader.Deserialize <Dictionary <string, object> > (in_jsonEventData);
data[OperationParam.EventServiceUpdateEventDataData.Value] = eventData;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
ServerCall sc = new ServerCall(ServiceName.Event, ServiceOperation.UpdateEventData, data, callback);
m_brainCloudClientRef.SendRequest(sc);
}
/// <summary>
/// Uses the specified item, potentially consuming it.
/// </summary>
/// <remarks>
/// Service Name - UserInventoryManagement
/// Service Operation - UseUserItem
/// </remarks>
/// <param name="itemId">
/// </param>
/// <param name="version">
/// </param>
/// <param name="newItemData">
/// </param>
/// <param name="includeDef">
/// </param>
/// <param name="success">
/// The success callback.
/// </param>
/// <param name="failure">
/// The failure callback.
/// </param>
/// <param name="cbObject">
/// The user object sent to the callback.
/// </param>
public void UseUserItem(
string itemId,
int version,
string newItemData,
bool includeDef,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.UserItemsServiceItemId.Value] = itemId;
data[OperationParam.UserItemsServiceVersion.Value] = version;
data[OperationParam.UserItemsServiceIncludeDef.Value] = includeDef;
var newItemDataDict = JsonReader.Deserialize <Dictionary <string, object> >(newItemData);
data[OperationParam.UserItemsServiceNewItemData.Value] = newItemDataDict;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.UserItems, ServiceOperation.UseUserItem, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Schedules raw notifications based on user local time.
/// </param>
/// <param name="profileId">
/// The profileId of the user to receive the notification
/// </param>
/// <param name="fcmContent">
/// Valid Fcm data content
/// </param>
/// <param name="iosContent">
/// Valid ios data content
/// </param>
/// <param name="facebookContent">
/// Facebook template string
/// </param>
/// <param name="minutesFromNow">
/// Minutes from now to send the push notification
/// </param>
/// <param name="success">
/// The success callback
/// </param>
/// <param name="failure">
/// The failure callback
/// </param>
/// <param name="cbObject">
/// The callback object
/// </param>
public void ScheduleRawPushNotificationMinutes(
string profileId,
string fcmContent,
string iosContent,
string facebookContent,
int minutesFromNow,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.ProfileId.Value] = profileId;
if (Util.IsOptionalParameterValid(fcmContent))
{
data[OperationParam.PushNotificationSendParamFcmContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(fcmContent);
}
if (Util.IsOptionalParameterValid(iosContent))
{
data[OperationParam.PushNotificationSendParamIosContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(iosContent);
}
if (Util.IsOptionalParameterValid(facebookContent))
{
data[OperationParam.PushNotificationSendParamFacebookContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(facebookContent);
}
data[OperationParam.MinutesFromNow.Value] = minutesFromNow;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.PushNotification, ServiceOperation.ScheduleRawNotification, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Post the players score to the given social leaderboard.
/// Pass leaderboard config data to dynamically create if necessary.
/// You can optionally send a user-defined json string of data
/// with the posted score. This string could include information
/// relevant to the posted score.
/// </summary>
/// <remarks>
/// Service Name - SocialLeaderboard
/// Service Operation - PostScoreDynamic
/// </remarks>
/// <param name="in_leaderboardId">
/// The leaderboard to post to
/// </param>
/// <param name="in_score">
/// The score to post
/// </param>
/// <param name="in_data">
/// Optional user-defined data to post with the score
/// </param>
/// <param name="in_leaderboardType">
/// leaderboard type
/// </param>
/// <param name="in_rotationType">
/// Type of rotation
/// </param>
/// <param name="in_rotationReset">
/// Date to reset the leaderboard
/// </param>
/// <param name="in_retainedCount">
/// Hpw many rotations to keep
/// </param>
/// <param name="in_success">
/// The success callback.
/// </param>
/// <param name="in_failure">
/// The failure callback.
/// </param>
/// <param name="in_cbObject">
/// The user object sent to the callback.
/// </param>
/// <returns> The JSON returned in the callback is as follows:
/// {
/// "status":200,
/// "data":{
/// }
/// }
/// </returns>
public void PostScoreToDynamicLeaderboard(
string in_leaderboardId,
long in_score,
string in_jsonData,
SocialLeaderboardType in_leaderboardType,
RotationType in_rotationType,
DateTime?in_rotationReset,
int in_retainedCount,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = in_leaderboardId;
data[OperationParam.SocialLeaderboardServiceScore.Value] = in_score;
if (Util.IsOptionalParameterValid(in_jsonData))
{
Dictionary <string, object> customData = JsonReader.Deserialize <Dictionary <string, object> >(in_jsonData);
data[OperationParam.SocialLeaderboardServiceData.Value] = customData;
}
data[OperationParam.SocialLeaderboardServiceLeaderboardType.Value] = in_leaderboardType.ToString();
data[OperationParam.SocialLeaderboardServiceRotationType.Value] = in_rotationType.ToString();
if (in_rotationReset.HasValue)
{
data[OperationParam.SocialLeaderboardServiceRotationReset.Value] = in_rotationReset.Value.ToString("d-MM-yyyy HH:mm");
}
data[OperationParam.SocialLeaderboardServiceRetainedCount.Value] = in_retainedCount;
ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
ServerCall sc = new ServerCall(ServiceName.SocialLeaderboard, ServiceOperation.PostScoreDynamic, data, callback);
m_brainCloudClientRef.SendRequest(sc);
}
/// <summary>
/// Advanced universalId password reset using templates with expiry
/// </summary>
/// <remarks>
/// Service Name - Authenticate
/// Operation - ResetUniversalIdPasswordAdvanced
/// </remarks>
/// <param name="appId">
/// The app id
/// </param>
/// <param name="universalId">
/// The email address to send the reset email to
/// </param>
/// <param name="serviceParams">
/// The parameters to send the email service. See documentation for full list
/// http://getbraincloud.com/apidocs/apiref/#capi-mail
/// </param>
/// <param name="expiryTimeInMin">
/// takes in an Expiry time to determine how long it will stay available
/// </param>
/// <param name="success">
/// The method to call in event of success
/// </param>
/// <param name="failure">
/// The method to call in the event of an error
/// </param>
/// <param name="cbObject">
/// The user supplied callback object
/// </param>
public void ResetUniversalIdPasswordAdvancedWithExpiry(
string universalId,
string serviceParams,
int tokenTtlInMinutes,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.AuthenticateServiceAuthenticateGameId.Value] = _client.AppId;
data[OperationParam.AuthenticateServiceAuthenticateUniversalId.Value] = universalId;
var jsonParams = JsonReader.Deserialize <Dictionary <string, object> >(serviceParams);
data[OperationParam.AuthenticateServiceAuthenticateServiceParams.Value] = jsonParams;
data[OperationParam.AuthenticateServiceAuthenticateTokenTtlInMinutes.Value] = tokenTtlInMinutes;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure);
ServerCall sc = new ServerCall(ServiceName.Authenticate, ServiceOperation.ResetUniversalIdPasswordAdvancedWithExpiry, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Redeem a code.
/// </summary>
/// <remarks>
/// Service Name - redemptionCode
/// Service Operation - REDEEM_CODE
/// </remarks>
/// <param name="scanCode">
/// The code to redeem
/// </param>
/// <param name="codeType">
/// The type of code
/// </param>
/// <param name="jsonCustomRedemptionInfo">
/// Optional - A JSON string containing custom redemption data
/// </param>
/// <param name="success">
/// The success callback.
/// </param>
/// <param name="failure">
/// The failure callback.
/// </param>
/// <param name="cbObject">
/// The user object sent to the callback.
/// </param>
public void RedeemCode(
string scanCode,
string codeType,
string jsonCustomRedemptionInfo,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.RedemptionCodeServiceScanCode.Value] = scanCode;
data[OperationParam.RedemptionCodeServiceCodeType.Value] = codeType;
if (Util.IsOptionalParameterValid(jsonCustomRedemptionInfo))
{
Dictionary <string, object> customRedemptionInfo = JsonReader.Deserialize <Dictionary <string, object> >(jsonCustomRedemptionInfo);
data[OperationParam.RedemptionCodeServiceCustomRedemptionInfo.Value] = customRedemptionInfo;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.RedemptionCode, ServiceOperation.RedeemCode, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Prepares a user file upload. On success the file will begin uploading
/// to the brainCloud server.To be informed of success/failure of the upload
/// register an IFileUploadCallback with the BrainCloudClient class.
/// </summary>
/// <param name="cloudPath">The desired cloud path of the file</param>
/// <param name="cloudFilename">The desired cloud fileName of the file</param>
/// <param name="shareable">True if the file is shareable</param>
/// <param name="replaceIfExists">Whether to replace file if it exists</param>
/// <param name="localPath">The path and fileName of the local file</param>
/// <param name="success">The success callback</param>
/// <param name="failure">The failure callback</param>
/// <param name="cbObject">The callback object</param>
public bool UploadFile(
string cloudPath,
string cloudFilename,
bool shareable,
bool replaceIfExists,
string localPath,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
#if UNITY_WEBPLAYER || UNITY_WEBGL
throw new Exception("File upload API is not supported on Web builds");
#else
FileInfo info = new FileInfo(localPath);
if (!info.Exists)
{
m_brainCloudClientRef.Log("File at " + localPath + " does not exist");
return(false);
}
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.UploadLocalPath.Value] = localPath;
data[OperationParam.UploadCloudFilename.Value] = cloudFilename;
data[OperationParam.UploadCloudPath.Value] = cloudPath;
data[OperationParam.UploadShareable.Value] = shareable;
data[OperationParam.UploadReplaceIfExists.Value] = replaceIfExists;
data[OperationParam.UploadFileSize.Value] = info.Length;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.File, ServiceOperation.PrepareUserUpload, data, callback);
m_brainCloudClientRef.SendRequest(sc);
return(true);
#endif
}
/// <summary>
/// Sends an event to the designated profile id with the attached json data.
/// Any events that have been sent to a user will show up in their
/// incoming event mailbox. If the recordLocally flag is set to true,
/// a copy of this event (with the exact same event id) will be stored
/// in the sending user's "sent" event mailbox.
/// </summary>
/// <remarks>
/// Service Name - Event
/// Service Operation - Send
/// </remarks>
/// <param name="toProfileId">
/// The id of the user who is being sent the event
/// </param>
/// <param name="eventType">
/// The user-defined type of the event.
/// </param>
/// <param name="jsonEventData">
/// The user-defined data for this event encoded in JSON.
/// </param>
/// <param name="success">
/// The success callback.
/// </param>
/// <param name="failure">
/// The failure callback.
/// </param>
/// <param name="cbObject">
/// The user object sent to the callback.
/// </param>
public void SendEvent(
string toProfileId,
string eventType,
string jsonEventData,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.EventServiceSendToId.Value] = toProfileId;
data[OperationParam.EventServiceSendEventType.Value] = eventType;
if (Util.IsOptionalParameterValid(jsonEventData))
{
Dictionary <string, object> eventData = JsonReader.Deserialize <Dictionary <string, object> > (jsonEventData);
data[OperationParam.EventServiceSendEventData.Value] = eventData;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.Event, ServiceOperation.Send, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Finds matchmaking enabled players using a cloud code filter
/// </summary>
/// <remarks>
/// Service Name - MatchMaking
/// Service Operation - FIND_PLAYERS_USING_FILTER
/// </remarks>
/// <param name="in_rangeDelta">
/// The range delta
/// </param>
/// <param name="in_numMatches">
/// The maximum number of matches to return
/// </param>
/// <param name="in_jsonExtraParms">
/// Other parameters
/// </param>
/// <param name="in_success">
/// The success callback.
/// </param>
/// <param name="in_failure">
/// The failure callback.
/// </param>
/// <param name="in_cbObject">
/// The user object sent to the callback.
/// </param>
/// <returns> The JSON returned in the callback is as follows:
/// {
/// "status": 200,
/// "data": {
/// "matchesFound": [
/// {
/// "pictureUrl": null,
/// "playerName": "UserC-1239941736",
/// "playerId": "c2b88d3f-2s32-43a6-9a71-0f0157e46505",
/// "playerRating": 0,
/// "summaryFriendData": null
/// },
/// {
/// "pictureUrl": null,
/// "playerName": "UserA-914307852",
/// "playerId": "96afefc7-02b2-4148-8d36-c62855d917b6",
/// "playerRating": 0,
/// "summaryFriendData": null
/// }
/// ]
/// }
/// }
/// </returns>
public void FindPlayersUsingFilter(
long in_rangeDelta,
long in_numMatches,
string in_jsonExtraParms,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.MatchMakingServiceRangeDelta.Value] = in_rangeDelta;
data[OperationParam.MatchMakingServiceNumMatches.Value] = in_numMatches;
if (Util.IsOptionalParameterValid(in_jsonExtraParms))
{
Dictionary <string, object> extraParms = JsonReader.Deserialize <Dictionary <string, object> >(in_jsonExtraParms);
data[OperationParam.MatchMakingServiceExtraParams.Value] = extraParms;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
ServerCall sc = new ServerCall(ServiceName.MatchMaking, ServiceOperation.FindPlayersUsingFilter, data, callback);
m_brainCloudClientRef.SendRequest(sc);
}
/// <summary>
/// Post the players score to the given social leaderboard.
/// Pass leaderboard config data to dynamically create if necessary.
/// You can optionally send a user-defined json string of data
/// with the posted score. This string could include information
/// relevant to the posted score.
/// </summary>
/// <remarks>
/// Service Name - leaderboard
/// Service Operation - PostScoreDynamic
/// </remarks>
/// <param name="leaderboardId">
/// The leaderboard to post to
/// </param>
/// <param name="score">
/// The score to post
/// </param>
/// <param name="data">
/// Optional user-defined data to post with the score
/// </param>
/// <param name="leaderboardType">
/// leaderboard type
/// </param>
/// <param name="rotationType">
/// Type of rotation
/// </param>
/// <param name="rotationReset">
/// Date to reset the leaderboard UTC
/// </param>
/// <param name="retainedCount">
/// How many rotations to keep
/// </param>
/// <param name="success">
/// The success callback.
/// </param>
/// <param name="failure">
/// The failure callback.
/// </param>
/// <param name="cbObject">
/// The user object sent to the callback.
/// </param>
public void PostScoreToDynamicLeaderboard(
string leaderboardId,
long score,
string jsonData,
SocialLeaderboardType leaderboardType,
RotationType rotationType,
DateTime?rotationReset,
int retainedCount,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
var data = new Dictionary <string, object>();
data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = leaderboardId;
data[OperationParam.SocialLeaderboardServiceScore.Value] = score;
if (Util.IsOptionalParameterValid(jsonData))
{
var customData = JsonReader.Deserialize <Dictionary <string, object> >(jsonData);
data[OperationParam.SocialLeaderboardServiceData.Value] = customData;
}
data[OperationParam.SocialLeaderboardServiceLeaderboardType.Value] = leaderboardType.ToString();
data[OperationParam.SocialLeaderboardServiceRotationType.Value] = rotationType.ToString();
if (rotationReset.HasValue)
{
data[OperationParam.SocialLeaderboardServiceRotationResetTime.Value] = Util.DateTimeToUnixTimestamp(rotationReset.Value);
}
data[OperationParam.SocialLeaderboardServiceRetainedCount.Value] = retainedCount;
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.PostScoreDynamic, data, callback);
_brainCloudClient.SendRequest(sc);
}
/// <summary>
/// Method updates an existing entity's Acl on the server.
/// </summary>
/// <remarks>
/// Service Name - GlobalEntity
/// Service Operation - UpdateAcl
/// </remarks>
/// <param name="entityId">
/// The entity ID
/// </param>
/// <param name="version">
/// The version of the entity to update
/// </param>
/// <param name="jsonEntityAcl">
/// The entity's access control list as json.
/// </param>
/// <param name="success">
/// The success callback.
/// </param>
/// <param name="failure">
/// The failure callback.
/// </param>
/// <param name="cbObject">
/// The user object sent to the callback.
/// </param>
public void UpdateEntityAcl(
string entityId,
int version,
string jsonEntityAcl,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
var data = new Dictionary <string, object>();
data[OperationParam.GlobalEntityServiceEntityId.Value] = entityId;
data[OperationParam.GlobalEntityServiceVersion.Value] = version;
if (Util.IsOptionalParameterValid(jsonEntityAcl))
{
var acl = JsonReader.Deserialize <Dictionary <string, object> >(jsonEntityAcl);
data[OperationParam.GlobalEntityServiceAcl.Value] = acl;
}
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.UpdateAcl, data, callback);
_client.SendRequest(serverCall);
}
/// <summary>
/// Method updates an existing entity's Acl on the server.
/// </summary>
/// <remarks>
/// Service Name - GlobalEntity
/// Service Operation - UpdateAcl
/// </remarks>
/// <param name="in_entityId">
/// The entity ID
/// </param>
/// <param name="in_version">
/// The version of the entity to update
/// </param>
/// <param name="in_jsonEntityAcl">
/// The entity's access control list as json.
/// </param>
/// <param name="in_success">
/// The success callback.
/// </param>
/// <param name="in_failure">
/// The failure callback.
/// </param>
/// <param name="in_cbObject">
/// The user object sent to the callback.
/// </param>
/// <returns> The JSON returned in the callback is as follows:
/// {
/// "status":200,
/// "data":
/// {
/// gameId : "game",
/// entityId : "hucfshugvgvfhug",
/// ownerId : "ubfcbvfbsdvbb",
/// entityType : "",
/// entityIndexedId : "",
/// version : 1,
/// timeToLive: 0,
/// expiresAt : 9947395735758975,
/// data :
/// {
/// field : "value"
/// },
/// acl :
/// {
/// other, 1
/// },
/// createdAt : 74889479874,
/// updatedAt : 73847474897487
///
/// }
/// }
/// </returns>
public void UpdateEntityAcl(
string in_entityId,
int in_version,
string in_jsonEntityAcl,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.GlobalEntityServiceEntityId.Value] = in_entityId;
data[OperationParam.GlobalEntityServiceVersion.Value] = in_version;
if (Util.IsOptionalParameterValid(in_jsonEntityAcl))
{
Dictionary <string, object> acl = JsonReader.Deserialize <Dictionary <string, object> >(in_jsonEntityAcl);
data[OperationParam.GlobalEntityServiceAcl.Value] = acl;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
ServerCall serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.UpdateAcl, data, callback);
m_brainCloudClientRef.SendRequest(serverCall);
}
private void button2_Click(object sender, EventArgs e)
{
//connect
call = new ServerCall(this, formState.ServerAddress, formState.ServerLogin, formState.ServerPassword, MessageFromServerCall_Async, MessageFromServer);
}
/// <summary>Sends a service request message to the server. </summary>
/// <param name="serviceMessage">The message to send</param>
internal void SendRequest(ServerCall serviceMessage)
{
// pass this directly to the brainCloud Class
// which will add it to its queue and send back responses accordingly
_comms.AddToQueue(serviceMessage);
}
private void UnloadClient(object sender)
{
_server = null; // Unload only removes the reference to the proxy, doesn't do anything else, since the ALCs need to be cleaned up by the users before the GC can collect.
_serverDelegate = null;
}
private IEnumerator uploadGlyph()
{
if (HardwareController.Instance.getLastLocation().Equals(GPSLocation.UNDEFINED))
{
statusPanel.showErrorStatus(CANNOT_ACCESS_LOCATION_ERROR);
yield return(null);
}
else if (LoggedInUser.GetLoggedInUser() == null)
{
statusPanel.showErrorStatus(NO_LOGGED_IN_USER_ERROR);
yield return(null);
}
else
{
statusPanel.showLoadingStatus("Creating Glyph");
double latitude = HardwareController.Instance.getLastLocation().latitude;
double longitude = HardwareController.Instance.getLastLocation().longitude;
double altitude = HardwareController.Instance.getLastLocation().altitude;
ServerCall uploadGlyphCall;
if (!publicToggle.isOn)
{
uploadGlyphCall = new ServerCall(ServerInteract.INSTANCE.AddPrivateGlyph(latitude, longitude, altitude));
}
else
{
uploadGlyphCall = new ServerCall(ServerInteract.INSTANCE.AddPublicGlyph(latitude, longitude, altitude, dateTimePicker.getSelectedDateTime()));
}
yield return(StartCoroutine(uploadGlyphCall.call()));
if (uploadGlyphCall.ReturnException != null)
{
statusPanel.showErrorStatus(uploadGlyphCall.ReturnException.Message);
}
else
{
OwnedGlyphEvent ownedGlyph = (OwnedGlyphEvent)uploadGlyphCall.ObjectResponse;
LoggedInUser.GetLoggedInUser().ownedGlyphs.Add(ownedGlyph);
statusPanel.showLoadingStatus("Uploading Picture");
ServerCall uploadToFirebaseCall = new ServerCall(ServerInteract.INSTANCE.UploadAddGlyphFileToFirebase(ownedGlyph.GetGlyph()));
yield return(StartCoroutine(uploadToFirebaseCall.call()));
if (uploadToFirebaseCall.ReturnException != null)
{
statusPanel.showErrorStatus(uploadToFirebaseCall.ReturnException.Message);
}
else
{
statusPanel.showStatus("Glyph Created!");
ApplicationFileManager.DeleteAddGlyphFile();
yield return(new WaitForSeconds(3));
SceneManager.LoadScene("Scenes/GroundViewScene");
}
}
}
yield return("Done");
}
public async Task OrderStreamConvertsToGrid()
{
//Need to create delay for the first set of orders to come in
var statusEvent = new ManualResetEvent(false);
var isFired = false;
//Listen for orders flowing in as json
connection.ServerJsonReceived += (sender, jsonArgs) =>
{
var args = ServerDataReceivedEventArgs <BlotterOrder> .DeserializeMessage(jsonArgs.RawJson);
var grid = new FastWindowGridModel <BlotterOrder>(10);
grid.LoadRowJson(jsonArgs.RowsJson);
//Make sure data matches
var props = typeof(BlotterOrder).GetProperties();
Assert.AreEqual(props.Length, grid.ColumnCount, "Grid column count should match the number of public properties in BlotterOrders");
for (var r = 0; r < grid.RowCount; r++)
{
for (var c = 0; c < grid.ColumnCount; c++)
{
var cellstr = grid.GetCellText(r, c).ToLower();
var propval = props[c].GetValue(args.Data.ElementAt(r));
if (propval is DateTime)
{
var cellval = DateTimeOffset.Parse(cellstr, CultureInfo.InvariantCulture).DateTime;
Console.WriteLine($"({r},{c}): {propval} = {cellval}: {(DateTime)propval == cellval}");
Assert.AreEqual(propval, cellval);
}
else
{
var propstr = propval?.ToString().ToLower() ?? string.Empty;
Console.WriteLine($"({r},{c}): {propstr} = {cellstr}: {propstr == cellstr}");
Assert.AreEqual(propstr, cellstr);
}
}
}
Console.WriteLine("Property match completed successfully.");
isFired = true;
statusEvent.Set();
};
//Listen for orders flowing in as byte arrays
connection.ServerBytesReceived += (sender, bytesArgs) =>
{
var args = ServerDataReceivedEventArgs <BlotterOrder> .DeserializeMessage(bytesArgs.RawData);
var grid = new FastWindowGridModel <BlotterOrder>(10);
grid.LoadRowObjects(bytesArgs.RowData);
//Make sure data matches
var props = typeof(BlotterOrder).GetProperties();
Assert.AreEqual(props.Length, grid.ColumnCount, "Grid column count should match the number of public properties in BlotterOrders");
for (var r = 0; r < grid.RowCount; r++)
{
for (var c = 0; c < grid.ColumnCount; c++)
{
var cellstr = (grid.GetCellText(r, c) ?? "").ToLower();
var propval = props[c].GetValue(args.Data.ElementAt(r));
if (propval is DateTime)
{
var cellval = DateTimeOffset.Parse(cellstr, CultureInfo.InvariantCulture).DateTime;
Console.WriteLine($"({r},{c}): {propval} = {cellval}: {(DateTime)propval == cellval}");
Assert.AreEqual(propval, cellval);
}
else
{
var propstr = propval?.ToString().ToLower() ?? string.Empty;
Console.WriteLine($"({r},{c}): {propstr} = {cellstr}: {propstr == cellstr}");
Assert.AreEqual(propstr, cellstr);
}
}
}
Console.WriteLine("Property match completed successfully.");
isFired = true;
statusEvent.Set();
};
//Make the call to open the orders stream and wait for the ServerDataReceived event to fire TWICE
var callname = AppSettings["ordersStreamCall"];
Assert.IsNotNull(callname, "AppSettings should contain an entry for 'ordersStreamCall'");
//Call with sorting by price DESC
var call = new ServerCall(1, callname, new List <object> {
0, 10, "DESC", "price"
});
await connection.Send(call);
statusEvent.WaitOne(5000);
Assert.IsTrue(isFired, "ServerDataReceived event should fired.");
}
public async Task OrderStreamUpdatesSorting()
{
//Need to create delay for the first set of orders to come in
var statusEvent = new ManualResetEvent(false);
var isFired = false;
var count = 0;
//Listen for orders flowing in as json
connection.ServerJsonReceived += (sender, jsonArgs) =>
{
var args = ServerDataReceivedEventArgs <BlotterOrder> .DeserializeMessage(jsonArgs.RawJson);
switch (count)
{
case 1:
{
var prices = args.Data
.Select(order => order.Price)
.ToList();
Console.WriteLine(prices.Aggregate(new StringBuilder(), (sb, p) => sb.Append($"{p}, ")));
for (var i = 1; i < prices.Count; i++)
{
Assert.IsTrue(prices[i] <= prices[i - 1], "Prices should be in descending order.");
}
count = 0;
isFired = true;
statusEvent.Set();
}
break;
case 2:
{
var prices = args.Data
.Select(order => order.Price)
.ToList();
Console.WriteLine(prices.Aggregate(new StringBuilder(), (sb, p) => sb.Append($"{p}, ")));
for (var i = 1; i < prices.Count; i++)
{
Assert.IsTrue(prices[i] >= prices[i - 1], "Prices should be in ascending order.");
}
count = 0;
isFired = true;
statusEvent.Set();
}
break;
}
};
//Listen for orders flowing in as byte arrays
connection.ServerBytesReceived += (sender, bytesArgs) =>
{
var args = ServerDataReceivedEventArgs <BlotterOrder> .DeserializeMessage(bytesArgs.RawData);
switch (count)
{
case 1:
{
var prices = args.Data
.Select(order => order.Price)
.ToList();
Console.WriteLine(prices.Aggregate(new StringBuilder(), (sb, p) => sb.Append($"{p}, ")));
for (var i = 1; i < prices.Count; i++)
{
Assert.IsTrue(prices[i] <= prices[i - 1], "Prices should be in descending order.");
}
count = 0;
isFired = true;
statusEvent.Set();
}
break;
case 2:
{
var prices = args.Data
.Select(order => order.Price)
.ToList();
Console.WriteLine(prices.Aggregate(new StringBuilder(), (sb, p) => sb.Append($"{p}, ")));
for (var i = 1; i < prices.Count; i++)
{
Assert.IsTrue(prices[i] >= prices[i - 1], "Prices should be in ascending order.");
}
count = 0;
isFired = true;
statusEvent.Set();
}
break;
}
};
//Make the call to open the orders stream and wait for the ServerDataReceived event to fire TWICE
var callname = AppSettings["ordersStreamCall"];
Assert.IsNotNull(callname, "AppSettings should contain an entry for 'ordersStreamCall'");
//Call with sorting by price DESC
var call = new ServerCall(1, callname, new List <object> {
0, 10, "DESC", "price"
});
count = 1;
await connection.Send(call);
statusEvent.WaitOne(5000);
Assert.IsTrue(isFired, "ServerDataReceived event should fired.");
//Call with sorting by price ASC
statusEvent.Reset();
call = new ServerCall(1, callname, new List <object> {
0, 10, "ASC", "price"
});
count = 2;
await connection.Send(call);
statusEvent.WaitOne(5000);
Assert.IsTrue(isFired, "ServerDataReceived event should fired.");
}
public IEnumerator UpdateAvatarImage(User user)
{
ServerCall avatarCall = new ServerCall(ServerInteract.INSTANCE.ApplyAvatarTextureToImage(user, this));
yield return(StartCoroutine(avatarCall.call()));
}
