The market for messaging apps is exploding. People are looking for alternatives to standard text messaging. Since the opportunity huge, why not create a messaging app? In this post, we’ll walk you through a bare bones WhatsApp clone (we’ll call it KiiChat) for Android that you can build with minimal effort by leveraging Kii Cloud. Good news is that with the rise of mobile backend services such as Kii.com, it has become very easy to create such applications very quickly 

Continue reading

Ebook: Get Users

A tremendous number of mobile sessions happen outside the United States, but many developers have a hard time spotting the right opportunities for their apps. Our latest Mobile App Developers’ Guide, How to Get More Users: A Global View of Success, is here to help. You’ll find straightforward tips for pinpointing where there’s interest in your app and prepping it for distribution.

The ebook is free, so enjoy! And if you like what you read, please pass it along to a friend.

Get your copy here >>

A record-breaking 24,000 game developers, business professionals and industry leaders attended this year’s Game Developers Conference (GDC) at the Moscone Center in San Francisco.

gdc14_1

In short, it was an amazing week. I was fortunate to spend time at the Kii kiosk inside the Unity booth and to take part in GDC’s countless opportunities to learn and get inspired. I heard exciting announcements, enjoyed fun-filled interactive spaces and attended festive parties and events. After speaking with tons of people at GDC, I firmly believe that Kii and other MBaaS vendors play an important role at game developer events and that game development can derive value from tools that enable a faster time-to-market. That’s precisely what Kii does and why it’s a must-have weapon in any developer’s arsenal.

gdc14_2

Here are some of the other insights I took away from the show:

  • Our partner, Unity, has established itself as a dominant influence among game developers. Unity offers exactly what today’s game developers want: a technically impeccable development environment with lots of room for customization and extension via plugins from partners, true multiplatform deployment support that embraces everything from consoles to web and from mobile to PC, and strong, positive brand awareness. As a result, Unity can boast something else developers love: a huge community of enthusiastic members. We’re glad to be working alongside Unity to offer the best C# based back-end service. gdc14_3
  • Indie game studios and independent developers are producing great work and are having a major impact on our industry. In fact, I met far more indie game developers at GDC than developers working for the big guys. With lower barriers to entry, it’s never been more achievable – and had more potential reward – to create a top-of-the-chart mobile game as a small game studio. I suppose this is good for everyone, as bad games get eliminated by natural selection. Let’s keep them coming!
  • Casual retro style games are definitely a trend and simple graphics are not a blocker to conquer the player’s minds. You could see these kinds of games all over GDC. gdc14_8
  • Alternative peripherals are emerging as a critical part of the next generation of gaming interaction. Demos for Leap, Oculus Rift (just bought by Facebook) and Playstation were fully booked, and it wasn’t unusual at GDC to find yourself with a strange peripheral like the Playstation VR helmet attached to your body while gaming. Smart watches, on the other hand, were almost nonexistent so I wouldn’t expect to see these devices evolve into game controllers, second screens, etc., any time soon. gdc14_4
  • Lots of developers took interest in our talk about rapid prototyping of games using Kii. We look forward to having some of them participate in our upcoming Unity contestgdc14_5
  • We got lots of positive feedback from developers who tried demos of the Asset Store as well as from the asset store managers, who were in the booth right next to us. Some issues with Android and the developer console were reported, but it was all solved by properly configuring the project build and refreshing the developer console respectively. gdc14_6
  • The cloud is gaining ground when it comes to hosted services for game developers. Kii, a cloud-based service itself, shared booth space with Simplygon, a company that allows you to upload your 3D model to the cloud for processing and get an optimized version with fewer polygons, which boosts your game performance. We’ll certainly see more cloud services like this, not only intended for development but also for in-game services, such as Kii provides. This trend is undeniable when you see Nintendo Wii providing a web development SDK that lets developers interact with the Wii API from a web app that’s hosted on a console. This could lead to interesting side effects in the future. gdc14_7

Overall, GDC 2014 was a great event for Kii, and I would like to personally thank everybody that dropped by and shared their feedback with us. Hope to see you there again next year!

blog-banner-user-console

We are happy to announce a new addition to Kii’s developer portal – user browser!

What is it?

A perfect complementary tool to our existing Data Browser, User Browser allows you to log into the developer portal to view and edit the registered users within your app at any time. Continue reading

Here at Kii, we’re constantly working on new functionality to improve the experience for our mobile developers. Several exciting new features just rolled out, giving you more power to accelerate development and optimize your apps. Without further ado…

A/B Testing for everyone

New A/B Testing functionality is included with all Kii accounts, including the free ones. In fact, it’s in your Developer Portal now (log in, left column).

Say you have a hunch that users prefer red buttons over green ones or think “Try” will outperform “Buy” as your call to action. Run an experiment to find out for sure and then push your optimal result to everyone with one click, without having to update your app.

Kii A/B Testing supports multiple variables so you can test combinations around app experience, features, usability, etc. It’s a great way to test hypotheses and optimize for user adoption, retention, monetization and other KPIs that matter for your business. (Not to mention being able to say, “I told you so.”) You get one experiment with unlimited variables free every month and can upgrade if you want to do more extensive testing. We’ve put together this video and an intro guide to get you ramped up.

A/B Testing for Unity, too

Since we announced our Unity SDK, we’ve gotten superb feedback from mobile game developers, both in our community and on the Unity Asset Store (all 5-star ratings). Thank you! We definitely consider Unity a priority and are pleased to announce that A/B Testing is available for the Unity SDK so you can validate your game engagement hypotheses.

Server Hooks!

Suppose you created this great Kii Sever Extension but, instead of programmatically executing it from your client, you want it to run when something meaningful happens on the backend (e.g. a user is created). Server Hooks allow you run Server Extensions automatically by attaching a Hook config file upon code upload. Your server extension can stay dormant and run when the conditions specified in your config file are met. Right now we support running your code when actions such as these happen:

  • Object CRUD operations on buckets
  • User management operations
  • Group management operations

For details on how to set up these hooks please see our Server Code Management Guide. A hook to execute server code on a scheduled basis (e.g. weekly) is coming soon!

Javascript SDK now compatible with PhoneGap and Titanium

Most multiplatform js-based mobile development tools such as PhoneGap and Titanium can now leverage Kii without hassle. Simply download our updated Javascript SDK as a project library. There’s no more jquery dependency!

That’s a wrap for now. We have more exciting announcements for game developers coming really soon, so stay tuned.

There’s more to mobile app success than having a reasonable strategy, an attractive UI design and solid development. In-app Analytics is key to measuring the execution and value of all the important things that happen within your app. Developers usually have access to generic numbers such as installs and activations, but those fall short of the insight needed to steer the application in the right direction and adapt the app to your users’ needs.

With Kii you get this “out-of-the-box” analytics for your application that can valuable to have a general snapshot of key metrics. You can fetch a set of predefined analytics results with no extra configuration (including user, data, file and advertising metrics) but the real power comes when you use Kii’s advanced analytics features to define custom metrics based on events or data generated by your application, with the flexibility of letting you freely define facts and dimensions.

Your metrics can be based on two data sources:

  • App Data: Object data created by your application. You can use any stored key-values for defining your custom metrics.
  • Event Data: Data thrown by your application besides application data. Kii Analytics provides you a feature to throw such event data with arbitrary key-values.

 All results will be automatically aggregated and will be ready to be presented to you.

 In this article I will show you how to work with both Event and Data based Analytics and how to fetch the Analytics processed data from the game itself  (all in the context of a simple 2D platform game demo that uses our Unity 3D SDK).

Event based Analytics

Let’s start with Event based Analytics. The mechanism is simple: you can send a custom event with custom (free form) data every time something meaningful happens in your game (eg. player dies, player reaches a special area, etc). The event data is aggregated on Kii Cloud and will be ready for slicing and dicing.

Suppose we want to send an event to the Kii Cloud every time the player dies and attaching the game time as data. The code using the Unity SDK would more or less look like this:

            // Sending Kii Analytics event for game over stats
            KiiEvent ev = KiiAnalytics.NewEvent("PlayerDeath");

            // Set key-value pairs
            ev["time"] = Time.time;
            ev["level"] = 1;

            // Upload Event Data to Kii Cloud
            KiiAnalytics.Upload(ev);

Notice that we attach the game time as if the event were a key/value store. You can attach as many dimensions as you want (all of them will be valid dimensions for slicing and dicing).

Now we need to define how to aggregate the data for visualization on the developer.kii.com and define the metrics and dimensions (for slicing and dicing). For this example we’ll call the metric “AvgDeathTime”, we make sure we select “Event Data” and select an aggegation function over the event data we sent (in this case we want to know the average of the field called “time” within the event). In Dimensions we specify the time but you could select other dimensions if they are available in your event (eg. if you pass the country in a field you could segment your analysis by country):

event_config

A step by step guide on how to configure your metric on the developer console can be found here: http://docs.kii.com/en/guides/unity/managing-analytics/flex-analytics/analyze-event-data/

After you click Save and if you already sent events ( using the source code above at least 24 hs prior to visualization) you’ll see your aggregated data:

avgdeath

Data based Analytics

Event based Analytics is powerful but has a major caveat: you need to define explicitly in your app when an event happens and which data is associated to it. That translates into app updates every time you need to define a new event/metric.

Fortunately if you’re suing Kii Cloud to store your game data you can apply the Analytics tools we described to any stored object (it doesn’t have to be an Analytics event) and, in this way, unleash the full power of Kii Analytics.

Let’s see how to store the user scores to later use data based Analytics to visualize the average user score. In order to do that you need to save an object with the score on Kii Cloud. The code will look more or less like this:

void SaveScore (int score)
{
        KiiUser user = KiiUser.CurrentUser;
        if (user == null)
            return;
        KiiBucket bucket = user.Bucket ("scores");
        KiiObject kiiObj = bucket.NewKiiObject();
        kiiObj ["score"] = score;
        kiiObj ["time"] = Time.time;
        kiiObj ["delta_time"] = Time.deltaTime;

        kiiObj.Save((KiiObject obj, Exception e) => {
            if (e != null)
                Debug.LogError(e.ToString());
            else
                Debug.Log("Score sent: " + score.ToString());
        });
 }

Notice that we also send the time together with the score. Similarly to our previous description of events, you can store any key/value combination in the object and any stored field can be used as an Analytics dimension. But unlike analytics events these objects are first class data objects and can be later retrieved with a powerful query system (among other things).

Once we sent scores this way to the back-end we can go to the developer console and configure a rule (here we’ll create one to aggregate the average user score):

user_score

Note that this rule will collect all objects with a “score” field and extract its value as an int. It will use a user scope bucket (see the source code above, you have to define the scope of bucket to store an object). Once defined we use this conversion rule to define an aggregation rule (in this case we want the average):

avg_user_score

Done! When we collect enough data we can visualize the average user score:

avg_user_score2

A full guide on how to create these rules is available here: http://docs.kii.com/en/guides/unity/managing-analytics/flex-analytics/analyze-application-data/

Fetching Analytics results inside the Game

Interestingly enough you’re not limited to visualizing event and data based analytics on the web. Some apps and games require access to some metrics to alter behaviour (eg. if the average single user score is below a certain level then game difficulty could be adjusted automatically). With the Unity SDK you can access the already processed analytics data by rule id straight from the game:

        // Define filters
        ResultCondition condition = new ResultCondition();
        condition.AddFilter("AppVersion", "9");
        condition.AddFilter("level", 1);
        condition.GroupingKey = "level";
        condition.DateRange = new DateRange(new DateTime(2014, 2, 23), 
                              new DateTime(2014, 2, 25));
        try
        {
            GroupedResult result = KiiAnalytics.GetResult("143", condition);
            IList<GroupedSnapShot> snapshots = result.SnapShots;
            foreach (GroupedSnapShot snapshot in snapshots)
            {
                // do something with snapshot.Data
            }
        }
        catch (Exception e)
        {
            errText = e.Message;
        }

Note that we initially define a condition to filter on the analytics results (of which it’s important to define a date range). The condition also allows to define a grouping key for the results (similar to a SQL group_by). Then we pass the condition and a rule ID to fetch the analytics results (which will be returned in snapshots containing data in json format). You’ll have to parse the json data into the appropriate format (depending on what kind of rule data you’re working with).

That’s all for now. We hope you can try out Kii Analytics in your game to get the necessary insight to improve the player experience. You might want to try out the demo described in this article which is available here:

https://github.com/KiiPlatform/Kii2DPlatformer

One of the advantages of Kii Cloud is that it exposes all of its APIs as a REST web service. This is not only useful for developers using Kii Cloud from platforms that don’t have a dedicated SDK, but also gives developers the chance to use new features before they are officially released in the SDKs.

Kii Cloud Launches Unity SDK, Data Browser and Server Extension

Let’s take a look at an example: calling Server Extensions from Unity 3D using the REST API. Since Unity 3D is the most recent addition to Kii’s platform, it is still catching up with some of the newest features like Server Extensions. Server Extensions allow developers to extend the functionality of Kii Cloud by deploying javascript code to create new, custom endpoints. So if there’s something that the API does not support by default you can extend it.

Deploying Server Extensions

First of all you need to create an app at developer.kii.com following these steps:

1)   Create an account at http://developer.kii.com
2)   Create an application as explained in “Register an application” following steps 1, 2, and 3 (disregard the other sections): http://documentation.kii.com/en/starts/unity/
Choose Unity as platform for your app and the server location of your back-end.
3)   Note the App Id, App Key, Client Id and Client Secret assigned to your app as explained in “Register an application” following step 4 (disregard the other sections): http://documentation.kii.com/en/starts/unity/

Now it’s time to deploy a Server Extension. Let’s create a simple echo service (It will give us back the message we send as parameter). Create a file called echo.js with the following content:


function echo(params, context) {
    return params.message;
}

Note: the function name “echo” will be the endpoint name (see next section)

We’ll use Kii server tool to deploy it (look for the icon with a cloud here https://developer.kii.com/#/sdks). Switch to the server tool directory from the command line, execute the following after adding your app’s keys (assuming you selected US for location of your app):


node bin/kii-servercode.js deploy-file --file echo.js --site us --app-id YOUR_APP_ID --app-key YOUR_APP_KEY --client-id YOUR_CLIENT_ID --client-secret YOUR_CLIENT_SECRET

Done! Your server extension is ready to be called.

Calling Server Extensions

In order to be able to talk to Kii’s REST API we need to be able to send POST HTTP requests with proper headers, data and endpoint information. In order to do this we’re going to use the native Unity 3D class WWW (so no 3rd party HTTP classes are needed) and a little bit of help from an extra class to encode/decode JSON.

The class WWW will help us send an HTTP request to Kii Cloud API using POST. This request will require the following data:

  • Kii App Id and App Key (you get these when creating an app on developer.kii.com)
  • Name of your custom endpoint (the name of the JS method you created) so you call the right server extension (you can have multiple methods doing different things)
  • Your JSON data (if your server extension uses parameters as input)
  • (Optional) A Kii user authentication bearer (a token) if you want to run the server extensions as an authenticated user rather than anonymously (you can get this token after signing in a user using Kii Cloud)

The code to call the server extension will look more or less like this (assuming you configured your app on developer.kii.com to be hosted in the US):


public static WWW RunServerExtension (string appId, string appKey, string endpoint, string kii_access_token, string msg)
{
	WWWForm form = new WWWForm();
	Hashtable headers = form.headers;
	headers["Content-Type"] = "application/json";
	headers["x-kii-appid"] = appId;
	headers["x-kii-appkey"] = appKey;
	if(kii_access_token != null)
		headers["Authorization"] = "Bearer " + kii_access_token;
	Hashtable data = new Hashtable();
	data["message"] = msg;
	string json = JSON.JsonEncode(data);
	Debug.Log("Sending: " + json);
	byte[] bytes = Encoding.UTF8.GetBytes(json);
	return new WWW("https://api.kii.com/api/apps/" + appId + "/server-code/versions/current/" + endpoint, bytes, headers);
}

Note that the method takes your app’s App Id and the App Key that you wrote down in previous steps. It’s important that you use the same method name that you use in your extension as the endpoint parameter (in this case it’s “echo“).

This call will not block the game since we’re running WWW in a Coroutine (the execution is yielded until we get a response from the server).

If you want to try this out you can download our demo project KiiUnityREST and run the Init scene after configuring your app keys using the Kii Game Cloud top level editor menu.

This is all for now. This technique allows you to have the best of both worlds in Unity, a dedicated SDK plus any REST API call!

On my next blog post I will show you how to send push notifications from Unity also via Kii REST API. Stay tuned!

Unity 3D Developer? Sign up to our contest and win 10K in prizes!!

Kii Cloud is a full-stack mobile backend to accelerate iOS, Android, HTML5 and Unity app development. Optional ad network integration is available to help you monetize. Get started with a free account at developer.kii.com

In this post we will look at working with images in a demo Kii Cloud application. The example shows how to store, retrieve and delete image data using Kii’s Javascript API. Similar approaches can be taken with other Kii APIs, but we’ll use JS for an example.

Image files (binary data) can be represented as an object. In terms of Kii’s API we will need to create a Kii Object, with one of the fields (key-value pairs) containing the binary image data. Please note, that the maximum size allowed for an object is 65534 bytes, which means that if you need to load bigger images, you will need to resize them in advance.

First, let’s read an image from a file into a variable (blob):
HTML: create an input tag to select an image file and img tag to preview the image

<input type='file' id=" inputImage" />

<img id="img" src="" />

Javascript (using JQuery): as soon as an image file is selected, it will be set to preview and stored into the imageData variable.

var imageData;

function readImage(input) {

  if (input.files && input.files[0]) {

    var FR = new FileReader();

    FR.onload = function (e) {

      $('#img').attr("src", e.target.result);

      imageData = e.target.result;

      addToList(imageData, $('#inputImage').val());

    };

    FR.readAsDataURL(input.files[0]);

  }
}

$("#inputImage").change(function () {

  readImage(this);

});

After executing the code above, your user will see the image preview as shown below:

preview

Now that we have our image saved in a variable, we can store it in Kii cloud:

// get the defined bucket belonging to this user

var bucket = KiiUser.getCurrentUser().bucketWithName("myObjects");

// create the object

var object = bucket.createObject();

// set a key/value pair for image blob and image namr

object.set("myObjectValue", imageData);

object.set("myObjectName", fileUri);

// save the object

object.save( ....//insert necessary callbacks here...);

}

The code snippet above saves image data in the current user’s bucket in Kii cloud. If the save was successful, we can retrieve the image along with the other images already in the bucket:

// get the defined bucket belonging to this user

var bucket = KiiUser.getCurrentUser().bucketWithName("myObjects");

// create an empty KiiQuery (will return all objects in the bucket)

var queryObject = KiiQuery.queryWithClause(null);

// sort the results by creation date

queryObject.sortByAsc("_created");

// perform the asynchronous query, with callbacks defined

bucket.executeQuery(queryObject, {

  // callback for a successful query

  success: function (queryPerformed, resultSet) {

    //display the results

  },

  // callback for a failed query

  failure: function (queryPerformed, anErrorString) {

    // add some error handling
  }});

}

The code snippet above loads the whole set of objects in the bucket. However, if you only want to retrieve a particular image, you can do so using its “myObjectName” key:

var clause = KiiClause.equals("myObjectName", fileName);

var query = KiiQuery.queryWithClause(clause);

// Define the callbacks

var queryCallbacks = {

  success: function(queryPerformed, resultSet) {

    // display the results
  },

  failure: function(queryPerformed, anErrorString) {

     // do something with the error response

  }}

// Execute the query

bucket.executeQuery(query, queryCallbacks);

Once the image objects are retrieved from Kii Cloud, we just need to display them. The retrieved resultSet should be assigned to the global results variable for the future reference. The results will be displayed in the listview element on the page:

results = resultSet;

// clear the existing objects from the list

$("#listview").empty();

// iterate through the result set

for (var i = 0; i < resultSet.length; i++) {

  // create a row UI element based on the object

  var obj = resultSet[i];

  var row = createListItem(obj, i);

  // add the row to the list

  $("#listview").append(row);

}

// refresh the list to show the added results

$("#listview").listview('refresh');

The function below shows how a DOM element is created from Kii image object:

function createListItem(obj, index) {

  // set the KiiObject URI to an attribute so it can be tracked

  var row = $("<li></li>").attr("uri", index);

  var imgrow = $("<img></img>").attr("src", obj.get("myObjectValue"));

  $(row).append(imgrow);

  var deleteLink = $("<a></a>").attr("href", "javascript:removeFromList('" + index + "')");

  $(deleteLink).append("<p>delete " + obj.get("myObjectName") + "</p>");

  // append the delete button to the row

  $(row).append(deleteLink);

  // return the entire row

  return row;

}

The result will present a list of images from Kii cloud with delete links next to them:

list

Image deletion works exactly the same as deletion of any other Kii object. Since we already have the list of all objects, we can just remove them using their index in the list:

// called from the UI, this method removes an object from the server

function removeFromList(index) {

  // get a reference to the selected object

  var obj = results[index];

  // perform an asynchronous deletion, with callbacks

  obj.delete({

    // callback for a successful deletion

     success: function(theDeletedObject) {

      // find the associated UI element and remove it from the list

      $("[uri='"+index+"']").remove();

    },

    // callback for a failed deletion

    failure: function(theObject, anErrorString) {

      // do something about the error

    }

  });
}

That’s all! Happy coding :) Full source is available for download here.

Kii Cloud is a full-stack mobile backend to accelerate iOS, Android, HTML5 and Unity app development. Optional ad network integration is available to help you monetize. Get started with a free account at developer.kii.com

3:12 p.m. PT Kii Platform Evangelist German Viscuso took to the Gaming World stage to talk about using Unity + Kii Game Cloud for cross-platform game development. His point: Game developers are great at building games, but aren’t typically as skilled at server provisioning and ongoing management. With a game cloud, you don’t have to worry about it. Features of note: Player management (register players with one line of code), data management (e.g. specify two things to save game progress across different devices on the backend), analytics and geolocation. All with seamless gameplay.

German Viscuso

Congrats to our first giveaway winner, Franklin Silva!

Franklin Silva

Parrot AR.Droid winner Franklin Silva

AppsWorld_KiiBooth

Left to right: Edmund Leung, German Viscuso, Chris Beauchamp, Waqas Makhdum, Masanari Arai

10:11 a.m. PT That’s a wrap for Woz’s keynote. We’ll be hanging out at Booth #113 giving away Parrot Ar.Drones. Stop by and say hi.

Keynote highlights:

“[With mobile] we’re having a lot more innovations and changes today than we ever have.”

“Apple is superior at saying no. They focus on what they do…[They put together] small teams with great people. “

“A whole new category of products doesn’t happen very often. If you’ve got something really great, don’t change it.”

Steve Jobs’ focus at Apple: “Keeping products good and usable. You don’t want too much junk in it.”

“We all need to build more security.”

“You don’t want to deceive your users. You want to protect them…Their data is their data.”

IOT (beyond wearables) needs standards. “Right now I can write code and so can anyone.”

Steve Wozniak, AppsWorld 2014

Apple co-founder Steve Wozniak gives the Developer World keynote at AppsWorld North America 2014.

9:10 a.m. PT Apple co-founder Steve Wozniak takes the stage for the Developer World keynote and fireside chat. We have an amazing view from the Kii booth.

AppsWorld Expo

Gateway to the AppsWorld North America 2014 expo floor.

9 a.m. PT San Francisco’s Moscone Center West is decked out for AppsWorld North America 2014.

AppsWorld_NA_MosconeCenter

AppsWorld North America 2014, Moscone Center West, San Francisco

About Vishal: I am the founder and CEO of Appsquare—a Sydney-based  app development company that designs innovative apps, provides part funding for selected app ideas and also helps app developers get funding through its network of Venture Capitalists and Angel Investors.

 

Everyone wants to create the next Temple Run and Subway, and many may even success in creating brilliant games. But, even the best app games won’t fetch their developers much in terms of profits, unless they are marketed right.

Therefore, before developing a gaming app, it is highly important to get your facts straight. Here’s a list of the top 9:

#1 Thumbs up to cross-promotions

60% of agency professionals and 70% of brand marketers feel that social media advertising is essential to build brand awareness. It must seem appalling but it is possible to drive an app in the Top 10 without shelling out on advertising. This is when cross promotion is applied to the existing application. Rovio, BigFish and Chillingo are players who make this fact valid. And they no doubt are big names!

Rovio in fact scripted the Angry Bird success story with a very interactive social marketing strategy. So impressive is this success story that it’s hard to believe that the game almost flopped when it was first launched.

#2 Moderate Success!

For a game to be considered moderately successful, it has to at least earn up to $100-500K per month. Yes, per month! And what’s the other criterion to attain moderate success? The game has to receive 200-300k installs and 30-50k DAU. Clash of Clans and Hay Day’s proprietor Supercell mints around $4m per day.

#3 High k-factor

So when does a gaming app acquire the high k-factor? A mobile game invite sent through SMS acquires the highest k-factor. The SMS scores high on reach and user receptiveness as compared to other platforms.

4328629067_638176d539_o

Image source: http://farm5.staticflickr.com/4027/4328629067_638176d539_o.jpg

#4 The swipe accuracy

There is no doubt that simple tapping is easy. However, it is observed that people are much more accurate with swipe gestures. While using swipe gestures, a person subconsciously controls a trajectory of the finger leading to more accurate moves.

#5 Power of limited offers

The limited offer is the most successful good in CSR racing. And the best part is that it appears only 5 times in the entire game. With merely 5 shows, it manages to turn the most successful.

#6 The high ranker in the App store

Sometimes it is felt that an app is a scam when it constantly ranks high in the App store. But when the app holds a high rank, even after 4-5 days, it isn’t a scam.

#7 Traffic can be a problem

The only place where traffic is loved is in the virtual world of app downloads. However, traffic larger than 1MB per minute creates issues in Latin America.

#8 Copying at roadrunner speed

When a western game is published in China, it is sometimes too late. There have been several cases of Chinese developers copying titles and sometimes even successful Facebook games.

#9 Psychological help for game developers

Game developers are taking the services of psychologists so as to acquire some help with the game start and tutorial levels. This is because if players are engaged during the tutorial and first level, they are more likely to continue playing the rest of the game.

The above game app marketing facts are not only interesting to know, but also highlight significant insights that can help app developers. A high rank is obtained on aspects like scope and lucrative growth. These can be achieved by scanning the market, concept and user expectation.

 

Kii Cloud is a full-stack mobile backend to accelerate iOS, Android, HTML5 and Unity app development. Optional ad network integration is available to help you monetize. Get started with a free account at developer.kii.com

 

Reference Links:

http://www.appfreak.net/mobile-game-development-facts-you-need-to-know/

http://heidicohen.com/7-actionable-social-media-tactics-to-rock-your-marketing-plans/

http://heidicohen.com/mobile-marketing-29-charts-every-marketer-needs/