/// <summary>
/// Gifts item to the specified player.
/// </summary>
/// <remarks>
/// Service Name - UserInventoryManagement
/// Service Operation - GetUserItem
/// </remarks>
/// <param name="profileId">
/// </param>
/// <param name="itemId">
/// </param>
/// <param name="version">
/// </param>
/// <param name="immediate">
/// </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 GiveUserItemTo(
String profileId,
String itemId,
int version,
bool immediate,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.UserInventoryManagementServiceProfileId.Value] = profileId;
data[OperationParam.UserInventoryManagementServiceItemId.Value] = itemId;
data[OperationParam.UserInventoryManagementServiceVersion.Value] = version;
data[OperationParam.UserInventoryManagementServiceImmediate.Value] = immediate;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.UserInventoryManagement, ServiceOperation.GiveUserItemTo, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Sends an array of file details and returns
/// the details of any of those files that have changed
/// </summary>
/// <remarks>
/// Service Name - S3Handling
/// Service Operation - GetUpdatedFiles
/// </remarks>
/// <param name="category">
/// Category of files on server to compare against
/// </param>
/// <param name="fileDetailsJson">
/// An array of file details
/// </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 GetUpdatedFiles(
string category,
string fileDetailsJson,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
if (Util.IsOptionalParameterValid(category))
{
data[OperationParam.S3HandlingServiceFileCategory.Value] = category;
}
data[OperationParam.S3HandlingServiceFileDetails.Value] = JsonReader.Deserialize <object[]>(fileDetailsJson);
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.S3Handling, ServiceOperation.GetUpdatedFiles, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Method returns a page of global leaderboard results.
///
/// Leaderboards entries contain the player's score and optionally, some user-defined
/// data associated with the score.
///
/// Note: This method allows the client to retrieve pages from within the global leaderboard list
/// </summary>
/// <remarks>
/// Service Name - leaderboard
/// Service Operation - GetGlobalLeaderboardPage
/// </remarks>
/// <param name="leaderboardId">
/// The id of the leaderboard to retrieve.
/// </param>
/// <param name="sort">
/// Sort key Sort order of page.
/// </param>
/// <param name="startIndex">
/// The index at which to start the page.
/// </param>
/// <param name="endIndex">
/// The index at which to end the page.
/// </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 GetGlobalLeaderboardPage(
string leaderboardId,
SortOrder sort,
int startIndex,
int endIndex,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
var data = new Dictionary <string, object>();
data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = leaderboardId;
data[OperationParam.SocialLeaderboardServiceSort.Value] = sort.ToString();
data[OperationParam.SocialLeaderboardServiceStartIndex.Value] = startIndex;
data[OperationParam.SocialLeaderboardServiceEndIndex.Value] = endIndex;
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.GetGlobalLeaderboardPage, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Advanced universalId password reset using templates
/// </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="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 ResetUniversalIdPasswordAdvanced(
string universalId,
string serviceParams,
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;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure);
ServerCall sc = new ServerCall(ServiceName.Authenticate, ServiceOperation.ResetUniversalIdPasswordAdvanced, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Gets the number of entries in a global leaderboard
/// </summary>
/// <remarks>
/// Service Name - leaderboard
/// Service Operation - GET_GLOBAL_LEADERBOARD_ENTRY_COUNT
/// </remarks>
/// <param name="leaderboardId">
/// The ID of the leaderboard
/// </param>
/// <param name="versionId">
/// The version of the leaderboard
/// </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 GetGlobalLeaderboardEntryCountByVersion(
string leaderboardId,
int versionId,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
var data = new Dictionary <string, object>();
data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = leaderboardId;
if (versionId > -1)
{
data[OperationParam.SocialLeaderboardServiceVersionId.Value] = versionId;
}
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.GetGlobalLeaderboardEntryCount, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Purchases a quantity of an item from the specified store,
///if the user has enough funds. If includeDef is true,
///response includes associated itemDef with language fields
/// limited to the current or default language.
/// </summary>
/// <remarks>
/// Service Name - UserInventoryManagement
/// Service Operation - GetUserItem
/// </remarks>
/// <param name="defId">
/// </param>
/// <param name="quatity">
/// </param>
/// <param name="shopId">
/// </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 PurchaseUserItem(
String defId,
int quantity,
string shopId,
bool includeDef,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.UserInventoryManagementServiceDefId.Value] = defId;
data[OperationParam.UserInventoryManagementServiceQuantity.Value] = quantity;
data[OperationParam.UserInventoryManagementServiceShopId.Value] = shopId;
data[OperationParam.UserInventoryManagementServiceIncludeDef.Value] = includeDef;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.UserInventoryManagement, ServiceOperation.PurchaseUserItem, data, callback);
_client.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,
Dictionary <string, object> newItemData,
bool includeDef,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.UserInventoryManagementServiceItemId.Value] = itemId;
data[OperationParam.UserInventoryManagementServiceVersion.Value] = version;
data[OperationParam.UserInventoryManagementServiceNewItemData.Value] = newItemData;
data[OperationParam.UserInventoryManagementServiceIncludeDef.Value] = includeDef;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.UserInventoryManagement, ServiceOperation.UseUserItem, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Sets the player's experience to an absolute value. Note that this
/// is simply a set and will not reward the player if their level changes
/// as a result.
/// </summary>
/// <remarks>
/// Service Name - PlayerStatistics
/// Service Operation - SetXpPoints
/// </remarks>
/// <param name="in_xpValue">
/// The amount to set the the player's experience to
/// </param>
/// <param name="in_success">
/// The success callback
/// </param>
/// <param name="in_failure">
/// The failure callback
/// </param>
/// <param name="in_cbObject">
/// The callback object
/// </param>
/// <returns> The JSON returned in the callback is as follows.
/// {
/// "status":200,
/// "data":null
/// }
/// </returns>
public void SetExperiencePoints(
int in_xpValue,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.PlayerStatisticsExperiencePoints.Value] = in_xpValue;
SuccessCallback successCallbacks = m_brainCloudClientRef.GetGamificationService().CheckForAchievementsToAward;
if (in_success != null)
{
successCallbacks += in_success;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(successCallbacks, in_failure, in_cbObject);
ServerCall sc = new ServerCall(ServiceName.PlayerStatistics, ServiceOperation.SetXpPoints, data, callback);
m_brainCloudClientRef.SendRequest(sc);
}
/// <summary>
/// Partial increment of entity data field items. Partial set of items incremented as specified.
/// </summary>
/// <remarks>
/// Service Name - entity
/// Service Operation - INCREMENT_USER_ENTITY_DATA
/// </remarks>
/// <param name="entityId">The entity to increment</param>
/// <param name="jsonData">The subset of data to increment</param>
/// <param name="success">The success callback</param>
/// <param name="failure">The failure callback</param>
/// <param name="cbObject">The callback object</param>
public void IncrementUserEntityData(
string entityId,
string jsonData,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
var data = new Dictionary <string, object>();
data[OperationParam.EntityServiceEntityId.Value] = entityId;
if (Util.IsOptionalParameterValid(jsonData))
{
var where = JsonReader.Deserialize <Dictionary <string, object> >(jsonData);
data[OperationParam.EntityServiceData.Value] = where;
}
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var serverCall = new ServerCall(ServiceName.Entity, ServiceOperation.IncrementUserEntityData, data, callback);
_client.SendRequest(serverCall);
}
/// <summary>
///
/// </summary>
/// <remarks>
/// Service Name - CustomEntity
/// Service Operation - UpdateCustomEntityFields
/// </remarks>
/// <param name="context">
/// </param>
/// <param name="pageOffset">
/// </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 UpdateEntityFields(
string entityType,
string entityId,
int version,
string fieldsJson,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.CustomEntityServiceEntityType.Value] = entityType;
data[OperationParam.CustomEntityServiceEntityId.Value] = entityId;
data[OperationParam.CustomEntityServiceVersion.Value] = version;
data[OperationParam.CustomEntityServiceFieldsJson.Value] = JsonReader.Deserialize <Dictionary <string, object> >(fieldsJson);;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.CustomEntity, ServiceOperation.UpdateCustomEntityFields, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Method updates an existing entity's Owner and Acl on the server.
/// </summary>
/// <remarks>
/// Service Name - globalEntity
/// Service Operation - UPDATE_ENTITY_OWNER_AND_ACL
/// </remarks>
/// <param name="entityId">
/// The entity ID
/// </param>
/// <param name="version">
/// The version of the entity
/// </param>
/// <param name="ownerId">
/// The owner ID
/// </param>
/// <param name="acl">
/// The entity's access control list
/// </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 UpdateEntityOwnerAndAcl(
string entityId,
long version,
string ownerId,
ACL acl,
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;
data[OperationParam.OwnerId.Value] = ownerId;
data[OperationParam.GlobalEntityServiceAcl.Value] = JsonReader.Deserialize(acl.ToJsonString());
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.UpdateEntityOwnerAndAcl, data, callback);
_brainCloudClient.SendRequest(serverCall);
}
/// <summary>
/// Updates the item data on the specified user item.
/// </summary>
/// <remarks>
/// Service Name - UserInventoryManagement
/// Service Operation - UpdateUserItemData
/// </remarks>
/// <param name="itemId">
/// </param>
/// <param name="version">
/// </param>
/// <param name="newItemData">
/// </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 UpdateUserItemData(
string itemId,
int version,
string newItemData,
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;
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.UpdateUserItemData, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Method updates an existing entity on the server.
/// </summary>
/// <remarks>
/// Service Name - GlobalEntity
/// Service Operation - Update
/// </remarks>
/// <param name="in_entityId">
/// The entity ID
/// </param>
/// <param name="in_version">
/// The version of the entity to update
/// </param>
/// <param name="in_jsonEntityData">
/// The entity's data as a json string
/// </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 UpdateEntity(
string in_entityId,
int in_version,
string in_jsonEntityData,
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;
Dictionary <string, object> entityData = JsonReader.Deserialize <Dictionary <string, object> >(in_jsonEntityData);
data[OperationParam.GlobalEntityServiceData.Value] = entityData;
ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
ServerCall serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.Update, data, callback);
m_brainCloudClientRef.SendRequest(serverCall);
}
/// <summary>
/// Sends a notification to multiple users consisting of alert content and custom data.
/// </param>
/// <param name="profileIds">
/// Collection of profile IDs to send the notification to
/// </param>
/// <param name="alertContentJson">
/// Body and title of alert
/// </param>
/// <param name="customDataJson">
/// Optional custom data
/// </param>
/// <param name="success">
/// The success callback
/// </param>
/// <param name="failure">
/// The failure callback
/// </param>
/// <param name="cbObject">
/// The callback object
/// </param>
public void SendNormalizedPushNotificationBatch(
IList <string> profileIds,
string alertContentJson,
string customDataJson,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.PushNotificationSendParamProfileIds.Value] = profileIds;
data[OperationParam.AlertContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(alertContentJson);
if (Util.IsOptionalParameterValid(customDataJson))
{
data[OperationParam.CustomData.Value] = JsonReader.Deserialize <Dictionary <string, object> >(customDataJson);
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.PushNotification, ServiceOperation.SendNormalizedBatch, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Updates an event in the user's incoming event mailbox.
/// </summary>
/// <remarks>
/// Service Name - Event
/// Service Operation - UpdateEventData
/// </remarks>
/// <param name="evId">
/// The event id
/// </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 UpdateIncomingEventData(
string evId,
string jsonEventData,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.EvId.Value] = evId;
if (Util.IsOptionalParameterValid(jsonEventData))
{
Dictionary <string, object> eventData = JsonReader.Deserialize <Dictionary <string, object> > (jsonEventData);
data[OperationParam.EventServiceUpdateEventDataData.Value] = eventData;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.Event, ServiceOperation.UpdateEventData, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Removes the match and match history from the server. DEBUG ONLY, in production it is recommended
/// the user leave it as completed.
/// </summary>
/// <remarks>
/// Service Name - AsyncMatch
/// Service Operation - Delete
/// </remarks>
/// <param name="ownerId">
/// Match owner identifier
/// </param>
/// <param name="matchId">
/// Match identifier
/// </param>
/// <param name="pushContent">
/// Match owner identifier
/// </param>
/// <param name="summary">
/// Match owner identifier
/// </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>
//string abandonedBy,
public void AbandonMatchWithSummaryData(
string ownerId,
string matchId,
string pushContent,
string summary,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
//abandoneddby not needed?
data["ownerId"] = ownerId;
data["matchId"] = matchId;
data["pushContent"] = pushContent;
data["summary"] = JsonReader.Deserialize <Dictionary <string, object> >(summary);
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.AsyncMatch, ServiceOperation.AbandonMatchWithSummaryData, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Registers the given device token with the server to enable this device
/// to receive push notifications.
/// </param>
/// <param name="in_device">
/// The device platform being registered.
/// </param>
/// <param name="in_token">
/// The platform-dependant device token needed for push notifications.
/// </param>
/// <param name="in_success">
/// The success callback
/// </param>
/// <param name="in_failure">
/// The failure callback
/// </param>
/// <param name="in_cbObject">
/// The callback object
/// </param>
/// <returns> JSON describing the new value of the statistics and any rewards that were triggered:
/// {
/// "status":200,
/// "data":null
/// }
/// </returns>
public bool RegisterPushNotificationDeviceToken(
string in_device,
string in_token,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
bool bToReturn = false;
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.PushNotificationRegisterParamDeviceType.Value] = in_device;
data[OperationParam.PushNotificationRegisterParamDeviceToken.Value] = in_token;
ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
ServerCall sc = new ServerCall(ServiceName.PushNotification, ServiceOperation.Register, data, callback);
m_brainCloudClientRef.SendRequest(sc);
bToReturn = true;
return(bToReturn);
}
/// <summary>
/// Updates the "friend summary data" associated with the logged in user.
/// Some operations will return this summary data. For instance the social
/// leaderboards will return the player's score in the leaderboard along
/// with the friend summary data. Generally this data is used to provide
/// a quick overview of the player without requiring a separate API call
/// to read their public stats or entity data.
///
/// </summary>
/// <remarks>
/// Service Name - PlayerState
/// Service Operation - UpdateSummary
/// </remarks>
/// <param name="jsonSummaryData">
/// A JSON string defining the summary data.
/// For example:
/// {
/// "xp":123,
/// "level":12,
/// "highScore":45123
/// }
/// </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 UpdateSummaryFriendData(
string jsonSummaryData,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
if (Util.IsOptionalParameterValid(jsonSummaryData))
{
Dictionary <string, object> summaryData = JsonReader.Deserialize <Dictionary <string, object> >(jsonSummaryData);
data[OperationParam.PlayerStateServiceUpdateSummaryFriendData.Value] = summaryData;
}
else
{
data = null;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.PlayerState, ServiceOperation.UpdateSummary, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Sends a notification to a "group" of user based on a brainCloud portal configured notification template.
/// Includes JSON defining the substitution params to use with the template.
/// See the Portal documentation for more info.
/// </param>
/// <param name="groupId">
/// Target group
/// </param>
/// <param name="alertContentJson">
/// Body and title of alert
/// </param>
/// <param name="customDataJson">
/// Optional custom data
/// </param>
/// <param name="success">
/// The success callback
/// </param>
/// <param name="failure">
/// The failure callback
/// </param>
/// <param name="cbObject">
/// The callback object
/// </param>
public void SendNormalizedPushNotificationToGroup(
string groupId,
string alertContentJson,
string customDataJson,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.GroupId.Value] = groupId;
data[OperationParam.AlertContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(alertContentJson);
if (Util.IsOptionalParameterValid(customDataJson))
{
data[OperationParam.CustomData.Value] = JsonReader.Deserialize <Dictionary <string, object> >(customDataJson);
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.PushNotification, ServiceOperation.SendNormalizedToGroup, data, callback);
m_brainCloudClientRef.SendRequest(sc);
}
/// <summary>
/// Gets a list of up to randomCount randomly selected entities from the server based on the where condition and specified maximum return count.
/// </summary>
/// <remarks>
/// Service Name - globalEntity
/// Service Operation - GET_RANDOM_ENTITIES_MATCHING
/// </remarks>
/// <param name="where">Mongo style query string</param>
/// <param name="maxReturn">The maximum number of entities to return</param>
/// <param name="success">The success callback</param>
/// <param name="failure">The failure callback</param>
/// <param name="cbObject">The callback object</param>
public void GetRandomEntitiesMatching(
string whereJson,
int maxReturn,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
var data = new Dictionary <string, object>();
if (Util.IsOptionalParameterValid(whereJson))
{
var where = JsonReader.Deserialize <Dictionary <string, object> >(whereJson);
data[OperationParam.GlobalEntityServiceWhere.Value] = where;
}
data[OperationParam.GlobalEntityServiceMaxReturn.Value] = maxReturn;
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.GetRandomEntitiesMatching, data, callback);
_client.SendRequest(serverCall);
}
/// <summary>
/// Atomically increment (or decrement) player statistics.
/// Any rewards that are triggered from player statistic increments
/// will be considered. Player statistics are defined through the brainCloud portal.
/// Note also that the "xpCapped" property is returned (true/false depending on whether
/// the xp cap is turned on and whether the player has hit it).
/// </summary>
/// <remarks>
/// Service Name - PlayerStatistics
/// Service Operation - Update
/// </remarks>
/// <param name="in_jsonData">
/// The JSON encoded data to be sent to the server as follows:
/// {
/// stat1: 10,
/// stat2: -5.5,
/// }
/// would increment stat1 by 10 and decrement stat2 by 5.5.
/// For the full statistics grammer see the api.braincloudservers.com site.
/// There are many more complex operations supported such as:
/// {
/// stat1:INC_TO_LIMIT#9#30
/// }
/// which increments stat1 by 9 up to a limit of 30.
/// </param>
/// <param name="in_success">
/// The success callback
/// </param>
/// <param name="in_failure">
/// The failure callback
/// </param>
/// <param name="in_cbObject">
/// The callback object
/// </param>
/// <returns> JSON describing the new value of the statistics and any rewards that were triggered:
/// {
/// "status":200,
/// "data":{
/// "experiencePoints":10,
/// "xpCapped":false,
/// "rewardDetails":{
/// "xp":{
/// "experienceLevels":[
/// {
/// "level":1,
/// "reward":{
/// "currency":{
/// "gold":1000
/// }
/// }
/// }
/// ]
/// }
/// },
/// "rewards":{
/// "experienceLevels":[
/// 1
/// ],
/// "currency":{
/// "gold":1000
/// }
/// },
/// "experienceLevel":1,
/// "statistics":{
/// "LIVES":1
/// },
/// "currency":{
/// "gems":{
/// "purchased":0,
/// "balance":10,
/// "consumed":0,
/// "awarded":10
/// },
/// "gold":{
/// "purchased":0,
/// "balance":2000,
/// "consumed":0,
/// "awarded":2000
/// }
/// }
/// }
/// }
/// </returns>
public void IncrementPlayerStats(
string in_jsonData,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
Dictionary <string, object> statsData = JsonReader.Deserialize <Dictionary <string, object> > (in_jsonData);
data[OperationParam.PlayerStatisticsServiceStats.Value] = statsData;
SuccessCallback successCallbacks = m_brainCloudClientRef.GetGamificationService().CheckForAchievementsToAward;
if (in_success != null)
{
successCallbacks += in_success;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(successCallbacks, in_failure, in_cbObject);
ServerCall sc = new ServerCall(ServiceName.PlayerStatistics, ServiceOperation.Update, data, callback);
m_brainCloudClientRef.SendRequest(sc);
}
/// <summary>
/// Creates custom data stream screen event
/// </summary>
/// <remarks>
/// Service Name - DataStream
/// Service Operation - CustomScreenEvent
/// </remarks>
/// <param name="eventName">
/// The name of the event
/// </param>
/// <param name="jsonEventProperties">
/// The properties of the event
/// </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 CustomScreenEvent(
string eventName,
string jsonEventProperties,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.DataStreamEventName.Value] = eventName;
if (Util.IsOptionalParameterValid(jsonEventProperties))
{
Dictionary <string, object> eventProperties = JsonReader.Deserialize <Dictionary <string, object> >(jsonEventProperties);
data[OperationParam.DataStreamEventProperties.Value] = eventProperties;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall serverCall = new ServerCall(ServiceName.DataStream, ServiceOperation.CustomScreenEvent, data, callback);
_client.SendRequest(serverCall);
}
/// <summary>
/// Method updates an existing entity on the server.
/// </summary>
/// <remarks>
/// Service Name - GlobalEntity
/// Service Operation - Update
/// </remarks>
/// <param name="entityId">
/// The entity ID
/// </param>
/// <param name="version">
/// The version of the entity to update
/// </param>
/// <param name="jsonEntityData">
/// The entity's data as a json string
/// </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 UpdateEntity(
string entityId,
int version,
string jsonEntityData,
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;
var entityData = JsonReader.Deserialize <Dictionary <string, object> >(jsonEntityData);
data[OperationParam.GlobalEntityServiceData.Value] = entityData;
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.Update, data, callback);
_client.SendRequest(serverCall);
}
/// <summary>
/// Executes a script on the server.
/// </summary>
/// <remarks>
/// Service Name - Script
/// Service Operation - Run
/// </remarks>
/// <param name="scriptName">
/// The name of the script to be run
/// </param>
/// <param name="jsonScriptData">
/// Data to be sent to the script in json format
/// </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 RunScript(
string scriptName,
string jsonScriptData,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.ScriptServiceRunScriptName.Value] = scriptName;
if (Util.IsOptionalParameterValid(jsonScriptData))
{
Dictionary <string, object> scriptData = JsonReader.Deserialize <Dictionary <string, object> >(jsonScriptData);
data[OperationParam.ScriptServiceRunScriptData.Value] = scriptData;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.Script, ServiceOperation.Run, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Finalize A Two Staged Purchase Transaction
/// </summary>
/// <remarks>
/// Service Name - AppStore
/// Service Operation - FINALIZE_PURCHASE
/// </remarks>
/// <param name="storeId">
/// The store storeId. Valid stores are:
/// - itunes
/// - facebook
/// - appworld
/// - steam
/// - windows
/// - windowsPhone
/// - googlePlay
/// </param>
/// /// <param name="transactionId">
/// The Transaction Id returned in Start Transaction
/// </param>
/// <param name="transactionJson">
/// The specific store data required
/// </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 FinalizePurchase(
string storeId,
string transactionId,
string transactionJson,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.AppStoreServiceStoreId.Value] = storeId;
data[OperationParam.AppStoreServiceTransactionId.Value] = transactionId;
var transactionData = JsonReader.Deserialize <Dictionary <string, object> >(transactionJson);
data[OperationParam.AppStoreServiceTransactionData.Value] = transactionData;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.AppStore, ServiceOperation.FinalizePurchase, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Post the players score to the given social leaderboard.
/// 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.
///
/// Note that the behaviour of posting a score can be modified in
/// the brainCloud portal. By default, the server will only keep
/// the player's best score.
/// </summary>
/// <remarks>
/// Service Name - leaderboard
/// Service Operation - PostScore
/// </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="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 PostScoreToLeaderboard(
string leaderboardId,
long score,
string jsonData,
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;
}
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.PostScore, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Retrieve a view of the group leaderboard surrounding the current group
/// </summary>
/// <remarks>
/// Service Name - leaderboard
/// Service Operation - GET_GROUP_LEADERBOARD_VIEW
/// </remarks>
/// <param name="leaderboardId">
/// the id of the leaderboard
/// </param>
/// <param name="groupId">
/// The groups Id
/// </param>
/// <param name="sort">
/// The groups Id
/// </param>
/// <param name="beforeCount">
/// The count of number of players before the current player to include.
/// </param>
/// <param name="afterCount">
/// The count of number of players after the current player to include.
/// </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 GetGroupLeaderboardView(
string leaderboardId,
string groupId,
SortOrder sort,
int beforeCount,
int afterCount,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
var data = new Dictionary <string, object>();
data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = leaderboardId;
data[OperationParam.SocialLeaderboardServiceGroupId.Value] = groupId;
data[OperationParam.SocialLeaderboardServiceSort.Value] = sort.ToString();
data[OperationParam.SocialLeaderboardServiceBeforeCount.Value] = beforeCount;
data[OperationParam.SocialLeaderboardServiceAfterCount.Value] = afterCount;
var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.GetGroupLeaderboardView, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Allows a quantity of a specified user item to be sold.
///If any quantity of the user item remains,
///it will be returned, potentially with the associated
///itemDef (with language fields limited to the current
///or default language), along with the currency refunded
///and currency balances.
/// </summary>
/// <remarks>
/// Service Name - UserInventoryManagement
/// Service Operation - SellUserItem
/// </remarks>
/// <param name="itemId">
/// </param>
/// <param name="version">
/// </param>
/// <param name="quantity">
/// </param>
/// <param name="shopId">
/// </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 SellUserItem(
string itemId,
int version,
int quantity,
string shopId,
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.UserItemsServiceQuantity.Value] = quantity;
data[OperationParam.UserItemsServiceShopId.Value] = shopId;
data[OperationParam.UserItemsServiceIncludeDef.Value] = includeDef;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.UserItems, ServiceOperation.SellUserItem, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// List user files from the given cloud path
/// </summary>
/// <param name="cloudPath">File path</param>
/// <param name="recurse">Whether to recurse down the path</param>
/// <param name="success">The success callback</param>
/// <param name="failure">The failure callback</param>
/// <param name="cbObject">The callback object</param>
public void ListUserFiles(
string cloudPath,
bool?recurse,
SuccessCallback success = null,
FailureCallback failure = null,
object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
if (Util.IsOptionalParameterValid(cloudPath))
{
data[OperationParam.UploadPath.Value] = cloudPath;
}
if (recurse.HasValue)
{
data[OperationParam.UploadRecurse.Value] = recurse.Value;
}
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.File, ServiceOperation.ListUserFiles, data, callback);
_client.SendRequest(sc);
}
/// <summary>
/// Like findLobby, but explicitely geared toward creating new lobbies
/// </summary>
///
/// otherUserCxIds support coming soon!
///
public void CreateLobby(string in_roomType, int in_rating,
bool in_isReady, Dictionary <string, object> in_extraJson, string in_teamCode,
Dictionary <string, object> in_settings, string[] in_otherUserCxIds = null,
SuccessCallback success = null, FailureCallback failure = null, object cbObject = null)
{
Dictionary <string, object> data = new Dictionary <string, object>();
data[OperationParam.LobbyRoomType.Value] = in_roomType;
data[OperationParam.LobbyRating.Value] = in_rating;
data[OperationParam.LobbySettings.Value] = in_settings;
data[OperationParam.LobbyIsReady.Value] = in_isReady;
if (in_otherUserCxIds != null)
{
data[OperationParam.LobbyOtherUserCxIds.Value] = in_otherUserCxIds;
}
data[OperationParam.LobbyExtraJson.Value] = in_extraJson;
data[OperationParam.LobbyTeamCode.Value] = in_teamCode;
ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject);
ServerCall sc = new ServerCall(ServiceName.Lobby, ServiceOperation.CreateLobby, data, callback);
m_clientRef.SendRequest(sc);
}
