in my company we plan to develop an app with different modules. We develop Apps for Apple, Android and Windows. We have some default modules like inventory and relocation, but for some customers, we need to develop custom modules. The question is, what is the best way to provide this app to our customers and how we can use update functions?
If we build one app with every module, and just unlock the modules based on the customers licence, it will be massive inflated, at the time. We have up to 20 customers and each of it needs 2 or 3 custom modules.
To build 20+ apps and distribute it over the store, it will be really difficult to manage each app. And if we update some core functions, every single app must be updated. Not a good way.
So what is the best way to develop custom apps for our customers and ditribute and update it?
sorry for my english, it's not the best..
So you don't want to include all modules in every app installation, and you don't want to distribute many different versions of the app, each one with a different combination of modules.
It seems to me that the only solution you have is to download your modules after the user has installed the app and chosen their license.
The easiest way to implement this is with a web app as opposed to a native app. However if you want to write a native app you are able to download and execute binaries at runtime.
This thread contains a few different approaches to achieve that:
Is it possible to dynamically load a library at runtime from an Android application?
Good luck!
Related
I am working on a project where we have a product that we are selling to clients and basically it is same app with just different client logos, name and app color and some minor changes.
Let's say we have an app that creates a blog post. All of our clients are using this app and the only difference is that all apps have their own customer logos and color schema. It is hard to maintain multiple different projects and versions of apps. I mean if we have a new feature to implement or a bug fix, it is painful to copy code and put it in all apps and compile and generate APK files for Android and share it with clients.
It is also hard to deploy/create project when we get new client. Basically I am copying all project files, renaming directory and changing package name. I work on Android project, but we also have people working on iOS and it is same issue.
Is there any easy way to manage projects like this with some Android Studio feature and XCode feature? So for example, new feature of this app is allowing users to create post with uploading images so I write code for one Android app and push it to all apps and I can get APK files easily without opening multiple Android Studio projects?
Android Studio has support for multiple build types:
https://developer.android.com/studio/build/build-variants.html
Xcode can support multiple Targets:
https://developer.apple.com/library/content/featuredarticles/XcodeConcepts/Concept-Targets.html
With both you can use a shared codebase and depending on the build target/flavor/type, you simply use different assets, etc.
This would even let you configure certain apps with features enabled/disabled (assuming it's architectured well)
Short:
Is it possible to write a mobile application where you can download some kind of extensions/add-ons (like in desktop programs) that are not previously shipped in the app archive?
Long:
I am developing a mobile app with a shared base functionality but different modules for different clients. As the app is growing rapidly and the modules are quite different, it would make sense, not to pack every module into the apk from the beginning but to ship only the base code to all clients and they can select and download the modules they would like to use. Regarding apk size and speed this would offer definately advantages. Splitting the app into several smaller apps with different package names on the other hand would be very hard to maintain. Currently I'm using Ionic but the question would be equally interesting for native apps.
Searching the web returned nothing of value, so I'm wondering whether there is a way to acchieve this...
Well, i'm not sure if you can have a class loader as you have in Java for doing such things. But the res folder probably will not work.
Another approach is to launch every plugin as a different application, and design those activities to work with startForResult so you can communicate and open all other apps while looking like you are within the same application.
I am looking now into re-architecting a library based Android App, so that instead of providing each library's functionality at build time (limiting its expansion to me only), I would just provide a base App and an SDK that would allow any developer to independently write a plugin.
I couldn't find many ways of accomplishing this on Android (unlike .NET's Unity dependency injection framework which supports independent DLLs). What I found was:
APK based approach:
http://blog.raffaeu.com/archive/2015/05/31/android-plugin-application.aspx
Service based approach:
http://androidsrc.net/creating-android-app-plugin-architecture-tutorial/
My question is: Are there additional ways of accomplishing this? (note: ways that are legal from Google Play's ToS)
Also, in your opinion, which of the two approaches that I listed above is superior?
Generally, if an app will accept some sort of plugins from other developers, those plugins are distributed in the form of APK files, whether through the Play Store or through some other channel. Those plugins may need different permissions than yours, for example, and that can only be accomplished if they are first-class citizens on the Android device.
Hence, a plugin is merely some other app that interacts with yours through some documented and supported IPC mechanism. The big four Android components — activities, services, receivers, and providers — are all possibly relevant for a plugin. It really depends on what you want the plugin to do and what the plugin needs from your app to be able to do it. In the abstract, we cannot tell you which of those to use.
Personally, if I were going to do this sort of thing, I would write the base app plus at least three plugins. The act of "eating your own dog food" when writing those plugins will help guide you towards what IPC mechanisms are needed. Even if, in the end, you ship the plugins' functionality directly baked into the main app, having "real" plugins will help shape your SDK, your security model, etc.
I would like to create a modular app in Android. A user would download the core app with some basic functionality, then later on download more more modules and install them into the app. He will also be able to uninstall them, but still have the core app. Is this possible in Android? How should I approach it?
If I build an app for iOS and Android and I distribute it. Let's call this the basic version of my app. A year later, if I decide on a change to my app (a new view or feature) but I only want to distribute this to some users, can I list it as a separate app on the app stores as a "extension"? Then when downloaded (by someone who already has the basic app) it simply extends the functionality. If it's downloaded by someone who doesn't have the basic app, it prompts them to download the basic app along with it?
Yes, you certainly can do this. Android platform offers IPC (Interprocess Communication) mechanism via AIDL (in Android every app is run in its own process by default) and it will be probably used to communicate between your apps. To get information about other apps you can use PackageManager.