android.content.Intent type.
Your code can send them to the Android system defining the components you are targeting.
For example, via the startActivity() method you can define that the intent should be used to start an activity.Bundle.
This data can be used by the receiving component.
| Method | Description |
|---|---|
onAttach() |
The fragment instance is associated with an activity
instance.The fragment and the
activity is not fully initialized.
Typically you get in this method a
reference to
the
activity which
uses the fragment for further initialization work.
|
onCreate() |
Fragment is created. The
onCreate()
method is called after the
onCreate()
method of the activity but before the
onCreateView()
method of the fragment. |
onCreateView() |
The fragment instance creates its view
hierarchy. In the
onCreateView()
method the
fragment
creates its user
interface. Here you can inflate
a layout via
the
inflate()
method call of the
Inflator
object passed as a parameter to this method.
In this method you should not interactive with the activity,
the activity is not yet fully initialized.
There is no need to
implement this method for headless
fragments
.The
inflated views become part of the view hierarchy of its
containing
activity. |
onActivityCreated() |
The
onActivityCreated()
is called after the
onCreateView()
method when the host
activity
is created.
Activity and fragment instance have been created as
well as
the
view
hierarchy of the activity.
At this point, view can
be accessed with
the
findViewById()
method.
example.
In this method you can instantiate objects which require a
Context
object. |
onStart() |
The
onStart()
method is called once the
fragment
gets visible. |
onResume()
|
Fragment becomes active.
|
onPause() |
Fragment is visible but becomes not active anymore, e.g.,
if
another activity is animating on top of the activity which
contains the fragment.
|
onStop() |
Fragment becomes not visible.
|
onDestroyView() |
Destroys the view of the fragment. If the fragment is
recreated
from the backstack this method is called and afterwards
the
onCreateView
method. |
onDestroy()
|
Not guaranteed to be called by the Android platform.
|
Context class.
Therefore you have to use the getActivity() method to get the parent activity.Context.registerReceiver()
and
Context.unregisterReceiver()
methods.Context.unregisterReceiver() method.
If you forget this, the Android system reports a leaked broadcast receiver error.
For instance, if you registered a receive in onResume() methods of your activity, you should unregister it in the onPause() method. PackageManager
class to enable or disable receivers registered in your
AndroidManifest.xml
file.ComponentName receiver = new ComponentName(context, myReceiver.class);
PackageManager pm = context.getPackageManager();
pm.setComponentEnabledSetting(receiver,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
PackageManager.DONT_KILL_APP);sendStickyBroadcast(Intent)
method, the corresponding
intent
is sticky, meaning the intent
you are sending stays around after the
broadcast is complete.// Register for the battery changed event
IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
/ Intent is sticky so using null as receiver works fine
// return value contains the status
Intent batteryStatus = this.registerReceiver(null, filter);
// Are we charging / charged?
int status = batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
boolean isCharging = status == BatteryManager.BATTERY_STATUS_CHARGING
|| status == BatteryManager.BATTERY_STATUS_FULL;
boolean isFull = status == BatteryManager.BATTERY_STATUS_FULL;
// How are we charging?
int chargePlug = batteryStatus.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
boolean usbCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_USB;
boolean acCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_AC; registerReceiver(BroadcastReceiver,
IntentFilter)'
. This also works for a null
`BroadcastReceiver
.sendBroadcast(Intent)
.<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<EditText
android:id="@+id/time"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:hint="Number of seconds"
android:inputType="numberDecimal" >
</EditText>
<Button
android:id="@+id/ok"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="startAlert"
android:text="Start Counter" >
</Button>
</LinearLayout>package de.vogella.android.alarm;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Vibrator;
import android.widget.Toast;
public class MyBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Toast.makeText(context, "Don't panik but your time is up!!!!.",
Toast.LENGTH_LONG).show();
// Vibrate the mobile phone
Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
vibrator.vibrate(2000);
}
}<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="de.vogella.android.alarm"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="15" />
<uses-permission android:name="android.permission.VIBRATE" >
</uses-permission>
<application
android:icon="@drawable/icon"
android:label="@string/app_name" >
<activity
android:name=".AlarmActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<receiver android:name="MyBroadcastReceiver" >
</receiver>
</application>
</manifest>AlarmActivity
class to the
following. This activity creates an
intent to start the
receiver and register this intent with the alarm manager service.package de.vogella.android.alarm;
import android.app.Activity;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
public class AlarmActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
public void startAlert(View view) {
EditText text = (EditText) findViewById(R.id.time);
int i = Integer.parseInt(text.getText().toString());
Intent intent = new Intent(this, MyBroadcastReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(
this.getApplicationContext(), 234324243, intent, 0);
AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()
+ (i * 1000), pendingIntent);
Toast.makeText(this, "Alarm set in " + i + " seconds",
Toast.LENGTH_LONG).show();
}
}
de.vogella.android.receiver.phone
. Also create an activity.MyPhoneReceiver
class.package de.vogella.android.receiver.phone;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.telephony.TelephonyManager;
import android.util.Log;
public class MyPhoneReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Bundle extras = intent.getExtras();
if (extras != null) {
String state = extras.getString(TelephonyManager.EXTRA_STATE);
Log.w("MY_DEBUG_TAG", state);
if (state.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
String phoneNumber = extras
.getString(TelephonyManager.EXTRA_INCOMING_NUMBER);
Log.w("MY_DEBUG_TAG", phoneNumber);
}
}
}
}android.permission.READ_PHONE_STATE
permission to your manifest file which allows you to listen to state
changes in your receiver. Also Register your receiver in your
manifest
file. The resulting manifest should be similar to the
following listing.<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="de.vogella.android.receiver.phone"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="15" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" >
</uses-permission>
<application
android:icon="@drawable/icon"
android:label="@string/app_name" >
<activity
android:name=".MainActivity"
android:label="@string/title_activity_main" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<receiver android:name="MyPhoneReceiver" >
<intent-filter>
<action android:name="android.intent.action.PHONE_STATE" >
</action>
</intent-filter>
</receiver>
</application>
</manifest>LogCat
view.PendingIntent
via
the
getBroadcast()
method of the
PendingIntent
class.
To perform an activity via a
pending intent, you receive the
activity via
PendingIntent.getActivity()
.android.intent.action.BOOT_COMPLETED
system event. This requires the
android.permission.RECEIVE_BOOT_COMPLETED
permission.BOOT_COMPLETED
event in the Android manifest file.<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="de.vogella.android.ownservice.local"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="10" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<application
android:icon="@drawable/icon"
android:label="@string/app_name" >
<activity
android:name=".ServiceConsumerActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<receiver android:name="MyScheduleReceiver" >
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>
<receiver android:name="MyStartServiceReceiver" >
</receiver>
</application>
</manifest> import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
public class MyReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
// assumes WordService is a registered service
Intent intent = new Intent(context, WordService.class);
context.startService(intent);
}
}android.intent.action.BOOT_COMPLETED
event. In this case register it for the
`android.intent.action.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE
`
event. android.intent.action.BOOT_COMPLETED
events.
Intent
class. Other Android system classes also define events, e.g., the
TelephonyManager
defines events for the change of the phone state.
As of Android 3.1 the Android system excludes all receiver from receiving intents by default if the corresponding application has never been started by the user or if the user explicitly stopped the application via the Android menu (in Manage ▸ Application ).
This is an additional security feature as the user can be sure that only the applications he started will receive broadcast intents.
Before API level 11, you could not perform any asynchronous operation in the onReceive() method, because once the onReceive() method had been finished, the Android system was allowed to recycle that component. If you have potentially long running operations, you should trigger a service instead.
Since Android API 11 you can call the goAsync() method. This method returns an object of the PendingResult type. The Android system considers the receiver as alive until you call the PendingResult.finish() on this object. With this option you can trigger asynchronous processing in a receiver. As soon as that thread has completed, its task calls finish() to indicate to the Android system that this component can be recycled.
Implementation
A receiver can be registered via the AndroidManifest.xml file.
Alternatively to this static registration, you can also register a receiver dynamically via the Context.registerReceiver() method.
The implementing class for a receiver extends the BroadcastReceiver class.
If the event for which the broadcast receiver has registered happens, the onReceive() method of the receiver is called by the Android system.
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.
For example, applications can register for the ACTION_BOOT_COMPLETED system event which is fired once the Android system has completed the boot process.
|
|
Android provides the LocalBroadcastManager
class in the support library v4. This is a helper class to register
for
and send broadcasts of Intents to local objects within your
process. This approach improves security as the broadcast events
are only visible within your process and is faster than using
standard events. |
Messenger
via the
Intent
data it receives from the
activity. If the
Messenger
is bound to a
Handler
in the
activity,
the
service
can send objects of type
Message
to the
activity.Messenger
is parcelable, which means it can be passed to another process and
you
can use this object to send
Messages
to the
Handler
in the
activity.Messenger
also provides the method
getBinder()
which allows passing a
Messenger
to the
activity. The
activity
can therefore send
Messages
to the
service.Service
runs in
a separate
process via the <android:process=":process_description">
attribute.<service
android:name="WordService"
android:process=":my_process"
android:icon="@drawable/icon"
android:label="@string/service_name"
>
</service>Service
is private to its declaring application. If the colon is not used, the
Service
would be a global process and can be used by other Android
applications.| Note: If you want to make a service to other Android application available, they must run in their own process. |
bindService()
method to start the
service.ServiceConnection
object as a parameter which is called on the service start and when finishing its
onBind()
method. This method
returns a
IBinder
object to the
ServiceConnection.IBinder
object
can be used
by the
activity
to communicate
with the
service.onStartCommand()
method in the service is called with the
Intent
object used for the
bindService()
method.IntentService
class for your service implementation.IntentService
is used to perform a certain task in the background. Once
done, the
instance of
IntentService
terminates itself automatically. An example for its usage would be
downloading certain resources from the internet.IntentService
class offers the
onHandleIntent()
method which will be asynchronously called by the Android system.Service
class
or one
of
its subclasses. <service
android:name="MyService"
android:icon="@drawable/icon"
android:label="@string/service_name"
>
</service> public class MyService extends Service {
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
//TODO do something useful
return Service.START_NOT_STICKY;
}
@Override
public IBinder onBind(Intent intent) {
//TODO for communication return IBinder implementation
return null;
}
}startService(intent)
method.// use this to start and trigger a service
Intent i= new Intent(context, MyService.class);
// potentially add data to the intent
i.putExtra("KEY1", "Value to be used by the service");
context.startService(i); bindService()
method call. This allows you to communicate directly with the
service.
We discuss that later.startService(intent)
method is called and the
service is not yet running, the service
object is
created and
the
onCreate()
method of the service is called.onStartCommand(intent)
method in the
service
is called.
It passes in the
Intent
object
from the
startService(intent)
call.startService(intent)
is called while the service
is running, its
onStartCommand()
is also called. Therefore your
service
needs to be prepared that
onStartCommand()
can be called several times.
What if you call this method twice in your code? Do you have to worry about synchronizing the onStartCommand()
method call?
No, this method is called by the Android system in the main user
interface thread, therefore it cannot be called simultaneously from two
different threads.
|
startService()
method.onStartCommand()
method call, the service returns an
int
which defines its restart behavior in case the service gets terminated
by the Android platform. You can use the constants, the most common
options are described by the following table.| Option | Description |
|---|---|
Service.START_STICKY
|
Service is restarted if it gets terminated.
Intent data passed to the
onStartCommand method is null.
Used for services which manages their own state and do not depend on the Intent data. |
Service.START_NOT_STICKY
|
Service is not restarted.
Used for services which are periodically triggered anyway.
The service is only restarted if the runtime has pending
startService() calls since the service termination. |
Service.START_REDELIVER_INTENT
|
Similar to Service.START_STICKY but the original
Intent is re-delivered to the onStartCommand method. |
You can check if the service was restarted via the
Intent.getFlags()
method.
START_FLAG_REDELIVERY
(in case the service was started with
Service.START_REDELIVER_INTENT)
or
START_FLAG_RETRY
(in case the service was started with Service.START_STICKY)
is
passed.
|
stopService()
method. No matter how frequently you called the
startService(intent)
method, one
call to the
stopService()
method
stops the service.stopSelf()
method. This is typically done if the service finishes its work.