camera/processing/ProcessingService.java

/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.camera.processing;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.IBinder;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.os.Process;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;

import com.android.camera.app.CameraServices;
import com.android.camera.app.CameraServicesImpl;
import com.android.camera.debug.Log;
import com.android.camera.session.CaptureSession;
import com.android.camera.session.CaptureSession.ProgressListener;
import com.android.camera.session.CaptureSessionManager;
import com.android.camera.util.AndroidServices;
import com.android.camera2.R;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * A service that processes a {@code ProcessingTask}. The service uses a fifo
 * queue so that only one {@code ProcessingTask} is processed at a time.
 * <p>
 * The service is meant to be called via {@code ProcessingService.addTask},
 * which takes care of starting the service and enqueueing the
 * {@code ProcessingTask} task:
 *
 * <pre>
 * {@code
 * ProcessingTask task = new MyProcessingTask(...);
 * ProcessingService.addTask(task);
 * }
 * </pre>
 */
public class ProcessingService extends Service implements ProgressListener {
    /**
     * Class used to receive broadcast and control the service accordingly.
     */
    public class ServiceController extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getAction() == ACTION_PAUSE_PROCESSING_SERVICE) {
                ProcessingService.this.pause();
            } else if (intent.getAction() == ACTION_RESUME_PROCESSING_SERVICE) {
                ProcessingService.this.resume();
            }
        }
    }

    private static final Log.Tag TAG = new Log.Tag("ProcessingService");
    private static final int THREAD_PRIORITY = Process.THREAD_PRIORITY_BACKGROUND;
    private static final int CAMERA_NOTIFICATION_ID = 2;
    private Notification.Builder mNotificationBuilder;
    private NotificationManager mNotificationManager;

    /** Sending this broadcast intent will cause the processing to pause. */
    public static final String ACTION_PAUSE_PROCESSING_SERVICE =
            "com.android.camera.processing.PAUSE";
    /**
     * Sending this broadcast intent will cause the processing to resume after
     * it has been paused.
     */
    public static final String ACTION_RESUME_PROCESSING_SERVICE =
            "com.android.camera.processing.RESUME";

    private WakeLock mWakeLock;
    private final ServiceController mServiceController = new ServiceController();

    /** Manages the capture session. */
    private CaptureSessionManager mSessionManager;

    private ProcessingServiceManager mProcessingServiceManager;
    private Thread mProcessingThread;
    private volatile boolean mPaused = false;
    private ProcessingTask mCurrentTask;
    private final Lock mSuspendStatusLock = new ReentrantLock();

    @Override
    public void onCreate() {
        mProcessingServiceManager = ProcessingServiceManager.instance();
        mSessionManager = getServices().getCaptureSessionManager();

        // Keep CPU awake while allowing screen and keyboard to switch off.
        PowerManager powerManager = AndroidServices.instance().providePowerManager();
        mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG.toString());
        mWakeLock.acquire();

        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(ACTION_PAUSE_PROCESSING_SERVICE);
        intentFilter.addAction(ACTION_RESUME_PROCESSING_SERVICE);
        LocalBroadcastManager.getInstance(this).registerReceiver(mServiceController, intentFilter);
        mNotificationBuilder = createInProgressNotificationBuilder();
        mNotificationManager = AndroidServices.instance().provideNotificationManager();
    }

    @Override
    public void onDestroy() {
        Log.d(TAG, "Shutting down");
        // TODO: Cancel session in progress...

        // Unlock the power manager, i.e. let power management kick in if
        // needed.
        if (mWakeLock.isHeld()) {
            mWakeLock.release();
        }
        LocalBroadcastManager.getInstance(this).unregisterReceiver(mServiceController);
        stopForeground(true);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "Starting in foreground.");

        // We need to start this service in foreground so that it's not getting
        // killed easily when memory pressure is building up.
        startForeground(CAMERA_NOTIFICATION_ID, mNotificationBuilder.build());

        asyncProcessAllTasksAndShutdown();

        // We want this service to continue running until it is explicitly
        // stopped, so return sticky.
        return START_STICKY;
    }

    @Override
    public IBinder onBind(Intent intent) {
        // We don't provide binding, so return null.
        return null;
    }

    private void pause() {
        Log.d(TAG, "Pausing");
        try {
            mSuspendStatusLock.lock();
            mPaused = true;
            if (mCurrentTask != null) {
                mCurrentTask.suspend();
            }
        } finally {
            mSuspendStatusLock.unlock();
        }
    }

    private void resume() {
        Log.d(TAG, "Resuming");
        try {
            mSuspendStatusLock.lock();
            mPaused = false;
            if (mCurrentTask != null) {
                mCurrentTask.resume();
            }
        } finally {
            mSuspendStatusLock.unlock();
        }
    }

    /**
     * Starts a thread to process all tasks. When no more tasks are in the
     * queue, it exits the thread and shuts down the service.
     */
    private void asyncProcessAllTasksAndShutdown() {
        if (mProcessingThread != null) {
            return;
        }
        mProcessingThread = new Thread("CameraProcessingThread") {
            @Override
            public void run() {
                // Set the thread priority
                android.os.Process.setThreadPriority(THREAD_PRIORITY);

                ProcessingTask task;
                while ((task = mProcessingServiceManager.popNextSession()) != null) {
                    mCurrentTask = task;
                    try {
                        mSuspendStatusLock.lock();
                        if (mPaused) {
                            mCurrentTask.suspend();
                        }
                    } finally {
                        mSuspendStatusLock.unlock();
                    }
                    processAndNotify(task);
                }
                stopSelf();
            }
        };
        mProcessingThread.start();
    }

    /**
     * Processes a {@code ProcessingTask} and updates the notification bar.
     */
    void processAndNotify(ProcessingTask task) {
        if (task == null) {
            Log.e(TAG, "Reference to ProcessingTask is null");
            return;
        }
        CaptureSession session = task.getSession();

        // TODO: Get rid of this null check. There should not be a task without
        // a session.
        if (session == null) {
            // TODO: Timestamp is not required right now, refactor this to make it clearer.
            session = mSessionManager.createNewSession(task.getName(), 0, task.getLocation());
        }
        resetNotification();

        // Adding the listener also causes it to get called for the session's
        // current status message and percent completed.
        session.addProgressListener(this);

        System.gc();
        Log.d(TAG, "Processing start");
        task.process(this, getServices(), session);
        Log.d(TAG, "Processing done");
    }

    private void resetNotification() {
        mNotificationBuilder.setContentText("…").setProgress(100, 0, false);
        postNotification();
    }

    /**
     * Returns the common camera services.
     */
    private CameraServices getServices() {
        return CameraServicesImpl.instance();
    }

    private void postNotification() {
        mNotificationManager.notify(CAMERA_NOTIFICATION_ID, mNotificationBuilder.build());
    }

    /**
     * Creates a notification to indicate that a computation is in progress.
     */
    private Notification.Builder createInProgressNotificationBuilder() {
        return new Notification.Builder(this)
                .setSmallIcon(R.drawable.ic_notification)
                .setWhen(System.currentTimeMillis())
                .setOngoing(true)
                .setContentTitle(this.getText(R.string.app_name));
    }

    @Override
    public void onProgressChanged(int progress) {
        mNotificationBuilder.setProgress(100, progress, false);
        postNotification();
    }

    @Override
    public void onStatusMessageChanged(int messageId) {
        mNotificationBuilder.setContentText(messageId > 0 ? getString(messageId) : "");
        postNotification();
    }
}