粘性服务管理

Question

我有一个粘性服务（从 onStartCommand 返回 START_STICKY），它在 AsyncTask 中执行一些代码，但我遇到了一些问题如何以及何时开始、绑定、停止、解除绑定。我只希望在父活动处于活动状态时提供该服务，我不希望它在应用程序关闭时在后台徘徊，但我需要该服务在方向更改后继续存在。目前，我不需要服务在活动的整个活动期间都处于活动状态，因此我在 Service< 中的 AsyncTask 中完成主要工作后调用 stopSelf() /code>，然后在需要时再次启动 Service。有时我需要中断服务正在执行的工作，取消 AsyncTask 并使用不同的数据重新开始。问题是，无论我做什么，我似乎都无法在所有不同的可能场景中得到可靠的解决方案。谁能看一下并告诉我我做错了什么？

我的 Service 是：

public class ChordCalculatorService extends Service {

    private final IBinder mBinder = new LocalBinder();
    private AsyncTask<SearchData, SearchStatusData, List<Item>> currentTask;

    @Override
    public void onCreate() {}

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // We want this service to continue running until it is explicitly
        // stopped, so return sticky.
        return START_STICKY;
    }

    /**
     * Class for clients to access. Because we know this service always runs in
     * the same process as its clients, we don't need to deal with IPC.
     */
    public class LocalBinder extends Binder {
        public ChordCalculatorService getService() {
            return ChordCalculatorService.this;
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    public SearchData getSearchData() {
        return searchData;
    }        

    public void startWork() {
        if (currentTask != null && currentTask.getStatus() == Status.RUNNING) {
            currentTask.cancel(true);
        }
        if(searchData != null) {
            Worker task = new Worker();
            currentTask = task.execute(new SearchData[] { searchData });
        } else {
            Message msg = handler.obtainMessage(ERROR, "No search data set");
            handler.sendMessage(msg);
        }
    }


    class Worker extends AsyncTask<SearchData, SearchStatusData, List<Item>> {
        // ... code ...

        @Override
        protected void onPostExecute(List<Item> result) {
            Message msg = handler.obtainMessage(COMPLETE, new StatusData(Status.STATUS_FINISHED, result));
            handler.sendMessage(msg);
            stopSelf();
        }
    }
}

当前，当创建自定义 View 时，我已启动 Service：

public class MyCustomView extends BasicFretBoardView  {

    private ServiceConnection conn;
    private MyService myService;
    private boolean isServiceStarted;
    private boolean isServiceBound;

    public MyCustomView(Context context, AttributeSet attr) {
        super(context, attr);
        startService();
    }

    public void startService() {
        Intent serviceIntent = new Intent(getContext(), MyService.class);
        conn = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                myService = ((LocalBinder) service).getService();
                myService.registerHandler(serviceHandler);
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                myService = null;
            }
        };

        // Explicitly start the service. Don't use BIND_AUTO_CREATE, since it
        // causes an implicit service stop when the last binder is removed.

        getContext().startService(serviceIntent);
        getContext().bindService(serviceIntent, conn, 0);
        isServiceStarted = true;
        isServiceBound = true;
    }

    public void stopService() {
        if (isServiceStarted) {
            Intent serviceIntent = new Intent(getContext(), MyService.class);
            getContext().stopService(serviceIntent);
            isServiceStarted = false;
        }
        unBindService();
    }


    public void unBindService() {
        if(isServiceBound) {
            getContext().unbindService(conn);
            isServiceBound = false;
        }
    }

    // gets called based on some user interaction
    private void startServiceWork() {
        if(!isServiceStarted) {
            startService();
        } else {
            myService.cancelCalcalation();
        }
        myService.setData(data);
        myService.startWork();
    } 
}

并在 中处理停止服务活动：

public class CustomChordActivity extends Activity {

    // ... code ...

    @Override
    public void onBackPressed() {
        super.onBackPressed();
    }

    @Override
    protected void onPause() {
        if(isFinishing()) {
            chordsView.stopService();
        }
        super.onPause();
    }

    @Override
    protected void onStop() {
        super.onStop();
    }

    @Override
    protected void onDestroy() {
        chordsView.unBindService();
        super.onDestroy();
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }
}

Answer 1

看来您希望任务按需运行，也许 IntentService 会是更合适的选择。当您需要完成工作时（startServiceWork()），您只需启动服务即可启动 AsyncTask。任务完成后，服务将结束。

现在，关于方向变化，您必须实现一个广播接收器，其意图过滤器是“android.intent.action.CONFIGURATION_CHANGED”。 （我假设您希望服务在方向改变时工作）将广播接收器放置在您的活动/主 ui 线程中。这实际上将使广播接收器的托管进程成为主要应用程序进程，从而使从广播接收器内启动服务更加安全。