A prompt answer would be: the reason if I require that. I distribute my application available which has an assemble in overhaul usefulness. Thoroughly genuine :). The requirement for such a usefulness emerged when I composed the Android application Developers for my momentum MSc proposition research. The application was never planned to be distributed available, yet rather it was just thought for inner use. On the other hand, giving some sort of instinctive overhaul component is significant for having the capacity to discharge bugfix updates or include new elements. The same may hold for you also, for case for the situation where you add to an application for an organization which doesn't need it to be discharged on the official Android market. On the other hand you need to execute distinctive "channels" (as Chrome does it), denoting an application as an early discharge rendition which will be overhauled through your own instrument to a devoted arrangement of beta analyzers.
Android App Versioning
Android applications Development have two diverse sort of rendition numbers: the adaptation code and form name. The form code (see line 4 underneath) versiones the codebase while the adaptation name (see line 5) is proposed for representation purposes, i.e. for appearing in your application's about UI or it is shown by Android on its Manage Applications client interface.
Obviously the fundamental hobby is for the variant code as it can be effectively used to look at for the accessibility of a more up to date form, i.e. a higher rendition code number than the present one.
Programmatically Reading the Version Code
The initial step is to have the capacity to automatically perused the present application's variant code. For reasons unknown, simple:
Presently, knowing how to peruse the present adaptation code it is only important to question some remote area for the vicinity of an Android app Developers with a higher rendition code as the present one.
The Update Strategy
I took an extremely straightforward, yet effective methodology. On some remote, openly available area on the web, new forms get sent. Fundamentally the new apk record and in addition a plain ordinary content document containing only that application's variant code. So I have
- The APK: http://some-open url/convey/MyApplication.apk
- The rendition information record: http://some-open url/convey/versioninfo.txt
On the versatile customer application, I have an updater administration which keeps running as an Android Background Service. The rationale is straightforward: in general interims, the administration downloads the versioninfo.txt record and parses the containing number speaking to the form code of the sent application. The download is finished by opening a HTTP association and issuing a GET ask:
The openHttpConnection() method that gets called from within downloadText() contains the code for - obviously - opening the HttpConnection which is returned as an InputStream to the caller for being further processed:
As should be obvious there is space for changes. The downloadText() as determined above downloads a String worth which should be changed over to a whole number for doing a legitimate correlation with the gadget's present adaptation.
The check itself is very basic: if the downloaded number is greater than the current application's rendition code number, a warning is activated to the client, demonstrating the vicinity of a more up to date adaptation. By tapping on the notice, a download Intent is terminated, which downloads the new apk record by utilizing the program's construct as a part of download usefulness:
This is without a doubt the least complex methodology. A more complex one could be to let the application itself download the new apk to the SD card and fire the introduce, a short time later uprooting the APK again and so forth...
