The Android development environment is based on Java and uses many of the same techniques
we've seen in Java SE (Standard Edition). For instance, you will recognize the Event-Handling
model from our Applet discussions.
The Android Operating System (OS) is Linux-based.
Android Developer Terms
- An Activity is the term used for a single UI screen in your App.
Your App may have multiple screens; each would be its own Activity. Guess what the class-name is??
More details at: Activities
- A Service is used by your App and is used for a task that runs in the background.
It does not have a UI.
More details at: Services
- A Content Provider manages the data your App uses.
More details at: Content Providers
- A Broadcast Receiver is the term used for the code in your App that recieves and
process messages from the system or that informs other parts of the system that your App
is available.
More details at: BroadcastReciever class
- To make your App available for people to load on their Android phones, you will need to
publish it.
More details at:
Publishing Overview
- You can also directly run the App (and the debugger) by connecting your Android
phone to your development computer via the USB port.
Other terms
- An Intent is a message that allows the different components of an App to communicate.
More details at: Intents and Intent Filters
And more at: Intent class
- The term stack refers to a list of things that follow LIFO (last-in, first-out). Think
of a stack of trays in a cafeteria ...
- Activities and the use of the Back key are managed with what is called the back stack.
More details at:
Tasks and Back Stack
- The term user focus refers to the part of a program that is "active". It can refer
to the active component in a GUI or to the active "Activity" (screen) in an App.
- A manifest file is a special XML file that describes the files that make up the package
for your App. The IDE (for instance Eclipse) will create this for you.
More details at:
The AndroidManifest.xml File
Note: a manifest file is also used for creating a "runnable jar", which is a the collection of
files used to run your Java application. They user can just double-click on it to run the
application. An IDE will also generate the manifest for you when you export your code to a
runnable jar.
- A callback is traditionally a method that is passed to other code as a pointer.
The idea is that the function is "registered" with the other code, which doesn't have
to know anything about the function to call it, other than the signature.
Java doesn't support passing functions as pointers, but achieves the same thing with interfaces.
Other helpful references: