I am looking to release two version of my app: free and paid. The paid app will have a few more functions but no extra content as such. Originally I was going to release two separate apps on the market but it is proving difficult to keep a single code base and have two separate apps.
Would in-app purchases be a better way to do this? So I release a free app and then allow users to purchase a unlock for the extra functions. This would also mean that I wouldn't have to explicitly use the licensing part of the Android development as that is taken care of within the in-app purchasing.
There are three strategies which come to my mind:
Release two versions, a free version and a paid version. The paid version contains additional features. To make development easier, you should use Android Libaries. These prevent the duplication of code.
Advantages:
Simpler to implement.
Works on other markets as the Android Market because it is not dependant on it.
Disadvantage:
If the user has some data in the free version, you must provide a import functionality for the paid version or the user will loose the data.
You have two versions on the market which get different reviews.
Release two version: a free version which contains all features but some features are locked. Unlock them using a "unlock app" which is a simple paid app released on the market.
Advantages:
Simple to implement.
Works on other markets as the Android Market because it is not dependant on it.
Disadvantes:
Is not that intuitive because the user has a "useless" app installed.
Release one version: a free version which contains all features but some features are locked. Unlock them using in-app purchases.
Advantages:
Finegrained solution: You can unlock different features for different prices.
Disadvantes:
Not that simple to implement, the In-App-API is tricky
Does not work without Android Market
You could also use two separate flavors.
One for the free version and the other for the paid version.
Without rewriting another boss project.
https://developer.android.com/studio/build/build-variants.html
Related
I am wondering what is the best way to have two different versions of an android app. I would like to have version of my app with ads and one without ads (the paid one). What is the easiest way to achieve this ? I have found something called version flavours here but since I am new to android development I am not sure if that is what I want. Please any suggestions for addressing this ?
You could have two versions of the application in Play store. However, you would have to maintain these separately and it is frustrating to upgrade from free to paid with this approach. If you chose this way of maintaining your application, you would have to have two projects, one for each version. This would result you into having two copies of almost identical source code.
One approach I've seen people do is that the free version also contains the premium features which are unlocked once the user installs a paid unlocker application from the store. However, this has the same result as the first option: you would have to maintain two applications (this time different, though) and the users would have to install additional software.
The best option is to include the premium version as an in-app purchase. The app would contain all the premium features but would be locked by default. Once the user pays for the in-app product (in this case the premium membership), he would unlock all the features.
You can read more about in-app billing here.
Why not just publish two apps with the free one as this :
MyApp
and the paid one as this:
MyApp(Paid).
And this is how to prepare them:
Get your app working, and add ads and then sign it and generate the apk. Publish it. MyApp.apk
Then go back, and remeove the ads, change the package name, add the Paid to the name, and then sign the apk. MyApp(Paid).apk
Then Publish it.
I decided to build a paid version of my free Android application.
The paid version has some extra features. How do I manage both versions?
Is it possible to keep them based on the same source code?
If an application requires unique package name, how do I force paid application to replace free version?
What about db, preferences and other privately stored stuff, how to share them without exposing all data to the rest of the world?
Any advice that will help to manage both projects,
but not answers the above questions directly, is appreciated as well.
There are several approaches:
Put the core of your app in a library project, and create two other projects one for the paid, and one for the free version of the app. An upgrade to the paid version means the user has to uninstall the free version, and looses all the data.
This is the "classical" approach.
Let the user make an in-app payment. The user keeps all database and settings, and you have to maintain only one app.
This option requires extra modules to be included in your app, and extra logic.
Make another dummy/empty app, this is a paid app. The existance of this app means the user has a paid version. The user keeps on using the orginal/free app.
You can simply check by using the PackageManager to see if the paid app is downloaded.
The user keeps all database and settings, and you have to maintain only one app. Ok, there are two apps, but the second can be really small and simple.
You don't have to include additional libraries/code to make an in-app payment. You can also have all your apps upgraded to the 'pro' version with one purchase.
I don't know if all users understand this pattern. For the developper, this can be achieved with minimal work, and the users keep all their settings while upgrading.
I think it's possible and recommended to keep them in same source
code. Otherwise you have to support two versions of app instead of
only one.
If you have only one app therefore you have only one package name.
Create a class responsible for app features availability in current license state (free or paid). This class should store information about license state (free, paid, maybe you will deside to add subscription mode in future in which paid version can expire after some period). Features of your app available only in paid verion shoud check current license state. You can also change app GUI depending of license state. For example hide GUI of paid features, show "Buy" button or ads, etc.
And also if you have only one app that can be free or paid you don't have to share any internal app data between paid and free versions.
I'm having two versions of my app. Free and Pro. I'm going to remove the free version and change status of the Pro version from paid to free and use in app billing to unlock advanced features instead of having two different apps. Users already paid should start off with all features enabled.
Is there a way to check if a user has purchased the app after changing it to free?
From what I have read, LVL can't do this.
Is it possible with IAB v3?
There are several postsbelow here on StackOverflow concerning this topic. The short answer is that there's no fool-proof way to do it.
Some possibilities:
Check for some prexisting object exclusively from the Pro Version(db, pref, etc)
This won't work for new devices, only if it's a simple upgrade on an existing install
Use the old Pro app itself as the "key" to unlock(check PackageManager)
Suffers from the same problem as above, and even uglier
Create a unique id for each Pro customer, save it server-side and check on startup
Necessitates internet access for validation, not very secure, users hate data collection
A hybrid of more than one method would probably work best, but it depends highly on the implementation. No matter what you come up with, there will be some issues, and I don't think there's a way to 100% cover every existing customer.
How to migrate from a paid android application to an application paid for with in-app billing?
Converting an Android application from a free/paid model to in-app paid unlocking
Changing paid Android App to free with In App Billing - grandfathering existing customers
How can I use the paid version of my app as a "key" to the free version?
Is it possible to list in Google's Android Market a single APK for both free and paid versions?
So far, I only found this tip to create a button in the free version that links to the paid versions, but IIUC these are still 2 separate APKs.
I also found a reference to creating free/paid versions from same code, but that still refers to 2 separate APKs.
What I am interested in is an (Google) Android Market way to provide functionality that is similar to PayPal's MPL (i.e. one app does it all). Is this possible?
EDIT: Based on the answer below, it seems that Google's In-App Billing facilitates this.
However, LVL's Requirements and limitations says:
Licensing is currently for paid apps
only, since free apps are considered
licensed for all users. If your
application is already published as
free, you won't be able to upload a
new version that uses licensing.
I know that LVL is not the same as In-App Billing but LVL is definitely required for In-App Billing to work (if only for using the key). So how does this reconcile?
It's possible to use something known as in app products. The min API is 1.6, which should work plenty well. Basically, anyone could download the code, but some unlocking of features could be done if desired to buy new functionality. They also have sample code which shows how it works.
Alternatively, you could use the licensing API, and simply check to see if your app is licensed. This would require a different package name, however, as all apps do.
You can rename the package before compile and release it as two apps.
i.e. com.example.yourproject and com.example.yourprojectpaid
You need to use the Key for both he LVL and the in app billing and its a good amount of effort to set up. If you want the easy way out use the example above, but know your paid app is not really protected from piracy if you don't use the LVL for your paid app or in app purchases if you keep the app free.
Good Luck.
I was wondering if there is any way to progammatically determine if the android app has been paid for?
I am going to implement the Android LVL library code in my app. But I also want to let the users first try out the app and then buy it if they like it. So how can I determine if the app has been bought and hence fully licensed.
If you want to let users try your application out first before buying release a limited free version. (Limited by features not time)
Then also release a paid application. I would recommend 'up selling' your application from the free one. i.e. promote and encourage the upgrade from the free one by saying it has more features, better this, better that..
The LVL then only belongs in the paid version, not the free one.
This can be done with the new In-app Billing API but not with the existing LVL, as LVL can only be used to verify upfront purchases from the Android Market (read paid apps.)
Effectively LVL and In-app Billing server responses are the same and can be verified in the same manner.