Quip Goes Global With Parse Push

QuipIn many workplaces, collaborative word processing is a key activity on a day-to-day basis. However, the tools we use to write collaboratively have remained relatively unchanged in the past thirty years. With Quip, this experience has become much more dynamic, and much more accessible. Quip is a mobile, collaborative word processor that works across smartphones, tablets, and the desktop.

Started in 2012 by Kevin Gibbs and Bret Taylor, the former Chief Technology Officer of Facebook and co-creator of Google Maps, Quip tackles a unique opportunity in high global demand. Having seen tremendous growth in mobile devices, Quip took to redefining the product experience for productivity apps for the era of smartphones and tablets. The Quip app works seamlessly across desktop, iOS, and Android.

Quip turned to Parse Push to handle its push notifications on Android. This was a very strategic move, given that Android has such a large, rapidly growing user base—particularly outside of the U.S. However, much of this growth has been taking place in places like China, where the Play Store and Google Services are not present. Using Parse Push, Quip was able to reach those users without having to reproduce Google’s infrastructure, and now are present on virtually all Android devices around the world. China is Quip’s third biggest country, and growing quickly. This has also proved useful for users in Russia, and on devices like the Kindle Fire in the U.S. According to Bret Taylor, CEO of Quip:

Our favorite aspects of using Parse were the great APIs and great documentation. Thanks to using Parse for notifications on Android devices without Google services, we have a much bigger presence in China.

Head on over to Quip’s desktop product to find out more, or download now straight from the App Store or on Google Play.

Nancy Xiao
September 11, 2014

Announcing Parse Config

Parse Config

We at the Parse London office are happy to announce Parse Config: the simplest way to store your app’s parameters for updating on the fly. Keeping configurations out of your app’s binary means config changes do not require a fresh app release.

Say you have a background image in your game, and you would like to change it on the fly during the Christmas season. All you would have to do is swap the image on the Parse Config dashboard. Or, for example, you have this shiny new feature that you haven’t released yet, and would like to have a few people dogfood it. You could trickle out these by specifying a “dogfooding” array of user IDs.

Parse Config Dashboard

In the past, some Parse developers have built their own configuration management using a Parse Object, and then modified its columns in the Data Browser. This approach required manually caching this object on mobile devices to avoid waiting for a query to run on every app restart. Parse is all about abstracting away common tasks so we wanted to build something for this use case.

Parse Config makes the experience of handling configuration much smoother than ever before. We updated our iOS, Android, JS, .NET and Unity SDKs to provide intuitive method calls to help sync configurations in the Parse Cloud. Our SDKs automatically cache the last-fetched configuration, so you don’t have to re-fetch it after an app restart.

Here is an example snippet of what the Parse Config API looks like. Alternatively, you can have a look at the Anywall source code, which has now been updated to use Parse Config.

[PFConfig getConfigInBackgroundWithBlock:^(PFConfig *config, NSError *error) {
  NSArray *distanceOptions = config[@"searchDistanceOptions"];
  if (!distanceOptions) {
    // No config for distance options - fallback to the default ones
    distanceOptions = @[ @250.0, @1000.0, @2000.0, @5000.0 ];
  }
  self.distanceOptions = distanceOptions;
  [self.tableView reloadData];
}];

Our simple yet flexible API gives you precise control over when to fetch a new configuration and when to use the last-known configuration.The PFConfig is an immutable dictionary that can be used to retrieve configuration parameters. Our SDKs automatically persist the last-known PFConfig instance, and can be retrieved with [PFConfig currentConfig] so you don’t have to worry about losing the last-known configuration if a user decides to close your app.

As you may expect, the fetching of the configuration from the server is an asynchronous call. While the fetch occurs in the background, you can keep using the last-held PFConfig instance, without worrying about it suddenly changing underneath you. After the fetch completes, you can decide to switch to the latest PFConfig anytime.

We are always looking to improve our products and would love to hear your feedback. Check out our guides, try it out and let us know what you think!


  
Karan Gajwani
September 8, 2014

Meety Makes File Sharing Easy With Parse

Meety

For businesses across the globe, file sharing has become a ubiquitous, of-the-minute tool that is constantly utilized in all kinds of work settings. Sensing an opportunity and reimagining the way files are shared, Japan’s NEOS Corporation has tackled file sharing with a fresh new take with the release of Meety. In Japan, email communication has been replaced with chat. Simultaneously, file sharing tools such as Dropbox and Evernote have drastically grown in usage. Thus, Meety sought to find a common ground between the two, developing a comprehensive chat application with file sharing features.

By using Meety’s integration with Dropbox, Google Drive, and Box, users can easily transfer files to each other—from music to movie files to PowerPoints, Word Docs, Excel spreadsheets, PDFs, and more. Files are stored and managed in every chat room, allowing for simple search functionality if a user needs to return to the file in the future.

For execution of the app, the Meety team at NEOS Corporation turned to Parse. NEOS Corporation has a wide array of resources, including investor backing from NTT Docomo, Sharp Corporation, and KDDI Corporation. Upon coming across Parse on an external blog, the team decided to give it a try. According to Meety’s software development manager:

By using Parse, we were able to launch the service without incurring large infrastructure costs. We saved about three crucial months in developing our app, which also brought down our development costs.

Meety is now available for download on the App Store, and is coming soon to the Google Play Store.

Nancy Xiao
September 6, 2014

The Dangerous World of Client Push

Push Notifications are one of the most effective ways for apps to increase user engagement and retention, notify customers of important information like sales and new products, or allow users communicate with each other. A messaging app, for example, could use push notifications to alert users to an incoming message from their friend in the app. But be careful, because the most obvious way to do this can expose you to a security risk.

One easy way to send push notifications to particular users from within an app is to send the pushes directly from the client code, for example by using PFPush on iOS. This is tempting, because you have all the information you need to send the push straight from within iOS, and the code to send the push is very simple. But as Bryan mentioned in his security series, clients can’t be trusted to send push notifications directly. Some nefarious hacker could modify the client code, changing the Objective-C or Java code to modify the push’s alert text, or to send pushes to people they shouldn’t be able to. The hacker could steal your app’s keys and send pushes himself without even using the app.

Sounds scary! Luckily, there is a simple way around this security vulnerability. In your app’s settings, under “Push Notifications”, there is a toggle that lets you disable “Client Push.” We highly recommend that you set this switch to “OFF,” and instead of sending the push notifications from the client, you should write Cloud Code functions that validate the user and the data to be pushed before sending them. Client Push is disabled by default, but this feature can still be useful for initial prototyping if you want to hook up push notifications without diving into Cloud Code as you iterate. But as you scale to a production app, you really should not have Client Push enabled.

Here is one example of how to port your pushes from the client into Cloud Code, starting with an example Client Push to a single user, stored in userObject. Here’s the old iOS code:

// WRONG WAY TO SEND PUSH - INSECURE!
PFQuery *pushQuery = [PFInstallation query];
[pushQuery whereKey:@"user" equalTo:userObject];
PFUser *user = [PFUser currentUser];
NSString *message = [NSString stringWithFormat:@"%@ says Hi!", user[@"name"]];

PFPush *push = [[PFPush alloc] init];
[push setQuery:pushQuery]; // Set our Installation query
[push setMessage:message];
[push sendPushInBackground];

And on Android:

// WRONG WAY TO SEND PUSH - INSECURE!
ParseQuery pushQuery = ParseInstallation.getQuery();
pushQuery.whereEqualTo("user", userObject);
ParseUser currentUser = ParseUser.getCurrentUser();
String message = currentUser.getString("name") + " says Hi!";

ParsePush push = new ParsePush();
push.setQuery(pushQuery); // Set our Installation query
push.setMessage(message);
push.sendInBackground();

To move these push calls to Cloud Code, first we would write a Cloud function, sendPushToUser, to verify that the user sending the push is allowed to send it and that the alert text is what it should be.

Parse.Cloud.define("sendPushToUser", function(request, response) {
  var senderUser = request.user;
  var recipientUserId = request.params.recipientId;
  var message = request.params.message;

  // Validate that the sender is allowed to send to the recipient.
  // For example each user has an array of objectIds of friends
  if (senderUser.get("friendIds").indexOf(recipientUserId) === -1) {
    response.error("The recipient is not the sender's friend, cannot send push.");
  }

  // Validate the message text.
  // For example make sure it is under 140 characters
  if (message.length > 140) {
  // Truncate and add a ...
    message = message.substring(0, 137) + "...";
  }

  // Send the push.
  // Find devices associated with the recipient user
  var recipientUser = new Parse.User();
  recipientUser.id = recipientUserId;
  var pushQuery = new Parse.Query(Parse.Installation);
  pushQuery.equalTo("user", recipientUser);
 
  // Send the push notification to results of the query
  Parse.Push.send({
    where: pushQuery,
    data: {
      alert: message
    }
  }).then(function() {
      response.success("Push was sent successfully.")
  }, function(error) {
      response.error("Push failed to send with error: " + error.message);
  });
});

 After you deploy this Cloud function, you can call the code from iOS like this:

[PFCloud callFunctionInBackground:@"sendPushToUser"
                   withParameters:@{@"recipientId": userObject.id, @"message": message}
                            block:^(NSString *success, NSError *error) {
  if (!error) {
     // Push sent successfully
  }
}];

And on Android:

HashMap<String, Object> params = new HashMap<String, Object>();
params.put("recipientId", userObject.getObjectId());
params.put("message", message);
ParseCloud.callFunctionInBackground("sendPushToUser", params, new FunctionCallback<String>() {
   void done(String success, ParseException e) {
       if (e == null) {
          // Push sent successfully
       }
   }
});

Now that you have moved the Push logic into Cloud Code, you can disable Client Push in your app settings, and spoil the hacker’s evil plan! We hope you learned how to use Cloud Code to secure your app’s push notifications, and that you will think twice before enabling Client Push for your app. As always, feel free to ask questions or let us know what you think on our new Help page.

Jamie
September 3, 2014

Open Sourcing the f8 Conference Apps

f8 App

 

As part of the f8 conference experience, we launched iOS and Android apps built entirely on Parse. The app enabled conference attendees to stay up-to-date with upcoming talks, get to know the speakers, and receive push notifications on talks they had marked as favorites.

This app grew out of the Parse Developer Day apps, and was thoroughly customized to match the f8 experience. Using Parse to build these apps was a fun experience, and it took one iOS and Android developer around two weeks to deliver the apps. Parse Data was used to store all the conference data and much of the User Interface (UI) customizations and assets, enabling quick iteration on design changes across iOS and Android. Even after the app was shipped, last minute updates were possible without touching code, simply by using the Data Browser. And, as talks were in session, the Push Console was used for ad hoc messaging to conference attendees–it’s vitally important to know when to pick up those T-shirts.

Today, we are releasing the source code for these apps so you can peek under the hood and see how they were built. The source code is available on GitHub. We hope they will serve as good guidance for how to build apps on Parse. We also hope others find them useful as a starting point for their own conference apps. We can’t wait to see what you do with them!

Christine Abernathy
August 28, 2014

Elex’s Age of Warring Empire Finds A Key Ally in Parse

Age of Warring Empire
As a long-standing player in China’s gaming and internet industries, Elex was founded in 2008 with a focus on developing mobile games. With partners including Baidu, Tencent, Alibaba, 7Road, and Giant Interactive, Elex has grown rapidly, rising to the forefront of game development in both Asian and Western markets.

The latest to Elex’s gaming family, Age of Warring Empire, has soared to the top of the charts, with over 20 million downloads to date. It has also charted as one of the top 30 grossing apps on Android for several consecutive months. Age of Warring Empire is supported by Parse Push, and the game is popular on both the Android and iOS platforms.

While strategy and war games are popular no matter the hemisphere, Elex decided to add yet another element of complexity to Age of Warring Empire. Beyond the basics of a strategy game, the team explored RPG elements and a top-notch player vs. player system to craft a unique experience found only in Age of Warring Empire.

These layers of complexity have attracted a strong user base, and in order to communicate directly with players, Age of Warring Empire uses Parse Push. These push notifications prove to be pivotal in gameplay, as notifications are sent when important events occur in a player’s Empire. Additionally, Age of Warring Empire is able to retain their players’ attention with a daily check-in award powered by a push notification. Competitions and flash sales are regular occurrences in the app as well, and key drivers of traffic and retention. Particular attention is paid to these events with the help of Parse Push.

As Evan Wan, producer of Age of Warring Empire, notes:

Parse is beneficial in its convenience, ease-of-use, and efficiency. Normally, it takes us more than 48 hours to acquire good data, and Parse requires less than half that time. Additionally, Parse provides us with statistical accuracy and a range of analyses.

As empires continue to flourish, and with it, the crucial importance of consistent player engagement, Age of Warring Empire can efficiently and directly communicate to players with the help of Parse Push. Age of Warring Empire is available on the App Store and the Google Play Store.

Nancy Xiao
August 22, 2014

Announcing Parse Analytics Integration with App Links

After the initial release of App Links support in the Bolts SDK, we’ve been looking for ways to enhance this support and easily provide actionable data to developers. With that in mind, we are pleased to announce Parse support for the App Links analytics hooks that are now available in the Bolts framework.

This Parse support takes App Links events and translates them into Parse Analytics custom events. You can then go to your app’s Analytics dashboard to view detailed App Links data–for example, how often an outbound App Links has been clicked or how many times your app has been opened from another App Links-enabled app.

This new open source, lightweight library is available for iOS and Android. You can simply download the jar or framework file and drop it into your project that’s already using the Bolts SDK. You can also download the source directly from GitHub. Then you can start measuring App Links events on Android as follows:

ParseAppLinksAnalytics.enableTracking(context);

To measure App Links events in iOS, add the following:

[PAAnalytics enableTracking];

You can then check out the custom events area in the Analytics dashboard and look for the following data related to your App Links usage:

AppLinksInbound: whenever traffic resulting from your App Links integration opens up your app.
AppLinksOutbound: whenever your app opens another app via an App Links integration.
AppLinksReturning: (iOS only) whenever an App Links integrated app returns the user back to your app after a previous outbound link.

Note that these events are only triggered if the App Links are constructed using the Bolts SDK.

For more information, please see the platform-specific README files on GitHub. We’d love to hear your feedback as you use the power of Parse Analytics to help fine tune your app’s integration with App Links and Bolts.

Christine Abernathy
August 21, 2014

Com2uS Uses Parse to Power their Top Downloaded for-Kakao Game “Heroes Classic”

Heroes ClassicWith over 100 million registered users on its Kakao Talk platform, Korea’s Kakao is quickly becoming one of the most direct and powerful channels possible for reaching potential game players. Kakao Talk is a hugely dominant player in the mobile communications market in Korea, and has begun extending its reach through gaming. Over 90 percent of mobile smartphones in Korea have the Kakao Talk app downloaded, allowing multiple game developers building on the platform to finally break through 10 million downloads.

The latest of these concepts, Heroes Classic for Kakao, is an game powered by Parse. Heroes Classic is the third output from the C-Lab’s mobile game development segment, and will be serviced by Com2uS in a collaboration between C-Lab and Com2uS. Com2uS will take care of overall game operations and promotion activities, which are already surging with over 100,000 downloads since its release on the Google Play Store on June 13th.

Heroes Classic is a role-playing game (RPG) where the main goal is to fight off as many monsters as possible within a given time. Its characters, however, are incredibly unique, falling under 8 different categories.

Heroes Classic was intentionally launched on Kakao, as it is the most popular SNS game platform. As the game approaches a global release, more of Facebook Platform’s products will be utilized to drive new user traffic. Before selecting Parse, the Heroes Classic team vetted multiple backend-as-a-service companies until Parse’s versatile features won them over. As the project leader of Heroes Classic puts it:

The main benefits of Parse for us was its scalability and Unity integration. Our favorite Parse features are the dialogue control to adjust request limits in addition to the native APIs for each programming language.

Heroes Classic is now available for download on the Google Play Store, and keep an eye out for more hits from Com2uS!

Nancy Xiao
August 21, 2014

Big Fish Games Releases A New Hit With Parse

Cascade

As the long-standing veteran of the casual games industry, Big Fish is its largest producer. With a growing catalog of 3,000 plus unique PC games, and 300 plus unique mobile games, Big Fish has distributed more than 2 billion games to date. Its latest game, Cascade, is a new free-to-play title that combines Match-3 functionality with a slot machine for an entirely new, patent-pending game mechanic. Currently, the game features over 140 handcrafted puzzles to be solved by players, with even more to come with regular content updates. Upon its release in July 2014, Cascade was instantly featured as one of the Best New Games of the App Store.

Initially created by developer Funkitron Inc., Big Fish Games is the publisher behind Cascade. With new lands, characters, obstacles, and gems being added each month, Big Fish has turned to Parse to power the game’s backend infrastructure. Cascade uses a combination of Parse Core and Cloud Code to sync game data across players’ devices, in addition to utilizing Parse Push to send remote notifications. Given the popularity of playing on both iPhone and iPad, it was crucial for Big Fish to find a solution that allowed for cross-device syncing. According to a producer in the Big Fish internal studio, SkyRocket Studios, Parse has proven to be a key piece to the Cascade puzzle:

Funkitron engineers found Parse’s APIs and SDKs to be stable, full-featured, and easy-to-use, with good documentation and lots of sample code. The ability to customize the service via custom, server-side code was a tremendously useful asset as well. Parse was easy to get started with, and I thought it had a good amount of depth to it in the longer run.

Don’t miss Cascade’s new spin on Match-3! Available for download on the App Store today.

Nancy Xiao
August 15, 2014

OKpanda Tackles Language Learning in Asia With Parse

OKpanda

Learning a new language is often a task full of tangled tongues and frustrating phrases. With the arrival of OKpanda, however, these roadblocks to learning English may be alleviated. Launched on iOS in December of 2013, OKpanda has taken a mobile-first approach towards creating a novel curricula combined with smart gaming to pioneer innovative ways to help users learn English.

It’s not the first time this team has taken on mobile development, or gaming. Cofounded by Nir Markus, the former CTO of PlayerDuel, a mobile platform that turned any mobile game into a social game with friends, Markus and his PlayerDuel team saw installations in over 30 million mobile devices in its first year. With this experience shaping the strategy behind OKpanda, the team has initially tackled the Japanese segment of the Asian English-learning market. Japan is one of the largest language learning markets in Asia, with approximately $5 billion currently spent on language services.

For many new English speakers, OKpanda’s research found that the number one requested skill by students is conversation practice. The app then simulates real life situations, and allows the user to practice their conversation skills. Users can participate in an exchange by listening and selecting the right answer, and vocal conversation is now in the works. With this emphasis on conversation practice, OKpanda saw over 260,000 downloads in Japan within the first 50 days of its launch without any marketing spend.

As OKpanda continues to grow rapidly in Japan, and across Asia, it has become more important than ever to be able to directly reach its users. Given the repetitive and consistent nature of language practice, engagement through Parse Push has allowed OKpanda to continually captivate the concentration of their users. Currently, OKpanda releases a new conversational situation 2 times a week, and users are notified of each release through Parse Push. The choice to use Parse Push is one that has been positively reinforced through OKpanda’s ability to immediately preview how the push notification will look on mobile. Additionally, according to its cofounder Nir Markus, the team has found that the use of Parse Push has accelerated the company’s efficiency on a variety of levels:

When starting a new startup, it’s very important to move fast, especially before you’ve reached a product-market fit. To move fast, there is no need to invent the wheel, and the possibility of using services like Parse to power your product is a huge time saver.

OKpanda delivers a unique language-learning experience that can be found now on the App Store. Mobile language learning finally has a taste of the best of both worlds–it’s now both fun and easy.

Nancy Xiao
August 8, 2014

Archives

Categories

RSS Feed Follow us Like us