Android中后台任务的最佳实践

最新推荐文章于 2024-03-05 14:34:51 发布

心之所善兮

最新推荐文章于 2024-03-05 14:34:51 发布

阅读量1.1k

点赞数

分类专栏： Android官方文档译文

Android官方文档译文专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1.使用后台Service:IntentService
使用IntentService是一个直接了当的方式来处理后台任务。
但是它有一些局限性，例如无法直接与用户交互；任务是同步进行的，下个任务的执行必须等到上一个任务的完成；它无法被中断。尽管如此但是在大多数情况下，使用它还是一个较好的选择。下面我们来用用它：
使用步骤：

a.创建IntentService，我们创建它的子类：

<span style="font-size:14px;">public class RSSPullService extends IntentService {
    @Override
    protected void onHandleIntent(Intent workIntent) {
        // Gets data from the incoming Intent
        String dataString = workIntent.getDataString();
        ...
        // Do work here, based on the contents of dataString
        ...
    }
}</span>

还有其他IntentService中的回调方法，如onStartCommand()等是被系统自动回调的，我们不要再重写这些方法。

b.在Manifest中注册：

<span style="font-size:14px;"><application
        android:icon="@drawable/icon"
        android:label="@string/app_name">
        ...
        <!--
            Because android:exported is set to "false",
            the service is only available to this app.
        -->
        <service
            android:name=".RSSPullService"
            android:exported="false"/>
        ...
    <application/></span>

注意：这里的service的启动是通过显示intent启动的，所以不要添加 intent filter

c.启动IntentService：可以在activity或者fragment中来启动

<span style="font-size:14px;">/*
 * Creates a new Intent to start the RSSPullService
 * IntentService. Passes a URI in the
 * Intent's "data" field.
 */
mServiceIntent = new Intent(getActivity(), RSSPullService.class);
mServiceIntent.setData(Uri.parse(dataUrl));
// Starts the IntentService
getActivity().startService(mServiceIntent);	</span>

d.回调结果给启动该服务的activity或者fragment：
推荐的方式是在IntentService中使用LocalBroadcastManager来将数据返回，就是发广播了。

<span style="font-size:14px;">public final class Constants {
    ...
    // Defines a custom Intent action
    public static final String BROADCAST_ACTION =
        "com.example.android.threadsample.BROADCAST";
    ...
    // Defines the key for the status "extra" in an Intent
    public static final String EXTENDED_DATA_STATUS =
        "com.example.android.threadsample.STATUS";
    ...
}
public class RSSPullService extends IntentService {
...
    /*
     * Creates a new Intent containing a Uri object
     * BROADCAST_ACTION is a custom Intent action
     */
    Intent localIntent =
            new Intent(Constants.BROADCAST_ACTION)
            // Puts the status into the Intent
            .putExtra(Constants.EXTENDED_DATA_STATUS, status);
    // Broadcasts the Intent to receivers in this app.
    LocalBroadcastManager.getInstance(this).sendBroadcast(localIntent);
...
}</span>

定义一个广播接受者：

<span style="font-size:14px;">// Broadcast receiver for receiving status updates from the IntentService
private class DownloadStateReceiver extends BroadcastReceiver
{
    // Prevents instantiation
    private DownloadStateReceiver() {
    }
    // Called when the BroadcastReceiver gets an Intent it's registered to receive
    @
    public void onReceive(Context context, Intent intent) {
...
        /*
         * Handle Intents here.
         */
...
    }
}</span>

启动广播接收器：

<span style="font-size:14px;"> // The filter's action is BROADCAST_ACTION
        IntentFilter mStatusIntentFilter = new IntentFilter(
                Constants.BROADCAST_ACTION);
    
        // Adds a data filter for the HTTP scheme
        mStatusIntentFilter.addDataScheme("http");	
	// Instantiates a new DownloadStateReceiver
        DownloadStateReceiver mDownloadStateReceiver =
                new DownloadStateReceiver();
        // Registers the DownloadStateReceiver and its intent filters
        LocalBroadcastManager.getInstance(this).registerReceiver(
                mDownloadStateReceiver,
                mStatusIntentFilter);</span>

2.使用CursorLoader，加载Query
a.初始化loader

<span style="font-size:14px;">/*
         * Initializes the CursorLoader. The URL_LOADER value is eventually passed
         * to onCreateLoader().
         */
        getLoaderManager().initLoader(URL_LOADER, null, this);</span>

b.重写一些回调方法

<span style="font-size:14px;">	/*
* Callback that's invoked when the system has initialized the Loader and
* is ready to start the query. This usually happens when initLoader() is
* called. The loaderID argument contains the ID value passed to the
* initLoader() call.
*/
@Override
public Loader<Cursor> onCreateLoader(int loaderID, Bundle bundle)
{
    /*
     * Takes action based on the ID of the Loader that's being created
     */
    switch (loaderID) {
        case URL_LOADER:
            // Returns a new CursorLoader
            return new CursorLoader(
                        getActivity(),   // Parent activity context
                        mDataUrl,        // Table to query
                        mProjection,     // Projection to return
                        null,            // No selection clause
                        null,            // No selection arguments
                        null             // Default sort order
        );
        default:
            // An invalid id was passed in
            return null;
    }
}

/*
 * Defines the callback that CursorLoader calls
 * when it's finished its query
 */
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
    ...
    /*
     * Moves the query results into the adapter, causing the
     * ListView fronting this adapter to re-display
     */
    mAdapter.changeCursor(cursor);
}</span>

3.处理手机的休眠状态：

当手机处于闲置，然后熄灭屏幕后，系统会基本上关闭CPU,来防止电池的电量被快速耗尽。但是如果我们在这种情况下需要依然进行一些操作，例如在播放movies时保证屏幕一直处于亮的状态；例如不必要一定屏幕一直亮着，但是要保证cpu一直工作。

a.保证屏幕亮屏：
在activity中调用 getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
或者在activity的布局文件的根布局中使用 android:keepScreenOn="true"
一般情况下，你不必程序调用来清除该标记。
如果你有这个需求的话，例如间隔多长时间后清除该标记getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON).

b.保证cpu一直工作：PowerManager
我们只有在极端情况下才这么做，而且保证不要持有它们太长时间，因为这会非常影响电池的使用寿命。
需要权限：<uses-permission android:name="android.permission.WAKE_LOCK" />
PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
"MyWakelockTag");
wakeLock.acquire();
在你的后台任务执行完后，尽快的wakelock.release().

或者使用WakefulBroadcastReceiver，
使用这个广播启动一个后台服务，在服务结束后 MyWakefulReceiver.completeWakefulIntent(intent);释放CPU
public class MyWakefulReceiver extends WakefulBroadcastReceiver {

@Override
public void onReceive(Context context, Intent intent) {

// Start the service, keeping the device awake while the service is
// launching. This is the Intent to deliver to the service.
Intent service = new Intent(context, MyIntentService.class);
startWakefulService(context, service);
}
}

public class MyIntentService extends IntentService {
public static final int NOTIFICATION_ID = 1;
private NotificationManager mNotificationManager;
NotificationCompat.Builder builder;
public MyIntentService() {
super("MyIntentService");
}
@Override
protected void onHandleIntent(Intent intent) {
Bundle extras = intent.getExtras();
// Do the work that requires your app to keep the CPU running.
// ...
// Release the wake lock provided by the WakefulBroadcastReceiver.
MyWakefulReceiver.completeWakefulIntent(intent);
}
}

4.使用AlarmManager：进行后台定时循环操作
可以让你的app独立于application之外。你可以使用它来实现例如每天都要执行一个服务获取天气。
闹钟有如下特点：
可以让你使用广播启动服务或其他操作、
可以让你的操作独立于application，甚至即使手机是休眠的。
可以让你不必运行后台service，减少app的资源消耗的同时安排任务。

我们一般有这个需求，在后台每隔一段时间与服务器同步数据。下面是一些建议
a.随机触发网络请求,不要在某一个具体的时间来请求，减少服务器压力
b.保证alarm的频率中等
c.非必要下不要唤醒设备，选择alarm type

选择闹钟类型：
有2个通常使用的闹钟，elapsed real time基于手机开机的时间
eal time clock uses 基于UTC，实时时间，与时区有关
一般推荐使用elapsed real time

闹钟有这些类型：
ELAPSED_REALTIME，基于时间的逃逸数量，以手机启动开始，当手机休眠时也可以，但是不会唤醒手机
ELAPSED_REALTIME_WAKEUP，与上一个类似，但是会唤醒手机
RTC，在指定时刻，不会唤醒手机
RTC_WAKEUP，与上一个类似，会唤醒手机

下面列举少许例子说明：

<span style="font-size:14px;"> ELAPSED_REALTIME_WAKEUP说明
 30分钟后执行，之后每隔30分钟执行一次、
// Hopefully your alarm will have a lower frequency than this!
alarmMgr.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
        AlarmManager.INTERVAL_HALF_HOUR,
        AlarmManager.INTERVAL_HALF_HOUR, alarmIntent);

	
只执行一次	
private AlarmManager alarmMgr;
private PendingIntent alarmIntent;
...
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, AlarmReceiver.class);
alarmIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
alarmMgr.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() +
        60 * 1000, alarmIntent);
	

RTC_WAKEUP.	说明
// Set the alarm to start at approximately 2:00 p.m.
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 14);
// With setInexactRepeating(), you have to use one of the AlarmManager interval
// constants--in this case, AlarmManager.INTERVAL_DAY.
alarmMgr.setInexactRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
        AlarmManager.INTERVAL_DAY, alarmIntent);
	
	

//Wake up the device to fire the alarm at precisely 8:30 a.m., and every 20 minutes thereafter:
private AlarmManager alarmMgr;
private PendingIntent alarmIntent;
...
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, AlarmReceiver.class);
alarmIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
// Set the alarm to start at 8:30 a.m.
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 8);
calendar.set(Calendar.MINUTE, 30);
// setRepeating() lets you specify a precise custom interval--in this case,
// 20 minutes.
alarmMgr.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
        1000 * 60 * 20, alarmIntent);	</span>

<span style="font-size:14px;">取消闹钟：
// If the alarm has been set, cancel it.
if (alarmMgr!= null) {
    alarmMgr.cancel(alarmIntent);
}</span>

在手机设备开机的时候启动闹钟：
默认情况下，当手机关机后，再次重启会取消掉所有的闹钟了。在这种情况下，我们可以这样做来保证手机再次开机的时候自动启动闹钟。

<span style="font-size:14px;">使用步骤：

<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

public class SampleBootReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED")) {
            // Set the alarm here.
        }
    }
}	

<receiver android:name=".SampleBootReceiver"
        android:enabled="false">
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED"></action>
    </intent-filter>
</receiver>	

这个广播有些特别，一旦你启动了它，即使手机重启了，也还会存在的。
我们使能开启：
ComponentName receiver = new ComponentName(context, SampleBootReceiver.class);
PackageManager pm = context.getPackageManager();
pm.setComponentEnabledSetting(receiver,
        PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
        PackageManager.DONT_KILL_APP);
		
在需要的时候关闭：
ComponentName receiver = new ComponentName(context, SampleBootReceiver.class);
PackageManager pm = context.getPackageManager();
pm.setComponentEnabledSetting(receiver,
        PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
        PackageManager.DONT_KILL_APP);</span>

心之所善兮

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android中后台任务的最佳实践

1.使用后台Service:IntentService使用IntentService是一个直接了当的方式来处理后台任务。但是它有一些局限性，例如无法直接与用户交互；任务是同步进行的，下个任务的执行必须等到上一个任务的完成；它无法被中断。尽管如此但是在大多数情况下，使用它还是一个较好的选择。下面我们来用用它：使用步骤：a.创建IntentService，我们创建它的子类：pu
复制链接

扫一扫

专栏目录