2. 8. Content Providers and Databases
● Content providers manage access to a structured set of
data. They encapsulate the data, and provide
mechanisms for defining data security.
● Content providers are the standard interface that
connects data in one process with code running in
another process.
● Content providers allow exposing application data to
other applications
● Content providers handle inter-process communication
and secure data access.
3. Content Providers (2)
Content Providers
App 1 App 2
Share data
Search
Feature
Copy/Paste
complex data
File Data
Structured
Data
Handle
Add a level of
abstraction to Data
Handle Database
states
Widgets
CursorLoader and
Callback
SyncAdapter
4. Databases
● Android Supports SQLite database.
● To handle an SQLite database, we need an
“SQLiteDatabase” reference
○ SQLiteDatabase db = openOrCreateDatabase( "name", MODE_PRIVATE,
null); //openOrCreateDatabase called from a context
db.execSQL("SQL query");
6. ContentValues
● ContentValues can be optionally used as a level of
abstraction for statements like INSERT, UPDATE,
REPLACE
● meant to allow using cleaner Java syntax rather than
raw SQL syntax for some common operations
ContentValues cvalues = new ContentValues(); cvalues.
put("columnName1", value1); cvalues.put("columnName2",
value2); ... db.insert("tableName", null, cvalues);
7. Cursor
● Cursor lets you iterate through row results one at a time
● Methods:
getBlob(index), getColumnCount(), getColumnIndex(name),
getColumnName(index), getCount(), getDouble(index),
getFloat(index), getInt(index), getLong(index),
getString(index), moveToPrevious(), ...
8. Cursor (2)
Cursor cursor = db.rawQuery("SELECT * FROM notes");
cursor.moveToFirst();
do {
int id = cursor.getInt(cursor.getColumnIndex("id"));
String email = cursor.getString( cursor.
getColumnIndex("email"));
...
} while (cursor.moveToNext());
cursor.close();
9. 9. Broadcast Receivers
● A broadcast receiver (short receiver) is an Android
component which allows you to register for system or
application events. All registered receivers for an event
are notified by the Android runtime once this event
happens.
● it can be global (can be notified by other applications or
processes) or local (only notified by our appliocation)
● If it’s global, it must be declared in AndroidManifest.xml
● onReceive (Context context, Intent intent) has to be
implemented to handle received intent
10. 10. Services
● service: A background task used by an app
- example: google play music plays the music using a service
- example: Web browser runs a downloader service to retrieve a file
- Useful for long-running tasks, and/or providing functionality that can
be used by other applications
● Android has two kinds of services:
- standard services: for longer jobs; remains running after app closes
- intent services: for shorter jobs; app launches them via intents
● When/if the service is done doing work, it can broadcast
this information to any receivers who are listening
11. 10. Services (2)
Three ways to communicate with a service
- direct access: get the reference from the binder if the service is in
the same process as the activity that started it. In this case, we’re
talking about local services. public methods can be called directly.
Other applications can’t access this service
- Using a Handler and a Messenger: the service is running in another
process but in the same application. Handler and Messenger are
used to simplify IPC (interprocess communication) operations
- through aidl (Android Interface Definition Language): the service is
running in another process and can belong to another application. It’
s an interface for IPC.
12. The service lifecycle
● A service is started by an app’s activity using an intent
● Service operation modes:
- start: the service keeps running until it is manually stopped
- bind: the service keeps running until no “bound” apps are left
● Services have similar methods to activities for lifecycle
events
- onCreate, onDestroy
13. Adding a service in Android Studio
● right-click your project’s java package
● click New Service Service
14. Service class template
public class ServiceClassName extends Service {
/* this method handles a single incoming request */
@Override
public int onStartCommand(Intent intent, int flags, int id) {
// unpack any parameters that were passed to us
String value1 = intent.getStringExtra("key1");
String value2 = intent.getStringExtra("key2");
// do the work that the service needs to do ...
return START_STICKY; // stay running
}
@Override
public IBinder onBind(Intent intent) {
return null; // disable binding
}
}
15. AndroidManifets.xml changes
● to allow your app to use the service, add the following to
your app’s AndroidManifest.XML configuration:
(Android Studio does this for you if you use the New Service option)
- the exported attribut signifies whether other apps are also allowed
to use the service (true=yes, false=no)
<application…>
<service
android:name=”.ServiceClassName”
android:enable=”true”
android:exported=”false” />
16. Starting a service
● In your Activity class:
Intent intent = new Intent(this, ServiceClassName.class);
intent.putExtra("key1", "value1");
intent.putExtra("key2", "value2");
startService(intent); // not startActivity!
● or if the same code is launched from a
fragment
Intent intent = new Intent( getActivity(),
ServiceClassName.class);
...
17. Intent actions
● often a service has several “actions” or
commands it can perform
- example: a music player service can play, stop, pause,...
- example: a chat service can send, receive,...
18. Handler
● Handler: Represents a single piece of code to handle
one job in the queue
- Submit a job to the handler by calling its post method, passing a
Runnable object indicating the code to run
Handler handler = new Handler();
handler.post(new Runnable() {
public void run() {
// the code to process the job
...
}
});
19. Handler (2)
● Handler support communication through a Messenger:
- to send messages, call sendMessage(Message msg)
- to handle received messages, we should implement the method
handleMessage (Message msg)
20. 11. Multimedia
- The Android multimedia framework includes support for
playing variety of common media types,
- audio,
- video
- images
- You can play audio or video from media files stored in
your application's resources (raw resources), from
standalone files in the filesystem, or from a data stream
arriving over a network connection, all using
MediaPlayer APIs.
22. 12. Notifications
● notification: A message displayed to the user
outside of any app’s UI in a top notification
drawer area
- used to indicate system events, status of service tasks, etc
-
● notification can have:
- icons (small, large)
- a title
- a detailed description
- one or more associated actions that will occur when clicked
- ...
23. Notification properties
● setAutoCancel(boolean)
● setColor(argb)
● setContentIntent(intent)
● setContentText(“s”)
● setContentTitle(“s”)
● setGroup(“s”)
● setLargeIcon(bitmap)
● setLights(argb, onMs, offMs)
● setNumber(n)
● setSmallIcon(id)
● setSound(uri)
- whether to hide when clicked
- background color
- intent for action to run when clicked
- detailed description
- large heading text
- group similar notifications together
- image for big icon
- blinking lights
- a large number at right of notifications
- image file for icon
- a sound to play
24. Notification properties (2)
● setTicker(“s”)
● setVisibility(vis)
● setWhen(ms)
- text to scroll across top bar
- whether notification should show
- timestamp of notification
25. Notification with action
● Commonly, when the user clicks on a notification, an action should
occur. (redirect the user to a particular app / activity, etc
- To achieve this, use an intent inside your notification
- Must wrap it inside a “pending intent” object
Notification.Builder builder = ...;
Intent intent = new Intent(this, ActivityClassName.class);
intent.putExtra("key1", "value1");
...
PendingIntent pending = PendingIntent.getActivity(
this, 0, intent, 0);
builder.setContentIntent(pending);
Notification notification = builder.build();
...
