I want to know if an android app of mine can be extended by third parties without me having to modify the base app for each extension, kind of what eclipse does with its plug-ins.
The base app would be something pretty simple, some kind of local data manager (CRUD operations). A given plug-in may, for example, do things with said data (different ways of displaying it, for instance) in additional activities/fragments.
From a little research around, I've discovered that if I were to be the developer of both base app and plug-ins, I could accomplish it by creating new apks non directly accessible for the user (Main/Launcher) and querying from the base app whether a given plug-in is installed on the device and, if so, show additional options on the UX. I can work with that, but I wondered if there was no other option to allow the third-party extension.
Searching for "extension points" doesn't seem to yield android results. Maybe it isn't possible?
A given plug-in may, for example, do things with said data (different ways of displaying it, for instance) in additional activities/fragments.
Step #1: Expose said data to third-party apps, such as via a ContentProvider.
Right now, you're already done, except for the part of "show additional options on the UX". For that:
Step #2: Document the <intent-filter> that third-party apps should have on any activities that they want to be launched from your app. This may involve custom actions and/or categories and/or MIME types.
Step #3: When your needs to "show additional options on the UX" (which I am interpreting as some sort of list or menu), use queryIntentActivities() on PackageManager to find all activities that implemented the <intent-filter> that you documented in Step #2, and include them in that list.
For your particular scenario, where it's simply a matter of storing and retrieving data from a base application, you can use the same approach as the Contacts application uses, which uses a Content Provider.
You can read more about Content Providers and how to implement them here: Content Providers | Android Developers
If you're instead looking at extending an installed application, you would have to predefine a dynamic set of classes to present the data, as well as a set of rules and a language / interface for the plug-ins to extend your applications functionality from within your own application.
You could also look into loading external .jar files into your application at runtime. It looks like others have been successful before
Related
I am creating an Android app that will get data from the Internet. Eventually I will want to change the app to get similar data from a different (yet to be determined) Internet location. Then even later, yet another location. I'd like to avoid changing my app to account for different Internet locations because that would be difficult to maintain.
There's probably a lot of options, but after some research it seems like a Content Provider may do what I want. It looks like Content Providers were designed to expose data across application boundaries. This is okay, but I don't care that the Content Provider is in a different app from my main app. No other app would be interested in my Content Provider's data, so crossing application boundaries isn't helpful in this case.
Is a Content Provider a good way to approach the problem?
Is there another option I'm not considering?
If a Content Provider is a good solution, how would I go about packaging both the app and the Content Provider(s) into a single .apk file?
Can this be done inside Eclipse or do I need to use the command line tools?
Content provider is a good solution for your problem.
You just have to declare your content provider in your manifest and it's build with your apk. If you don't declare your Content provider as publi, only your app can access to your data.
A good lib/sample for beginning with content Providers is data droid http://datadroid.foxykeep.com/ It will do all the stuff for you.
If you are using the data directly in a ListView for example, it might be beneficial to create a content provider.
You could also opt for a different abstraction within your app, for example a new class that abstracts out the different sources. I don't really see the argument for using a content provider just to make your app more maintainable.
You might even argue that a content provider adds more complexity while you are not using most of it's features.
If you do go for a content provider you can add it to your main app as a component by declaring it in AndroidManifest.nl just fine and you can develop and package the app in Eclipse like you would normally.
I just got done writing an Android Activity that allows other Activities to call it for some result (it's not intended to be a stand-alone Activity). I'm now working on the equivalent iOS application and can't find any resources for how I would enable similar functionality on iOS.
The situation: The tool I'm producing is intended to be used by other applications, rather than as a standalone application. The thing is, the GUI that needs to be presented to the user is rather involved so I'd like to be able to provide the developer with a "all-in-one" package that they can simply launch and get results from. Doing this in Android was very straight forward. I simply wrote an Activity and instructed the developer to launch this Activity for result. I've looked around and can't find a similar functionality to allow an iOS developer to do the same. What would be the best way to go about doing this?
I think part of the problem I'm having in finding resources is that I'm not entirely sure what what I'm making is called. A library? extension? plug-in? I would think a library doesn't have a GUI and it seems extensions and plug-ins are made for an extensible application (that is, one in which the user can install the extension/plug-in).
Your API could be à single call that would pop up a modal view. A target and selector can be specified to receive an answer. Supplying it to other developers means packing it into a "framework". I'm not sure if you can include resources.
There isn't really any equivalent. The closest you can come is having the second application call UIApplication's openURL with a custom scheme that is listened to by your app, and then when your app is done it would do the same with a custom scheme that is listened to by the calling app.
In practice, the iOS app would usually include the entire activity-equivalent as some sort of library, which at the high level would take the form of a UIViewController subclass that is presented modally and then calls a delegate method or completion selector of some sort on completion.
iPhone development is a different design than Android development, so you may need to rethink what it is you are trying to do.
Most likely you will want to look at just including the code in each program, initially, just so you can get it testable, but that may not be the best solution.
But, without knowing more details about what you are trying to do it is hard to give some suggestions as to better solutions.
For example, you may find LocalNotifications as one solution (http://useyourloaf.com/blog/2010/7/31/adding-local-notifications-with-ios-4.html), but again, it depends on what your needs are.
I found that using local notifications to call a REST service, then to process it and decide if I need to inform the user was helpful, as a replacement for how I used Intents in the Android application.
I have seen applications with add-on modules on market - these modules add-up some new functionality.
What would be the best way to do that ?
I cannot think of a descent and neat way to do that.
There are many ways. The most common is to just install another application and access it via Intents. It's definitely worth looking at Open Intents. If you are really adventurous, you can even load custom plugins with DexClassLoader.
IMHO the only way to cleanly implement this is to use Android's build-in extensibility, namely by using Intents and/or BroadcastReceivers. This is the way Android apps are supposed to communicate with each other, but it may work perfectly also for your own app by creating a main version which is extensible through Intents by your "plug-ins" which can be downloaded separately from the market.
The things you need to learn about and look for on the web to implement such functionality are
Intents: Learn how you can use intents to pass data from one app to another or to invoke certain functionality on other apps.
BroadcastReceiver: For listening to certain events broadcasted by your app in your "plug-ins"
ContentProvider: The content provider is used to provide an abstraction over your data and allows your "plug-ins" to access your app data easily and nicely decoupled through Content URIs.
Intent Filters: These are used to tell the system which kind of actions/Intents my specific Activity is able to accept. You will need them as a way for invoking your plug-ins (by broadcasting an Intent with the given action/category) as well as for providing a space in your menus where "compatible" Intents may hook in automatically.
I hope I was able to provide you some of the topics you need to know about. I'm sure that once you get a deeper understanding on these, you will get a much clearer picture on how to realize such a modular app.
GOAL
Hi, I plan to include in all my aps a "credits" button that will display my logo, URL, etc.
PREFERRED SOLUTION
In order to be more effective I would like to have it as an independent app, so that if I later modify it, all the apps calling it would get updated to the same credits display, instead of modifying each of them.
ALTERNATIVES
*(a)* Of course the easy solution is to copy it within each of my apps and update manually each of them. I think this is not so effective when the number grows.
(b) Having a kind of external resource like a mobile adapted webpage which would always be called. I would only need to change it. But I open then the workfield out of android.
My first idea is to have to define it as an independent activity and get it called from each of the apps.
I have two related questions:
1. How do I ensure this "credits" activity gets installed with an application (is there a kind of dependency which can be defined?)
2. Is this a reasonable way of doing it within Android context?
Thanks.
PREFERRED SOLUTION In order to be more effective I would like to have it as an independent app, so that if I later modify it, all the apps calling it would get updated to the same credits display, instead of modifying each of them.
No user will download this, so do not bother writing it.
How do I ensure this "credits" activity gets installed with an application (is there a kind of dependency which can be defined?)
There is no way to accomplish this.
Is this a reasonable way of doing it within Android context?
No. As #bigstones suggests, use an Android library project.
it's been some time now, since I started reading about android.
I've already made a few basic applications, but I still miss something: How is actually sharing application component being done?
This is what the Android Dev Guide says:
A central feature of Android is that one application can make use of elements of other applications (provided those applications permit it). For example, if your application needs to display a scrolling list of images and another application has developed a suitable scroller and made it available to others, you can call upon that scroller to do the work, rather than develop your own. Your application doesn't incorporate the code of the other application or link to it. Rather, it simply starts up that piece of the other application when the need arises.
I think I came across some question like this, but I think I'm still confused.
Is the only way of getting such a 'private application' information to contact the developers of that application?
Is information about the data that the application operates with private, too?
If it is described in the AndroidManifest.xml file is it available for the other applications, or it is available only to Android?
When I started satisfying my interest in Android - one of the things that grabbed me was the impression of immense interoperability...
:)
Have I been wrong or I still haven't found the way?
Thanks!
How is actually sharing application component being done?
That depends entirely on what you consider an "application component" to be, and what you consider "sharing" to be.
This is what the Android Dev Guide says
That is a fairly bad piece of the documentation. Here is how I would write it:
A central feature of Android is that one application can make use of components (e.g., activities, services) of other applications (provided those applications permit it). For example, if your application needs to display a list of contacts and another application has developed an activity that does just that and made it available to others, you can call upon that activity to do the work, rather than develop your own. Your application doesn't incorporate the code of the other application. Rather, it simply starts up that piece of the other application when the need arises.
Is the only way of getting such a 'private application' information to contact the developers of that application?
Either developers are intending for you to integrate with them, or they are not. If they are, they should be documenting how to do that (e.g., Intent formats to be used with startActivity() to trigger their code). If they do not document such integration points, you can certainly ask the developers to add some. However, randomly shooting Intents at them in hopes of getting a response, even if it temporarily works, is little better than script kiddie tactics -- those developers are not obligated to ensure you code works when they upgrade their app.
Is information about the data that the application operates with private, too?
I do not know what "information about the data that the application operates with" means. Data managed by an application is private by default. Again, application developers can offer integration points for data (e.g., content provider, remote service API) -- some do, some do not.
one of the things that grabbed me was the impression of immense interoperability
Android offers greater interoperability potential than some other mobile platforms. However, using that potential requires consent among the interoper-ees. You cannot unilaterally decide to hack into another app's database, or invoke private activities, just because you feel like it.
Should more Android developers offer more integration points? In the abstract, sure. However, bear in mind that this adds support costs (e.g., answering integration questions) and limits coding flexibility (e.g., need to maintain a stable API for those doing the integrating). Developers cannot be blamed if they do not wish to incur all that.