We’ve got a doozy of a release for you heading into the Summer Holidays!

Release Highlights

WebHooks!

brainCloud now supports WebHooks! Which means it’s easier than ever to have your brainCloud app respond to events triggered from outside apps and services.

WebHooks are app-defined HTTP-callbacks that are triggered by events on another web service, and can be configured to invoke scripts in your app. The capabilities are similar to our Server-to-Server (S2S) interface, with the advantage that it is a more standardized mechanism, so tons of services already support it.

Examples of useful services that employ WebHooks include: Photon, Twilio, MailChimp, HipChat, Slack, Zapier, etc.

Setting up a WebHook integration is pretty simple:

• Write a new Cloud Code method that accepts our WebHook Parameter Syntax. The parameters you receive will be defined by the External Service that is calling you.
• Configure the WebHook using the Design Portal. You’ll give the hook a name, determine how you are securing it, and link it to your Cloud Code method. You use the Design | Cloud Code | WebHooks screen to configure your WebHooks.
• Register your WebHook URL in the external service. Finally, go to the external service and configure your WebHook, specifying the WebHook endpoint from the Design Portal, and any additional parameters that you require to be sent to your method.

Note – as with every external integration, we have to protect our servers from misuse. We have provided several mechanisms (server ip-validation and secret validation) to help your app confirm the identity of the service invoking the webhook. You should also ensure that your cloud script validates the validity of the incoming request. 

API Counts: Note that incoming webhook invocations count as 1 API count for the webhook itself, and 1 API count for the cloud code script being invoked.

[Note – we’ll be putting together a WebHooks tutorial in the next couple of days to better illustrate how they work.]

Faster File Downloads

We have re-factored our file-handling services to enable significantly faster downloads. The executive summary is that now when the client attempts to download a file via the URLs that are returned from GetFileList(), GetUpdatedFiles(), and ListUserFiles() – it will automatically be redirected to a cached version of the file located on a Content Distribution Network (CDN) node that is closer to them geographically.

The hitch is that Unity doesn’t natively support redirection (currently), so this doesn’t transparently work for our Unity apps. But don’t worry, there are two simple solutions:

#1 – Directly request the CDN-cached version of the File Url via the new GetCDNURL() methods (there are separate similarly-named methods for custom files vs. user files)

#2 – Use the UniWeb ($25) plug-in, which *does* support redirection, to retrieve the files instead of the built-in Unity libraries

#3 – Turn it off. Support for this behaviour can be turned off using the elegantly named “Funnel Custom and User File retrieval through app servers (slower)” compatibility option. You’ll find the option under Design | Core App Info | Advanced Settings, in the Compatibility Settings section.

Note – for maximum compatibility, the compatility flag defaults to enabled (that is, slower, legacy-mode behavior) for all existing apps. If your app would benefit from this speed increase, be sure to go disable the legacy setting!

Improved Entity Updates

We have revised our Create() and Update() Entity APIs to be much more efficient – and have revised the Increment() APIs to bring them into greater alignment with the others.

The biggest change is that the Create() and Update() methods no longer return the full entity data upon success. Returning the fully rendered object originally *seemed* like a good idea – and certainly looks good in the API Explorer for small objects. But if you are an storing larger objects, returning all that data in the API response just eats up the data connection (and isn’t useful to the app, since it already knows the data that it sent!).

Not that although the Create() and Update() methods for Entities* (i.e. User Entities, Global Entities, Groups and Group Entities) no longer return the full object upon success, they do still return the object skeleton (or summary), which includes the entityId, entityType, version, etc. The diagram below should better illustrate the change.

As always, we’ve added a new Compatibility Flag (“Default to returning full Entity contents for create and update operations”) to preserve the old behaviour if your app requires it. This flag defaults to ON for existing apps, and OFF for new apps moving forward.

Secondly, we’ve revised the new IncrementData() APIs to bring them into better alignment with the Create() and Update() methods. For example, like the methods above, IncrementUserEntityData(), will now return the full object skeleton upon success — with one addition – it will also return the updated balance of any fields that were incremented.

This new protocol was implemented by removing the old returnData parameter, which was a less optimal attempt to give the user control over what data is returned. The old method still works for apps using the 2.24 version of the libraries, but devs updating to 2.25+ will need to adjust their method calls accordingly.

Portal Changes

We’ve made the following portal changes:

• Design | Cloud Code | WebHooks
  • New screens for defining WebHooks. See the feature section above for details.
• Design | Marketplace | Products
  • We have enhanced the workflows so that you no longer have to manually press the [Facebook Register Products] button after making changes to the Facebook pricing information for products – it is now done automatically. We have left the button to support advanced scenarios where manually re-registering still makes sense.
• Monitoring | User Monitoring 
  • The new User Files screen allows you to view the files uploaded to an individual user account.
  • We have moved the in-app purchases that were displayed as part of the Virtual Currency screen to their own Transactions screen.
• Reporting
  • The  Sessions graph on the Analytics page now displays values according to local time.
  • We’ve added a new Incoming WebHooks count to the API Usage page.
• Miscellaneous
  • Faster App Deletion – Deleting an app now immediately marks it for deletion, to be completed by a background task during non-peak hours.
  • Password confirmations  – We have added more safety checks, where brainCloud will prompt you  re-enter your password for destructive operations (deleting an app, etc). We’ll be further enhancing these safety mechanisms in future updates. 

API Changes

The following changes/additions have affected the brainCloud API:

• Authenticate() and ReadPlayerState() methods
  • countryCode is now being returned
  • New isTester flag is being returned for users. This corresponds ot the [x] Is Tester checkbox that is selectable from Monitoring | User Monitoring | User Summary.  This is very handy if you want to trigger special logging, debug screens, etc to be available to testers but not regular users of your app.
• Client
  • New method (EndOfMessageBundleMarker()) for forcing the end of a message bundle. Useful for ensuring that large brainCloud requests are isolated into seaparate message bundles, and for ensuring that certain key calls (like LogOut()) get to return before continuing message processing.
• Cloud Code APIs
  • New CancelScheduledScript() method to cancel a scheduled cloud code job
• Currency APIs
  • Now properly enforces balance server-side for all ConsumeCurrency() operations. There’s a compatibility switch that defaults to ON for existing apps, but we recommend that all devs go to Design | Core App Info | Advanced Settings, and turn the “Enable legacy Currency handling (balance not enforced for Consume)” to OFF for their app (with appropriate testing, of course).
• Entity Create / Update APIs
  • As described in the Release Hilights section, API’s have been revised so that we do not return the full data content during Create() and Update() operations. There is a new compatibility flag to maintain the legacy behaviour (by default turned ON for existing apps).
  • The Increment() API methods have been revised to return results that are consistant with the rest of the Entity Create()/Update() methods. Revised methods include IncrementUserEntityData(), IncrementSharedUserEntityData(), IncrementGlobalEntityData(), IncrementGroupData() and IncrementGroupEntityData().
• Friend API
  • New GetSummaryDataForProfileId() method – returns the name, email, pictureUrl, and summary data for the specified user.
• Group APIs
  • New AutoJoinGroup() method allows you to automatically join a group that meets the provided criteria. Useful for quickly creating arbitrary grops of users.
  • The ReadGroupData() method has been added to client libraries (was missed last release – oops!)
• Identity APIs
  • New RefreshIdentity() method allows you to update identity tokens that are not the primary login identity

We have also removed / deprecated the following methods:

• Increment methods
  • We have removed the versions of the Entity Increment methods that accepted the returnData parameter.

Miscellaneous Changes / Fixes

• IPv6 Support
  • We have updated the C++ / Objective-C libraries to support IPv6.
  • We have re-confirmed that all other libraries properly support IPv6.
• Documentation
  • Completely revised and updated Cloud Code documentation section!
• Updated libraries
  • All of the supported libraries have been updated to support the latest APIs
• Plus miscellaneous fixes and performance enhancements.
• Miscellaneous page improvements – we’ve been iterating through our pages to add a bit more consistency and presentation polish.

We’ve got a smaller release for you this time. We’ve got a few bigger features cooking in the fires –  but in the meantime we thought we’d push out a few of the polish items and customer requests that we have queued.

Release Highlights

Authy OneTouch

We have enhanced our Two-Factor Authentication implementation to take advantage of Authy OneTouch for those users who are using the Authy App. It’s super convenient – no codes to enter! Just click [Approve] to confirm your login.

Customer API Requests

We’ve also released a few API enhancements at the request of some key customers. There are updates to Groups, Identities and the Cloud Code bridge. We hope you like them!

Portal Changes

We’ve made the following portal changes:

• Login
  • During Two-Factor Authentication you’ll notice the red One Touch meter. It tells you that we’ve detected that you have the Authy app, and have sent a request that you can simply [Approve] without having to enter the authentication code.
    Note: The login screen will stop monitoring for One Touch approval after 5 minutes, after which you can still enter the verification code.
• Power | Edit User
  • To ease the burden of 2FA, our login process optionally allows you to flag a device as trusted, so you won’t need to re-verify for 30 days. But what if you mistakenly hit that option when logging in from a public computer? Witness the new [Clear Trusted Devices] option on the Two-Factor tab of the Edit User dialog. Ta-dah! 🙂
  • Team Administrators can now unlink Two-factor Authentication from other user’s accounts (allows self-fixing of TFA-issues should they arise)
• General
  • Minor updates (for clarification and consistancy) to icons used throughout the portal.

API Changes

The following changes/additions have affected the brainCloud API:

• Cloud Code Bridge
  • New GetProfileId() method returns the profile id of the current user. Saves having to call to the PlayerState proxy for the information.
  • New GetName() method returns the name of the current user
  • New GetEmail() method returns the email address of the current user
• Groups API
  • Updated GetMyGroups() method to additionally return groups that you have been invited to and have requested to join.
• Identity API
  • New GetIdentities() method returns a list of the non-anonymous identities associate with the current profile. This method is useful to learn if the user has already associated a Facebook account with their profile, for example.
  • New GetExpiredIdentities() method returns a list of identitities with the current profile whose authentication tokens  that have expired (and should be refreshed)

We have also deprecated the following methods:

• Authentication Service
  • Deprecated GenerateGUID() and GenerateNewAnonymousId() – replaced with GenerateAnonymousId() method, which works in a more consistant manner.

Miscellaneous Changes / Fixes

• Updated libraries
  • All libraries have been updated with the latest API enhancements. Go get ’em!
• Documentation updates
  • Added Versioning overview to the Appendix summary of the API REF docs
  • Updated AsyncMatch documentation
  • Updated Leaderboard documentation
  • Better pre-hook cloud code examples
• Source updates
  • Removed JSON return data from the client source code, since that data is now included (and more likely to be up-to-date) in the API REF documentation
• Important Fixes
  • During login, if the user’s timezone has changed, the user’s timezone as recorded in segments is updated as well
  • Fix to Facebook purchase handling which could sometimes cause virtual currencies to be awarded twice in some circumstances
  • Added Facebook real-time payment transactions to the request logs
• Plus miscellaneous fixes and performance enhancements…

Release Highlights

This release delivers six new features:

• Groups! (i.e. Clans!) – allow your users to clan-up for greater socialization and competition!
• 2FA for Teams! An extra level of security for your development accounts.
• Scheduled Push Notifications! Deliver that message at exactly the right time no matter what timezone your users are in.
• Universal Windows Support – we have a new C++ library for Universal Windows Platform (UWP) apps.
• Xamarin Support – we have new iOS and Android libraries for Xamarin!
• watchOS Support – built native apps on watchOS using brainCloud!

Plus the usual assortment of API and library improvements. Note that all client libraries have been updated to the latest, except Javascript, which will be updated and released mid-next-week (week of Friday, May 18th).

Read on for all the details.

Release Highlights

Groups (i.e. Clans)

Although you’ve always been able to write your own clan system in brainCloud using Global Entities and Cloud Code, we thought it was about time that we lent a hand – reducing the coding burden, and adding great tools support at the same time.

This feature provides an API that allows users to dynamically create, join and manage Groups.

Groups have the following characteristics:

• Groups are a combination of a collection of users, plus some shared data about those users
• Groups in brainCloud are organized by Group Type. The developer defines a Group Type, setting certain rules such as the maximum # of members, and the action to take if a Group’s owner is deleted.
• There are three built-in roles – owner, admin and member
  • Groups are owned by a single user – but can have additional admins
  • Only the owner of a group may delete it. Owners may leave a group only if they re-assign ownership to another user.
  • Group membership can be open or closed. Open groups can be freely joined by anyone. Closed groups require an owner or admin to invite or approve join requests.
  • Groups can associate additional attribute data with members – which can allow for additional developer-defined role types (i.e. think ranks in Clash of Clans – Leader, Co-Leader, Elder, Member, etc)
  • A user can be a member of more than one Group. (Limits can be imposed by the developer, of course).
• Group data is a JSON object associated with the group. Access to the data is controlled by the group ACL.
• Groups can also own a set of entities (i.e. Group Entities) for more complex data needs. Group Entities can be owned by the group as a whole, or by individual members within a group.
• Group membership can be used for leaderboard retrieval

For more information re: brainCloud group support, refer to the Group API Reference Page .

Two-factor Authentication (for Team Members)

brainCloud’s Two-Factor Authentication (2FA) support allows you to tie your phone to your developer account for extra security and peace-of-mind.

We’ve chosen to use Twilio’s Authy technology for our 2FA implementation – it works similarly to Google Authenticator, but gives more options in terms of authentication (text, voice, or app) and offers better management of verification devices.

Hooking up 2FA to your account couldn’t be simpler:

• Choose Edit Profile from the top-right Power menu of the brainCloud Portal
• Go to the new Two-factor tab
• Click on the green [Click to Enable 2FA] button and follow the prompts!

For more information, refer to the Enabling 2FA page in our documentation.

Scheduled Push Notifications

Through the magic of scheduled cloud code and our push notification API, it’s always been possible to schedule push notifications to happen at a precise time. But – what if you want to send notifications to a segment of users, and ensure that those notifications get sent at a standardized local time – say 9am, for each of the users, regardless of their timezone? That was much, much harder.

Until now. Our new Schedule Push Notification interface allows you to specify a local time to send all notifications at. brainCloud will then automatically create the appropriate set of scheduled push notification jobs – one for each timezone involved – and then automatically send the notifications at the appropriate time for each group of users.

It’s extremely powerful, and very simple to use. Check out the new S2S API calls here.

Universal Windows Platform Support

We’ve created a new C++ library with support for Universal Windows Platform apps. And we’re making the library available via nuget as well. Stay tuned for more details.

Xamarin Support

With it’s recent acquisition by Microsoft and integration into Visual Studio, we’re finding tons of interest in Xamarin support for brainCloud. We’re pleased to announce the availability of the brainCloud Xamarin.ios and Xamarin.android libraries!

watchOS Support

Apple has announced that moving forward, all new and updated watchOS apps must be native. We are here to help, so we’ve built a new version of the brainCloud library that runs natively on watchOS 2. You’re welcome!

Portal Changes

The first thing you will notice is that we have re-ordered the tabs of the Design section of the portal to be mostly alphabetical (we still kept the Core App Info section at the top). We’ve added (and continued to add) so many features to brainCloud, going alphabetical seems like the only way to keep things easily findable.

In addition, we’ve made the following portal changes:

• Power | Edit User
  • Moved the Password section to a separate tab for clarity.
  • Added a new Two-Factor tab for enabling Two-Factor Authentication (2FA).
• Admin | Team Members
  • Added a 2FA column so that you can confirm which team members have enabled Two-Factor Authentication for additional security.
• Design | Cloud Code | Scripts
  • The scripts screen is now sortable according to the date+time that the scripts were last updated.
• Design | Groups
  • The new Group Types screen to allow you to define that types of groups that your application will support. Configuration information includes the maximum # of users allowed per group (default is 50 – contact us if you need higher), and what the system should do if the owner of a group is deleted.
• Monitoring | Global Monitoring | Jobs
  • Added support for viewing Scheduled Push Notification jobs.
• Monitoring | Group Monitoring
  • Added new Group Monitoring section to allow you to view and manage an application’s global user groups
  • The Groups screen presents a list of all groups, filterable by type of group. You can view the details of a Group by clicking on it – you can even edit the Group’s json-data.
  • The Group Entities screen displays a list of entities associated with groups. The list is filterable by entity type and/or group id.
    Pro-tip – to clickly see a group’s entities, look up the group in Group Monitoring first, and then choose “View Group Entities” from the action menu.
• Monitoring | User Monitoring | Groups
  • Shows the groups that a user is a member of, together with details about the group and the user’s membership.

API Changes

The following additions / changes have been made to the brainCloud API:

• Global Entities
  • New IncrementGlobalEntityData() method allows you to increment discrete numeric values in a global entity. Great for incrementing atomic stats-like values without pushing a full update to the entire JSON object.
• New Group API
  • There are too many new API methods to list here. For the full description of the new Group and Group Entity APIs, see the Groups section of the API Reference documentation.
• Leaderboard API
  • New GetGroupSocialLeaderboard() method retrieves a leaderboard filtered to the members of the specified group
• Push Notifications
  • New SendNormalizedPushNotificationToGroup() and SendTemplatedPushNotificationToGroup() methods sends push notifications to the members of a group
  • New S2S Scheduled Push Notifiation methods ( ScheduleNormalizedPushNotifications() and ScheduleRichPushNotifications() ) allow you to send push notifications to users according to their timezone
• User Entities
  • New IncrementUserEntityData() method allows you to increment discrete numeric values in a user entity. Just as useful as the GlobalEntity, Group and GroupEntity versions of the same method!
  • New GetSharedEntitiesListForPlayerId() method retrieves a list of shared entities for the specified player based on the specified where clause

Miscellaneous Changes / Fixes

• New/updated libraries
  • New Universal Windows Platform (UWP) C++ libs
  • New iOS and Android Xamarin libs
  • New watchOS libs
  • Upgraded version of OpenSSL in C++ libs
• Fixes and changes
  • Pre-hook cloud-code methods can no longer directly call the API that invoked them (prevents recursion loops!)
• Documentation Updates
  • Migrated reason codes over to new API Ref docs
  • Improved performance of new API Ref docs — Table-of-Contents now cached
  • API doc links in API explorer moved to new API Ref
  • Tutorials upgraded to link to new API Reference
  • New error handling tutorial
• Miscellaneous defect fixes
• Miscellaneous performance improvements

Release Highlights

There are a ton of small enhancements and fixes in 2.22 – plus these three big things:

brainCloud Friends

Until now, brainCloud has relied solely upon Facebook for managing a user’s friend relationships. Apps that didn’t want to connect to Facebook were left to implement their own system (via Cloud Code and User Entities). It’s work-able, and some of brainCloud’s best apps have taken this approach – but we thought brainCloud should do more for you.

Release 2.22 adds a new built-in friends system that is directly manageable by the app – while also dynamically merged with network sources (i.e. Facebook and others in the future) if available. This enables apps without Facebook integration to still have friends, and leverage friend-dependent features such as Social Leaderboards.

You’ll find the new API methods in the Friend service, as well as a new Monitoring screen for viewing a list of a user’s friends.

Parse Integration

Last month we delivered our Parse import feature. This release we’ve added the ability to connect to Parse Servers from live brainCloud apps – facilitating the gradual migration of functionality and user data from Parse to brainCloud.

Configuring the Parse connection is simple – go to Design | Integrations | Manage Integrations, and enter your Parse App ID and Reset API Key. You can even enter a custom Parse Server URL if you’ve already migrated from Parse’s servers.

From there, there are two key APIs to integrate into your app:

• AuthenticateParse() – used to authenticate with brainCloud via a Parse identity.
• ParseRequest() – makes a web request from brainCloud from Parse

We’ve even built a small sample app to show how these APIs can work together to dynamically migrate your users to brainCloud.

CloudCode Editor Run Tab

We think our CloudCoders will like this one. We’ve added a new Run tab to the editor, so that you can do the full develop, run, debug cycle from within the Cloud Code editor dialog. No more saving and exiting to the API Explorer – only to have to go right back to editor once the system hits that pesky defect!

Now edit, test and debug your code all from the same editor!

Pro tip: The session and log for the Run tab are shared with the API Explorer. This allows you to set up custom scenarios for testing.

Portal Changes

The following changes have been made to the design portal:

• Design | Core App Info | Advanced Settings
  • Two new Compatibility Settings have been added that allow developers to preserve the old behaviour of the API where user entities and friends relationships are concerned (see API changes, below)
  • The settings default to ON for existing apps (so that nothing breaks), but OFF for new apps.
  • It is recommended that developers test their app, and move the settings to OFF if possible to ensure best compatibility with future updates to the platform going forward.
• Design | Integrations
  • New Parse integration options have been added to the Manage Integrations page
• Design | Cloud Code | API Explorer
  • You can now easily copy the json results from any API call by clicking on the ellipsis {…} button at the top of the response.
  • API Explorer calls are now added to the user’s request/response logs (can aid debugging in some scenarios)
• Design | Cloud Code | Script Editor
  • New Run tab added to allow easy testing and debugging of scripts
  • Click [Quick Authenticate] to create a session with default options
  • Edit the parameters, and then click [Run] to execute the script
  • Note – brainCloud only runs the saved version of a script. If a script has changed and has not yet been saved, it will show an asterix (“*”) in the Editor tab title.
• Monitoring | Global Monitoring | Recent logs
  • Clicking on a profile id in a log entry now brings you to the Log page of that user in User Monitoring
• Monitoring | User Monitoring, Select User, Search 
  • We’ve expanded the user search to support all of our identity types, including GameCenter ID (note, it’s the numeric ID that Apple provides), Twitter ID, Steam ID, Parse ID, and more.
• Monitoring | User Monitoring | Friends
  • We’ve added a new screen to display the friends that a user has. The screen offers a filterable list of both the user’s Facebook friends who also have your app, along with any local brainCloud friends that the app may have added.
• Monitoring | User Monitoring | Recent Logs
  • Added the script name to the Run Script entries
  • API Explorer initiated calls now appear in the logs
• Live Lock
  • Better keyboard support for unlocking apps. Clicking the banner now puts the cursor into the password field automatically, and password entry is confirmed by hitting the [Enter] key
  • More buttons are now *disabled* when an app is locked, instead of hidden. This is so that locked features remain discoverable.
• Server Status
  • You can now easily look up the status of brainCloud’s servers via our new ServerStatus page.  You’ll find the link by the version number in the Portal under the left-hand navigation bar – or just bookmark braincloud.statuspage.io.

API Changes

The following changes have been made to the brainCloud API:

• Authentication and ReadPlayerState
  • Authenticate() and ReadPlayerState() methods now return the users’ pictureUrl property if available
  • Authenticate() and ReadPlayerState() no longer return the user’s entities by default [see User Entities] section below
•  BrainCloudWrapper
  • BrainCloudWrapper wraps the authentication and identity portions of the API, simplifying authentication for your apps.
  • Because the wrapper isn’t a core component of the library (and apps aren’t required to use it), it was only available on a few platforms, and wasn’t really documented.
  • It is very useful however, and eliminates some common programming mistakes – so we are now providing it across all platforms (except AS3), and have documented it in its own section of the API documentation.
• Friends
  • The new friends management methods are: AddFriends() and RemoveFriends(). They are plural because they allow you to add multiple friends in a batch.
  • A new method, FindPlayerByUniversalId() has been added to facilitate looking up potential friends
• Matchmaking
  • New DisableMatchmaking() api method has been added to all clients
• Parse Integration
  • You can now authenticate brainCloud users via the AuthenticateParse() method. Pro tip: Once the brainCloud account has been created, you can attach a brainCloud identity (i.e. Universal or Email) via the AttachIdentity() methods.
  • Once authenticated, you can make calls to Parse to retrieve data via the Cloud Code ParseRequest() method.
  • You configure parse configuration from the Design | Integrations | Manage Integrations screen.
• User Entities
  • Behaviour Change: UserEntities are no longer returned during Authenticate() and ReadPlayerState() calls by default. This is because some apps are actually storing thousands of entities per user, not all of which should be retrieved at once.
  • Apps can preserve the legacy behaviour by enabling the “Return user entites during authenticate and player state methods” flag in the Compatiblity section of the Design | Core App Info | Advanced Settings screen. This setting defaults to “on” for existing apps to preserve compatibility.
  • New GetList() and GetListCount() methods have been added. These methods allow for more complex queries of user entities.
  • GetSharedEntityForPlayerId() method added – previously you could only retrieve *all* shared entities in a list.

Miscellaneous Changes / Fixes

• Infrastructure updates
  • Improvements to Push Notifications architecture for increased performance and reliability
  • Upgraded our TLS libraries to use 1.1+ for improved security when connecting to our billing system.
• Removed methods – the following previously-deprecated methods have been removed from the 2.22 client libraries:
  • Removed ReadFriendsWithApplication() – use ListFriends() instead
  • Removed GetGlobalLeaderboard() – use GetGlobalLeaderboardPage() instead
  • Removed GetLeaderboard() – use GetSocialLeaderboard() instead
  • Removed RegisterPushNotificationDeviceToken with string device parameter – use version with Platform object instead
  • Removed ReadPlayerStatsSubset() with string parameter – use version that takes collection instead
  • Removed ReadAttributes() with string parameter – use version that takes collection instead
  • Removed ReadGlobalStatsSubset() with string parameter – use version that takes collection instead
  • Removed AwardAchievements() with string parameter – use version that takes collection instead
  • Removed UpdateSummaryFriendData() from BrainCloudFriend – use BrainCloudPlayerState version instead
  • Removed GetOneWayPlayers() and GetOneWayPlayersWithFilter() – use the FindPlayers() methods instead
• Javascript library
  • Added FileUpload capabilities to the Javascript libs – tutorial here
  • Added GenerateGUID() and GenerateNewAnonymousId() to the Javascript libs
• Unreal libs
  • Updated to support Unreal 4.11
• Miscellaneous changes, fixes and performance improvements, including:
  • Manually Triggering the forgot password feature for users or other team member’s now bcc’s the Team Member that requested it.
  • ReadFriendPlayerState() method was returning too much information – fixed
  • AB Test ID behaviour has been fixed. The value now remains constant after creation, as intended.
  • Should you want to change the AB Test ID value for testing purposes, however, you now can – via the User Summary screen. Just click the Tester button first.
  • The Global Entities screen has been enhanced to allow you to scroll through an unlimited number of entities
• Documentation
  • Stats grammar documentation added to the new site
  • C++ examples to the new site
  • BrainCloudWrapper section added to the new site

Okay, this one got away from us a little bit. The release is absolutely chock-full of new features – hopefully there is something for everyone!

Release Highlights

Team Member Roles

brainCloud now supports assigning permissions to Team Members on an app-by-app basis. The roles available are pre-defined (we don’t offer custom roles yet), but we’ve taken considerable care in defining a flexible set of roles based on customer feedback. And of course, you can combine roles to meet your needs.

Roles are assigned via the new Administration | Permissions page, which is accessible by Team Administrators. You can view the individual privileges that make up each role via the Roles tab of the page.

Live Lock

While we were implementing our permissions system, we decided to go one step further, and implement an extra level of protection for Live apps. The result is our new Live Lock feature, which ensures that you don’t inadvertently edit the configuration of your live app, even if you have the privileges to do so.

Our new “App is Live” banner will display on the portal pages for live apps, and will prevent the app from being modified without the user first unlocking it. Once unlocked, the banner turns yellow as a warning to be careful. Apps remain unlocked for the duration of your session – so it won’t unnecessarily affect your workflow.

Parse Import

As you might expect, brainCloud has seen an uptick in new sign-ups due to the Parse shutdown. We’ve received great feedback from our new arrivals, who find that brainCloud not only matches Parse’s featureset, but truly offers a whole lot more.

In an effort to be extra welcoming, we are pleased to roll-out Phase 1 of brainCloud’s Parse Migration support – which allows for easy importing of Parse data into our Cloud Data system (as Global Entities). This facility is especially useful for teams that had Parse apps in development, and want to quickly import their data and keep moving forward with a brainCloud-based implementation.

This is just the first step of our plan to assist customers migrate their apps from Parse. Stay tuned as we add additional features in the coming weeks, and be sure to fill in our Parse Migration Survey to ensure that your requirements are heard.

New <Beta> API Reference

New, faster, more searchable API documentation? Don’t mind if we do!

The new system is in beta, and the examples focus primarily on C# for now – but we think it’s already better than the old reference documentation – so we’re releasing it early. Going forward, our overview and tutorials will remain under the Docs header, with service and method references in the new system under API.

Let us know what you think! Check out the new docs here!

Swift and Objective-C CocoaPods

We’ve totally refactored our Apple libraries to work better with Swift and Objective-C, and repackaged them using CocoaPods to make them easier to integrate into your projects.

There are two CocoaPod libraries available:

• BrainCloud – for Objective-C and Swift projects
• BrainCloudCpp – for C++ projects

These libraries support iOS, OS X and tvOS.

You can find more information on using CocoaPods in your Xcode project in their Guides section.

Portal Changes

The following changes have been made to the Design Portal:

• (New) Administration | Permissions screen – used to set per-app permissions for your Team Members. Only accessible by Team Administrators.
• (New) Live Lock banner – tells you whether you app is live, and allows you to unlock it for editing.
• (New) Parse Import – available from the Global Monitoring | Global Entity screen.
• (Improved) User Monitor – we now display the User’s Profile picture if they have attached their Facebook identity.
• (Improved) Select Team screen – we’ve updated the look of the Select Team screen that appears immediately upon login. And as a bonus, it automatically remembers the last team that you logged into – allowing you to quickly skip past by clicking the [Continue] button
• (Improved) Edit Profile dialog – you can view your app access permissions by choosing Edit Profile from the sign out menu drop-down.
• (Improved) Log Viewer – you can now click through from the Global Logs to the User Logs by clicking on the profile id in any log entry.
• (Improved) Analytics Charts – improved and standardized the colors used in the charts on our Analytics page.

API Changes

There have been significant changes to the error handling and communication subsystems in several of the libraries. We recommend that you test well before updating clients in the field.

• Network Error Message Caching
  • This feature allows you to cache in-transit messages to the brainCloud server when a network error occurs.
  • More details can be found here
• Global Error callback
  • brainCloud now allows you to register a Global Error callback method which is called anytime an error is encountered.
• Authentication methods returning 202 error now go to error callback.
  • This only applies to C++ and Unreal libraries. If you’d prefer the old behaviour, you call BrainCloudClient.setErrorCallbackOn202Status(false)
• New Matchmaking API call
  • FindPlayerWithFilterAndAttributes() method added – allows the system to narrow the list of candidates before sending each candidate to the players custom filter. Useful for when the population of users you are looking for is a very small portion of the overall population.
• Improved Web Service APIs
  • We’ve added support for POST operations with external web services
  • We’ve also simplified the API so that you don’t have to repeat the URL being used (since you’re already declaring the URL as part of the external service configuration)
• Push Notifications
  • New server-to-server method, SendNormalizedToSegments(), for sending push notifications with custom parameters
  • New server-to-server method for returning a list of segments
• Leaderboards
  • Social Leaderboard calls now properly support LOWER_IS_BETTER leaderboards by returning the results in ascending order
• Miscellaneous
  • New method for looking up a user’s credentials given their profileId – GetExternalIdForProfileId()
  • UpdateContactEmail() method added which allows you to update the user’s email address (used for informational purposes, not authentication, which is controlled via the EmailIdentity)
  • Added API for generating anonymous id (GUID) to the Android / Java libs

Miscellaneous Changes / Fixes

• New Apple SDKs!  Our new iOS / Mac OS X / Apple TV SDKs have been revamped with better Objective-C and Swift support – and are now packaged using CocoaPods for easy addition to your projects!
• Revamped the Android Getting Started documentation
• Roku has been added as a supported platform
• New Marmalade C++ Client SDK
• Improved searching for users in User Monitoring – search now looks for a sub-string of the text entered
• Improved user logs performance
• Miscellaneous fixes and performance improvements

On Thursday, Facebook dropped a bomb. They announced that they were shutting down Parse, the Mobile Backend-as-a-Service (MBaaS) platform that they acquired in 2013.

Parse is one of brainCloud’s competitors, and arguably the biggest and most established player in the BaaS industry. Even so, brainCloud doesn’t run up against them that much because we have a richer, more specialized featureset that works better for our customer base.

In the wake of this event, it is inevitable that people are asking “What happened?” and “How can we trust any BaaS to build our business upon”. To that end, I thought I’d put together a few thoughts.

Why was Parse shut down?

The internet is a-buzz with comments that the business must have been failing.

I don’t buy that. The business case for the Backend-as-a-Service market is very strong, and Parse had a good product for the space they were aimed at. By all accounts, they had plenty of customers and an overall strong business. So why close it?

The answer is that Parse no longer aligned with the goals of it’s parent company, Facebook.

At the time that Parse was acquired, Facebook was floundering. They had recently IPO’d, but hadn’t figured out their mobile and advertising strategy. The stock was down, revenues were down – and they made a series of acquisitions hoping to strengthen and diversify their portfolio. Parse, well positioned as a platform for enabling mobile apps, seemed like a smart play to help them build up their mobile presence. And I’d say it was.

But now, almost three years later, things have changed. Facebook has totally turned it’s ship around. It is now a juggernaught in mobile, has advertising sales through the roof, and is more focused than ever on building out its core product. In managing everything it is doing, Facebook needs to continually ask itself: “Is <x> strategic to our overall success?”

And I think that’s where Parse failed the test. Parse’s business was probably $50-$100M per year. Healthy, for sure – heck, we’d take it! But that’s just a drop in the bucket to Facebook (less than 1% of revenue!), which will net close to $20B this year. And yet, I’ll bet that division had some of Facebook’s best engineers!

And that’s what it comes down to – Facebook said as much in their blog post. They are going to “focus their resources elsewhere.” I don’t think this is the normal generic excuse that a company makes when they announce bad news – in this case, I believe that it is very literally what they are doing.

Who can you trust?

In the wake of the Parse shut-down, a lot of people will be wondering how they can put their trust in any Backend-as-a-Service. After all, a ton of people probably chose Parse specifically because it was run by Facebook – a huge, incredibly successful organization, that was guaranteed to be around for years to come.

Here is my suggestion on the evaluation criteria to consider:

1. Feature Set – always start with the features – there is no point in going for a solution that doesn’t meet your needs.
2. Organization – consider the organization that develops it. Are they a long-standing, established business, that has earned a solid reputation in the marketplace?
3. Funding – how is the company/product funded? Beware of purely VC-funded companies. A lot of BaaS vendors are early stage VC-funded – this makes for splashy million dollar announcements and marketing materials, but the funding comes with strings attached, in terms of “You must succeed by <x> or you will be shut down.”
4. Business Model – does the business model make sense? Is it easy to understand how the business would make money for the organization? If not, be wary – a “too good to be true”business model is often a sign of a last-ditch “hail mary” throw for success.
5. Alignment – Does the product align with the strategic goals of the parent organization. No matter how good the product, Facebook has just proven that you are in danger if a clear alignment isn’t there.

Given this critera, how does brainCloud rate?

1. Feature Set – we pride ourselves on our features, and the rapid pace at which they are evolving. With brainCloud (especially in comparison to a lower-level offering like Parse), you spend less time building features and more time using them. And we match each new feature with a visual tool for configuring and managing it.brainCloud goes over-and-above the classic BaaS capabilities with support for Gamification (xp, milestones, quests, achievements, leaderboards, etc.), Segmented Push Notifications, Scheduled Cloud Code, Auto Promotions, Mobile Multiplayer, Shared User Accounts, External Authentication, Server-to-Server APIs, a dynamic DataStream Architecture, and much much more.
2. Organization – brainCloud is built by bitHeads, a 20-year old technology software developer based in Ottawa, Canada, in conjunction with playBrains, our game development subsidiary. bitHeads has earned a reputation as one of the top software development companies in Canada, and through the years has built award-winning products for Microsoft, Sony, Blackberry, Canada Post, Samsung, E*Trade, Nortel, Mitel, and hundreds of others.
3. Funding – brainCloud is privately funded by bitHeads, its parent organization, with some assistance from various Canadian government programs. We are privately controlled, and thus no ultimatums.We started building brainCloud over four years ago, well before the term BaaS or MBaaS was a thing. We saw the value and opportunity in this market back then, and are determined to build the best product for it.
4. Business Model – we don’t give brainCloud away, but we do work to keep the cost of the service as low as possible. brainCloud is free for development (maximum 100 dau), but you pay starting at $30 / month once you go live. This minimal charge ensures that every brainCloud customer is pulling their weight and paying their share of the costs for the service. This allows us to offer lower prices than our competitors, while at the same time ensuring that bitHeads can operate brainCloud indefinitely.
   
   Contrast that with the models of some of our competitors, and ask yourselves how they can possibly be successful in the mid-to-long term? They have to charge their paid users more, and are basically betting that they will have enough high-volume customers to pay for the inevitably huge number of low-volume customers (that they subsidize for free). And some models are even crazier! These are the sorts of bets that you make when you are desperate for your next round of VC funding, or looking to be bought.
5. Alignment – brainCloud arose because bitHeads was constantly building custom backend solutions for our customers. And we were building them over-and-over again, with largely the same features. For online casinos. Retail networks. Telecommunications. Mobile/Social games. For twenty years.Four years ago, we finally said, wait – what if we did this once, and productized it, so that we (nor anyone else) has to keep re-inventing the wheel? And thus brainCloud was born. It started as a small, separate team working within the company to build the core server system. We released the first apps on the platform almost three years ago – before we had a design portal with which to design and manage things (configuration was CSV and JSON back then).Today the team consists of twenty-ish people within the larger bitHeads/playBrains organization, together with the support teams to make that work. All services teams at bitHeads are aligned to delivering products and services around brainCloud. The custom apps and games that we build today are built upon brainCloud – it’s our competitive advantage. And we continue to productize and evolve the platform based on the feedback of our great community of developers.There’s no fear of alignment here – bitHeads is brainCloud.

And there you have it – my take on Parse, and how bitHeads and brainCloud rate as a Backend-as-a-Server that you can trust. To our brainCloud customers today, thanks a bunch – rest assured, we are in this for the long haul.

And if this is your first exposure to brainCloud, please sign up and take a look for free. If you take a good look at our features and tools, we think you’ll realize the power of the system we’ve developed, and the passion of the folks building it.

Oh – and if you are looking to move from Parse, please check out this survey. Filling it out will help us to prioritize the tools and support processes that we’re developing to assist Parse migration.

Happy coding folks!

Paul.

(PS – And for all you Parse-based folks looking to move, feel free to reach out. Our services teams would be happy to help you move over to our platform!)

We hope the holidays were good to everyone. The brainCloud team took a few days to relax and regroup with family, and now we’re back at it. Release 2.20.0 delivers some key customer-requested features, and sets the stage for a bunch more.

Without further ado, here’s what we’ve got.

Release Highlights

• Multi-team Accounts – brainCloud now allows your Team Member (i.e. Developer) account to be associated with multiple Teams (i.e. Companies). This is a much-requested feature, and will be especially useful to developers working on apps for multiple client companies, those with developer-publisher relationships, etc. You will immediately notice the new Team Selection dialog that displays after logging into the portal.

• Team Administrators – As part of the Multi-team feature, we added the concept of Team Administrators. Now, only team administrators can perform team-level operations like Manage Users, Manage and Publish Apps, Edit company billing info, etc. Note – this does not affect the access of data within individual apps – all team members still have full privileges. This is the first step towards the Role Security feature that is currently in development. Note that all existing users have Team Administrator access by default – you’ll want to go to Admin | Team Members and adjust this permission accordingly.
• User Files – this release brings support for storage of User Files – that is, binary files that are associated with individual apps (as opposed to our Custom Files, which are global). User Files can be organized by path (directories), can have shareable URLs, and can be up to 20 MB in size. The C++, C# (.Net/Unity), and Objective-C libraries have all been updated to support our new File APIs – which include support for uploading, listing, retrieving and managing files. Support for the other libraries will follow soon. Note – User Files are not yet visible in the Design Portal – that feature will be in an upcoming release.
  
• New Segment Criteria – we’ve added support for two new pieces of Segment Criteria: timezones and AB Test ID. Timezones are as you’d expect – the timezone that a user is in. The AB Test ID is a random number between 0 and 99 that gets assigned to every new user when they are created. If, for example, you’d like to try a sales promotion with half of your user base (to see if it effects their monetization) you could define a segment for AB Seed values of 0-49, and then associate the Promotion and any push notifications with that Segment. Note that AB Test IDs are also included in the Identity data that gets passed through our DataStream Architecture – so you can hookup any number of back-end tools to analyze the behavioural results of such a test.

Portal Changes

• Team is the New Company – given the new Multi-Team feature, the portal is now largely using the word “team” in place of “company”, which will now be used primarily for billing purposes.
• Team Selection – you’ll immediately notice the new Team Selection page that displays immediately upon logging into the portal. Just choose your team and you’re into the same portal interface you’re used to — you are only ever logged into a single team at a time. But never fear, switching active teams is quick and easy – just click on the team name from the right-hand-corner menu.

• Team Members Screen – has been revamped to show whether a member has Team Administrator privilege, and who how many apps they have access to. Currently all users have access to all apps, but that will change when we add our Role Security feature in the near future. Also note that you no longer Delete team members, you Remove them from your team. The user’s TeamMember account will continue to exist – allowing it to still be used to log into other teams.
• Edit Team Member – Users may now change their e-mail address, as well as their password. Team Members (even Team Administrators) may no longer change another Team Member’s password.
• Reporting | API Usage – File Storage stats are now reported in the section with File Transfer stats. Note – we don’t currently extrapolate the amount of storage that we think will be used by the end of the month.
• Timezones – we’ve expanded the list of options in the Timezone selector of the portal. You are welcome Newfoundland! 🙂

API  Changes / Additions

• New User Files API – A robust API for uploading, listing, and managing files. Supports files up to 20MB in size. See the BrainCloudFile api docs page.
• Update Picture URL – now that you can upload files, it makes sense that users can have custom profile pics. So just upload the file (with a shareable URL), and then set the picture URL accordingly.
• Session expiry – the Client Libraries have been enhanced to better handle session errors (session expired, invalidated due to login, etc.). This includes fixing heartbeats so that they no longer get sent if the session is gone.
• Client libraries have been updated for this release. As always, if your app is currently live, we recommend that you test thoroughly before releasing on the updated libraries.

Miscellaneous Changes / Fixes

• New, clearer error message returned when apps “in development” have reached their daily active user limit.
• System now returns better error information if Google Push support has not been properly configured.
• Additional data integrity checks when deleting dependent items in the portal – i.e. deleting an Achivement that is referred to by an XP Level, etc.
• Apple and Android device tokens (for push notifications) are now deleted if they are reported as invalid by Apple and/or Google’s servers.
• Miscellaneour fixes and performance improvements

Firstly, a reminder that we are on reduced support availability over the holidays while our team spends some well-earned time with their families (Dec 24th, 2015 – Jan 4th, 2016).  The servers of course will still be fully monitored, and we’re definitely still available to respond to emergencies.

This being our holiday release, we thought we’d try to finish off the year by focusing on a few more customer requests. There’s something in here for everyone!

Release Highlights

Key features of this release include:

• Profanity Filter API + WebPurify Integration – we’ve had several requests from developers to support profanity filtering in the platform. Although simple enough in concept, profanity filtering gets pretty complicated when you start taking into account multiple languages, custom whitelists and blacklists, identifying vs. replacing profane strings, etc. We’ve addressed this in two parts – we’ve added a new abstract Profanity Filter API to brainCloud, and partnered with the good folks at WebPurify to allow you to easily add profanity filtering to your apps.
• User Export [Beta] – we’ve always said that brainCloud’s data is your data – and we happily provide custom exports when requested. That said, it’s a lot more efficient to provide a way for you to export your user data yourself – which is of course what our new User Export feature is for. So, whether you are looking to do some additional analytics analysis, or maybe import your user e-mails into a mailing list platform – brainCloud now supports exporting the data you need in both .CSV and .JSON formats.
• Idle timeouts – we’ve refactored how the Design Portal handles user timeouts. To start, we’ve extended the timeout to 1 hour (from 20 minutes) – but we’ve also added a dialog to warn you that the session is about to timeout, and to definitely tell you once you have timed out. We’re much happier with the new system. Let us know what you think.

Portal Changes

Changes to the portal:

• WebPurify Integration settings – can be found in Design | Integrations | Manage Integrations. You simply enter the WebPurify API key, and choose what languages to filter on. Note that you can choose to automatically filter the user’s name field. If selected, brainCloud will automatically filter all calls to UpdatePlayerName() – and raise an exception if the name contains profanity. You can get a WebPurify account for as little as $15 / month at www.webpurify.com. Note that for brainCloud billing purposes, calls to WebPurify are counted as an external web service API call.
• Refresh button in Custom Files – we now cache the list of custom files, so we no longer have to access the file system to retrieve the directory.  This cache is updated each time a new file is added or deleted – but should you have reason to think that it’s out-of-date, just hit the [Refresh File List] button on the Design | Custom Config |  Files page.
• Export User Data – available under Reporting.  You can specify some filter criteria for which users to export, as well as select what types of data to include. We support both .CSV and .JSON file formats. Note – there are more data options associated with the JSON format (since it’s more flexible).
• Web Idle Timer – we’ve refactored how the web portal handles user timeouts. We’ve extended them timeouts, added better activity tracking, and improved the communication of when the session has expired. Let us know what you think.

API Changes / Additions

Changes and additions to the API:

• Profanity Filter API – There are 3 key methods for the Profanity Filter API – ProfanityCheck() returns true if foul language is found; ProfanityReplaceText() will actually replace bad words with a substitution character that you provide; and ProfanityIdentifyBadWords() returns a list of the bad words found (mostly useful for debugging). Remember, you need to set up a WebPurify() account to enable these APIs.
• Player State JSON enhancements – we’ve enhanced our Authentication and ReadPlayerState() calls to return additional user data – basically all the info that is displayed in the User Summary page of User Monitoring. So in addition to the slew of data that was already being returned, you now get emailAddress, createdAt, lastLogin, previousLogin, language, timezoneOffset, amountSpent (in cents) and refundCount.  Note that amountSpent refers to the reference price that you specify in the IAP entries, and is not a precise estimate of what a user paid, since it doesn’t take into account currency exchanges, the platform’s take, etc.

Miscellaneous Changes / Fixes

Additional improvements to this release:

• Big performance boost to GetFileList() and GetUpdatedFiles().  We now cache the data instead of reading from the file system each time – so performance is now approximately 3 times faster!
• brainCloud is now available directly from the Unity Asset Store!  (The brainCloud Bombers and brainCloud Space Shooter example games are there too!)  Feel free to drop by and give us a review! 
• All client libraries have been updated with the latest APIs
• Misc defect and performance fixes

Release Highlights

This release marks the debut appearance of a key roadmap item for brainCloud – our DataStream Architecture. Currently in beta, the concept behind DataStream is to enable a meaningful flow of data and events from your apps to value-added tools. And to do this as painlessly as possible – i.e. little to no client code – leveraging the data and server-side interactions that brainCloud already knows about.

DataStream is being implemented with the concept of extensible channels – which will be used to enable a great variety of integrations.

Our first channel is a doozy – Segment.com.  Connecting to Segment instantly gives us over 100 service integrations – including MixPanel, Google Analytics, Heap, Treasure Data and more.  There’s even support for generic webhooks.

Trying out DataStream is very simple. To do so:

• Register for a free Segment Developer account, and create a project to use
• Go to the brainCloud portal, and enter the Segment project information in the new Design | Integration section
• Optionally connect another service to Segment – like MixPanel, Google Analytics, etc.

That’s it – once you do this brainCloud will immediately begin sending the following events:

• Identify – contains base information (like profile id, name, e-mail etc) about a user interacting with Segment. Sent before we send any other events associated with that user.
• Login – triggered when a user logs in (via the Authenticate API)
• Register – triggered when a new user account is created (via the Authenticate API)
• RecordedScore – triggered when a user posts a score to a leaderboard
• LevelledUp – triggered when a user gains an experience level
• AwardedAchievement – triggered when a user is awarded an achievement
• AwardedMilestone – triggered when a user is awarded a milestone
• AwardedQuest – triggered when a user is awarded a quest
• WasSentNotification – triggered when a remote push notification was sent to the user
• CompletedOrder – triggered when a user completes an IAP purchase

In addition, your app can send custom events of it’s own (from the client or via Cloud Code).  There is a new DataStream service with three methods to support this:

• CustomTrackEvent – used to track custom user behaviours throughout your app – for example, a puzzle game might record “RoundStarted” with information on what round the user is playing, and what boosts they’ve selected for the round, together with a “RoundCompleted” event that summarizes the results. CustomTrackEvent() takes as parameters the name of the event, and set of custom key+value pairs for attributes.
• CustomScreenEvent – used to record that the user i
• CustomPageEvent – same as the above, but oriented toward web pages

Billing note – in addition to the regular tracking of API calls, each event sent out on a DataStream Channel counts as an additional API count.

We are very excited about the new possibilities that DataStream opens up for brainCloud apps – give it a try and send us feedback!

Additional Highlights

Additional features of this release include:

• Push Notification refactoring– we’ve refactored our push notification support to make it more efficient and reliable. Although none of the existing Client APIs have changed, you’ll notice:
  • Device tokens now expire after a settable period of time. This helps to keep all tokens recent and reliable, and also to ensure you’re not wasting API counts sending notifications to long-gone users.
  • Invalid Device Tokens (flagged by iOS and Android servers) are now automatically removed from profiles
  • Devices will no longer receive notifications from multiple users – if your app allows users to log in and out, it was possible to end up with multiple users with the same hardware device token. This is no longer possible – a token can now be associated with one and only one user.  That said, if you allow users to log out, you will call the new RemoveDeviceToken() call just before the logout, to ensure that the user’s profile no longer refers to the device.
  • There is a new Delete All Tokens menu option in the Design | Notifications | Settings screen, which allows you to clear all tokens of specific type (iOS, Android, etc.).  This is useful for when you switch between Sandbox and Production certificates on iOS, and you want to delete all the old tokens.
• Redemption Code Improvements – we’ve made some changes under the covers to make our implementation more efficient at high volumes of codes. The biggest change is that scan codes are no longer local to a code type, but are now global across all code types for an app id. This saves us a bunch of index space, and in practice better matches the datasets of our customers anyway.
• API Pre- and Post- Hook Improvements – we’ve improved the capabilities of API Pre- and Post- Hooks. As you may or may not know, Pre- and Post- hooks allow you to change the behaviours of brainCloud’s API calls themselves – inserting code to be run before and/or after the API call completes. Pre-hooks can now have the ability to change the parameters being sent into the API call. And Post-hooks can now access the original parameters sent to the API (providing useful context).
• Updated Unreal plug-in – Finally, we’ve made improvements to our Online Subsystem portion of our Unreal 4 libraries.

Portal Changes

Changes to the portal:

• Moved Email Authentication section – we’ve moved the Email Authentication settings from the Advanced Settings page to their own page under Design | Authentication.
• New Integrations section – we’ve added a new Design | Integrations section, which currently contains only the Segment integration from our new DataStream feature
• Revamped Notification Settings – the settings dialogs have been revamped to be clearer, and we’ve added an expiry drop-down.  You can also choose to delete existing iOS or Android device tokens.
• Get Test Redemption Codes – you can now search your datafill for a redemption code to use during testing.  You the Type and State of the code, and brainCloud will display the first one that matches. Available from the Global Monitoring | Redemption Codes screen.
• Reset Universal Authentication passwords – you may now reset the password of Universal Authentication users via the design portal. Simply choose the Set Password option in the new action menu displayed in the Credentials section of the User Monitoring | User Summary page.
• Managing Device Tokens – device tokens are used to push notifications to iOS and Android devices. The device tokens section of the User Summary page has been updated to display when the token was last registered (note – brainCloud only applies the first registration within a 24-hour period), and has a new [Reset Device Tokens] button to delete all the existing tokens for this user.

API Changes / Additions

Changes and additions to the API:

• Push Notification Tokens – two methods have been added to allow client apps greater control over the device tokens associated with user accounts.  DeregisterPushNotificationDeviceToken() will delete the associated device token from the user profile (), and DeregisterAllPushNotificationDeviceTokens() will delete all tokens associated with the user… (useful if you app contains a global toggle to disable all notifications to the user – as it will delete all notification tokens for this user, not just the token associated with the current device).
• DataStream Events – as mentioned in the highlights section above, new API calls have been added for custom DataStream events

Miscellaneous Changes / Fixes

Additional improvements to this release:

• Adjusted S2S Explorer so that it returns results in alignment with the API Explorer
• Added GlobalApp proxy to Cloud Code bridge
• Refactored C++ Comms to push common code into a single class
• Fixes to API Hook error handling – more descriptive error messages
• Miscellaneous fixes and performance improvements

   

This post is the first of our new series on best practices to observe before launching your app.

It’s an exciting feeling… Features are complete. Beta feedback incorporated. Final bits of polish applied. You are ready to launch.

Or are you? Are you sure that you have… Tested for every usage scenario? Every race condition? On each of thousands of device variations? Under unpredictable network conditions? Accounted for changing performance characteristics as your user base ramps?

Luckily you are using brainCloud – so you know your servers will handle the loads. But what about your client app? Your dev team is prepared to react and fix issues quickly – but how will you ensure that important updates make it to your users quickly?

Sure – the app stores support automatic software updates – but even so, it can take 3 weeks before the majority of your user base is using the new version of your app. That’s far too long if your app is crashing, corrupting data, and/or generally frustrating your users. In those 3 weeks your app’s ratings will take a huge hit.

This is why it is essential to implement Version Enforcement before you go live.

The good news is that brainCloud makes it easy.

Version Enforcement

brainCloud has built-in support for enforcing minimum client versions.  During authentication, in addition to transmitting information about the user that is logging in, the brainCloud client library sends two key pieces of information:

• platform – the type of device that the user is logging in from
• gameVersion – the version of the client game or app

These parameters aren’t just informational – brainCloud’s Version Enforcement feature allows you to ensure that only users of a specified version and above can log into your application. This forces out-of-date users to upgrade their clients before proceeding.

Version Enforcement is configured via the brainCloud Portal, and works in collaboration with integration code that you add to your app.

Above – the Design | Core App Info | Platforms screen

Note –  you can specify this minimum version on a per-platform basis, allowing you to accommodate staggered release schedules, different app approval processes, etc.

Integrating Version Enforcement

Integrating Version Enforcement into your app is very simple.

Follow these steps:

1. Set the app version in your client app. In most of the brainCloud client libraries, this is done via the BrainCloudClient.Initialize() function. In Unity, you can use the brainCloud Settings dialog.
   
   In either case, the version should be a string of format of “X.X” or “X.X.X” – for example, “1.0.0”.
2. Go to Design | Core App Info | Platforms, and temporarily set the minimum app version to something higher than your current app version.
3. Enhance the Authentication error handling of your app to catch the out-of-date error response – and display an appropriate message to the user. Ideally you should redirect the user to your apps store page so that he/she can trigger the update immediately. The brainCloud portal allows you to datafill the upgrade URL along with the minimum version.
   
   
4. Test to ensure that it works!

That’s it. Once this is in place, you will rest easier knowing that if (when) your users find problems in the field, that you’ll be able to push fixes to them in no time!