apps/CtsVerifier/src/com/android/cts/verifier/car/GarageModeChecker.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2020 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.cts.verifier.car;

 import android.app.job.JobInfo;
 import android.app.job.JobParameters;
 import android.app.job.JobScheduler;
 import android.app.job.JobService;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.os.AsyncTask;
 import android.os.Handler;
 import android.os.Message;
 import android.os.PersistableBundle;
 import android.provider.Settings;
 import android.util.Log;
 import android.util.SparseArray;

 import java.lang.ref.WeakReference;

 public final class GarageModeChecker extends JobService {
     private static final String TAG = GarageModeChecker.class.getSimpleName();

     static final String PREFS_FILE_NAME = "GarageModeChecker_prefs";
     static final String PREFS_INITIATION = "test-initiation";
     static final String PREFS_GARAGE_MODE_START = "garage-mode-start";
     static final String PREFS_GARAGE_MODE_END = "garage-mode-end";
     static final String PREFS_TERMINATION = "termination-time";
     static final String PREFS_JOB_UPDATE = "job-update-time";
     static final String PREFS_HAD_CONNECTIVITY = "had-connectivity";
     static final String PREFS_START_BOOT_COUNT = "start-boot-count";

     static final int SECONDS_PER_ITERATION = 10;
     static final int MS_PER_ITERATION = SECONDS_PER_ITERATION * 1000;

     private static final int GARAGE_JOB_ID = GarageModeTestActivity.class.hashCode();
     private static final String JOB_NUMBER = "job_number";
     private static final String REMAINING_SECONDS = "remaining_seconds";
     // JobScheduler allows a maximum of 10 minutes for a job, but depending on vendor implementation
     // Garage Mode may not last that long. So, max job duration is set to 60 seconds.
     private static final int MAX_SECONDS_PER_JOB = 60;

     private static final int MSG_FINISHED = 0;
     private static final int MSG_RUN_JOB = 1;
     private static final int MSG_CANCEL_JOB = 2;

     private Context mIdleJobContext;

     private boolean mReportFirstExecution = true;

     public static void scheduleAnIdleJob(Context context, int durationSeconds) {
         JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
         // Get the next available job ID
         int highestJobNumber = 0;
         for (JobInfo jobInfo : jobScheduler.getAllPendingJobs()) {
             int jobId = jobInfo.getId();
             if (highestJobNumber < jobId) {
                 highestJobNumber = jobId;
             }
         }
         scheduleJob(context, highestJobNumber + 1, durationSeconds);
     }

     private static void scheduleJob(Context context, int jobNumber, int durationSeconds) {
         JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
         ComponentName jobComponentName = new ComponentName(context, GarageModeChecker.class);
         JobInfo.Builder builder = new JobInfo.Builder(jobNumber, jobComponentName);

         PersistableBundle bundle = new PersistableBundle();
         bundle.putInt(JOB_NUMBER, jobNumber);
         bundle.putInt(REMAINING_SECONDS, durationSeconds);

         JobInfo jobInfo = builder
                 .setRequiresDeviceIdle(true)
                 .setExtras(bundle)
                 .build();
         jobScheduler.schedule(jobInfo);
     }

     private final Handler mHandler = new Handler() {
         private SparseArray<JobParameters> mTaskMap = new SparseArray<>();
         private boolean mHaveContinuousConnectivity = true; // Assume true initially

         @Override
         public void handleMessage(Message msg) {
             JobParameters job = (JobParameters) msg.obj;
             switch (msg.what) {
                 case MSG_FINISHED:
                     mTaskMap.remove(job.getJobId());
                     jobFinished(job, false);
                     break;
                 case MSG_RUN_JOB:
                     checkConnectivity(msg.arg1);
                     GarageModeCheckerTask task = new GarageModeCheckerTask(this, job, msg.arg1);
                     task.execute();
                     mTaskMap.put(job.getJobId(), job);
                     break;
                 case MSG_CANCEL_JOB:
                     JobParameters runningJob = mTaskMap.get(job.getJobId());
                     if (runningJob != null) {
                         removeMessages(MSG_RUN_JOB, runningJob);
                         mTaskMap.remove(job.getJobId());
                     }
                     SharedPreferences prefs = mIdleJobContext.getSharedPreferences(PREFS_FILE_NAME,
                             Context.MODE_PRIVATE);
                     SharedPreferences.Editor editor = prefs.edit();
                     editor.putLong(PREFS_TERMINATION, System.currentTimeMillis());
                     editor.commit();
                     Log.v(TAG, "Idle job was terminated");
                     break;
             }
         }

         private void checkConnectivity(int iteration) {
             if (mHaveContinuousConnectivity) {
                 // Check if we still have internet connectivity
                 NetworkInfo networkInfo = getApplicationContext()
                         .getSystemService(ConnectivityManager.class).getActiveNetworkInfo();
                 mHaveContinuousConnectivity = networkInfo != null
                         && networkInfo.isAvailable() && networkInfo.isConnected();
                 if (iteration == 0 || !mHaveContinuousConnectivity) {
                     // Save the connectivity state on the first pass and
                     // the first time we lose connectivity
                     SharedPreferences prefs = mIdleJobContext.getSharedPreferences(PREFS_FILE_NAME,
                             Context.MODE_PRIVATE);
                     SharedPreferences.Editor editor = prefs.edit();
                     editor.putBoolean(PREFS_HAD_CONNECTIVITY, mHaveContinuousConnectivity);
                     editor.commit();
                 }
             }
         }
     };

     @Override
     public boolean onStopJob(JobParameters jobParameters) {
         Message msg = mHandler.obtainMessage(MSG_CANCEL_JOB, 0, 0, jobParameters);
         mHandler.sendMessage(msg);
         return false;
     }

     @Override
     public boolean onStartJob(final JobParameters jobParameters) {
         mIdleJobContext = getApplicationContext();
         if (mReportFirstExecution) {
             mReportFirstExecution = false;
             // Remember the start time
             SharedPreferences prefs = mIdleJobContext.getSharedPreferences(PREFS_FILE_NAME,
                     Context.MODE_PRIVATE);
             SharedPreferences.Editor editor = prefs.edit();
             editor.putLong(PREFS_GARAGE_MODE_START, System.currentTimeMillis());
             editor.commit();
             Log.v(TAG, "Starting idle job");
         }
         Message msg = mHandler.obtainMessage(MSG_RUN_JOB, 0, 0, jobParameters);
         mHandler.sendMessage(msg);
         return true;
     }

     static int getBootCount(Context context) {
         int bootCount = 0;
         try {
             bootCount = Settings.Global.getInt(context.getContentResolver(),
                     Settings.Global.BOOT_COUNT);
         } catch (Settings.SettingNotFoundException e) {
             Log.e(TAG, "Could not get Settings.Global.BOOT_COUNT: ", e);
         }
         return bootCount;
     }

     private final class GarageModeCheckerTask extends AsyncTask<Void, Void, Boolean> {
         private final WeakReference<Handler> mHandler;
         private final JobParameters mJobParameter;
         private final int mIteration;

         GarageModeCheckerTask(Handler handler, JobParameters jobParameters, int iteration) {
             mHandler = new WeakReference<Handler>(handler);
             mJobParameter = jobParameters;
             mIteration = iteration;
         }

         @Override
         protected Boolean doInBackground(Void... infos) {
             int remainingSeconds = mJobParameter.getExtras().getInt(REMAINING_SECONDS);
             int myMaxTime = Math.min(remainingSeconds, MAX_SECONDS_PER_JOB);
             int elapsedSeconds = SECONDS_PER_ITERATION * mIteration;
             long now = System.currentTimeMillis();
             SharedPreferences prefs = mIdleJobContext.getSharedPreferences(PREFS_FILE_NAME,
                     Context.MODE_PRIVATE);
             SharedPreferences.Editor editor = null;

             if (elapsedSeconds >= myMaxTime + SECONDS_PER_ITERATION) {
                 // This job is done
                 if (myMaxTime == remainingSeconds) {
                     // This is the final job. Note the completion time.
                     editor = prefs.edit();
                     editor.putLong(PREFS_GARAGE_MODE_END, now);
                     editor.commit();
                     Log.v(TAG, "Idle job is finished");
                 }
                 return false;
             }

             editor = prefs.edit();
             editor.putLong(PREFS_JOB_UPDATE, now);
             editor.commit();
             if (elapsedSeconds >= myMaxTime && (myMaxTime < remainingSeconds)) {
                 // This job is about to finish and there is more time remaining.
                 // Schedule another job.
                 scheduleJob(mIdleJobContext, mJobParameter.getJobId() + 1,
                         remainingSeconds - elapsedSeconds);
             }
             return true;
         }

         @Override
         protected void onPostExecute(Boolean result) {
             final Handler handler = mHandler.get();
             if (handler == null) {
                 return;
             }
             if (result) {
                 Message msg = handler.obtainMessage(MSG_RUN_JOB, mIteration + 1, 0, mJobParameter);
                 handler.sendMessageDelayed(msg, MS_PER_ITERATION);
             } else {
                 Message msg = handler.obtainMessage(MSG_FINISHED, 0, 0, mJobParameter);
                 handler.sendMessage(msg);
             }
         }
     }
 }
	/*
	* Copyright (C) 2020 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.cts.verifier.car;

	import android.app.job.JobInfo;
	import android.app.job.JobParameters;
	import android.app.job.JobScheduler;
	import android.app.job.JobService;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.SharedPreferences;
	import android.net.ConnectivityManager;
	import android.net.NetworkInfo;
	import android.os.AsyncTask;
	import android.os.Handler;
	import android.os.Message;
	import android.os.PersistableBundle;
	import android.provider.Settings;
	import android.util.Log;
	import android.util.SparseArray;

	import java.lang.ref.WeakReference;

	public final class GarageModeChecker extends JobService {
	private static final String TAG = GarageModeChecker.class.getSimpleName();

	static final String PREFS_FILE_NAME = "GarageModeChecker_prefs";
	static final String PREFS_INITIATION = "test-initiation";
	static final String PREFS_GARAGE_MODE_START = "garage-mode-start";
	static final String PREFS_GARAGE_MODE_END = "garage-mode-end";
	static final String PREFS_TERMINATION = "termination-time";
	static final String PREFS_JOB_UPDATE = "job-update-time";
	static final String PREFS_HAD_CONNECTIVITY = "had-connectivity";
	static final String PREFS_START_BOOT_COUNT = "start-boot-count";

	static final int SECONDS_PER_ITERATION = 10;
	static final int MS_PER_ITERATION = SECONDS_PER_ITERATION * 1000;

	private static final int GARAGE_JOB_ID = GarageModeTestActivity.class.hashCode();
	private static final String JOB_NUMBER = "job_number";
	private static final String REMAINING_SECONDS = "remaining_seconds";
	// JobScheduler allows a maximum of 10 minutes for a job, but depending on vendor implementation
	// Garage Mode may not last that long. So, max job duration is set to 60 seconds.
	private static final int MAX_SECONDS_PER_JOB = 60;

	private static final int MSG_FINISHED = 0;
	private static final int MSG_RUN_JOB = 1;
	private static final int MSG_CANCEL_JOB = 2;

	private Context mIdleJobContext;

	private boolean mReportFirstExecution = true;

	public static void scheduleAnIdleJob(Context context, int durationSeconds) {
	JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
	// Get the next available job ID
	int highestJobNumber = 0;
	for (JobInfo jobInfo : jobScheduler.getAllPendingJobs()) {
	int jobId = jobInfo.getId();
	if (highestJobNumber < jobId) {
	highestJobNumber = jobId;
	}
	}
	scheduleJob(context, highestJobNumber + 1, durationSeconds);
	}

	private static void scheduleJob(Context context, int jobNumber, int durationSeconds) {
	JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
	ComponentName jobComponentName = new ComponentName(context, GarageModeChecker.class);
	JobInfo.Builder builder = new JobInfo.Builder(jobNumber, jobComponentName);

	PersistableBundle bundle = new PersistableBundle();
	bundle.putInt(JOB_NUMBER, jobNumber);
	bundle.putInt(REMAINING_SECONDS, durationSeconds);

	JobInfo jobInfo = builder
	.setRequiresDeviceIdle(true)
	.setExtras(bundle)
	.build();
	jobScheduler.schedule(jobInfo);
	}

	private final Handler mHandler = new Handler() {
	private SparseArray<JobParameters> mTaskMap = new SparseArray<>();
	private boolean mHaveContinuousConnectivity = true; // Assume true initially

	@Override
	public void handleMessage(Message msg) {
	JobParameters job = (JobParameters) msg.obj;
	switch (msg.what) {
	case MSG_FINISHED:
	mTaskMap.remove(job.getJobId());
	jobFinished(job, false);
	break;
	case MSG_RUN_JOB:
	checkConnectivity(msg.arg1);
	GarageModeCheckerTask task = new GarageModeCheckerTask(this, job, msg.arg1);
	task.execute();
	mTaskMap.put(job.getJobId(), job);
	break;
	case MSG_CANCEL_JOB:
	JobParameters runningJob = mTaskMap.get(job.getJobId());
	if (runningJob != null) {
	removeMessages(MSG_RUN_JOB, runningJob);
	mTaskMap.remove(job.getJobId());
	}
	SharedPreferences prefs = mIdleJobContext.getSharedPreferences(PREFS_FILE_NAME,
	Context.MODE_PRIVATE);
	SharedPreferences.Editor editor = prefs.edit();
	editor.putLong(PREFS_TERMINATION, System.currentTimeMillis());
	editor.commit();
	Log.v(TAG, "Idle job was terminated");
	break;
	}
	}

	private void checkConnectivity(int iteration) {
	if (mHaveContinuousConnectivity) {
	// Check if we still have internet connectivity
	NetworkInfo networkInfo = getApplicationContext()
	.getSystemService(ConnectivityManager.class).getActiveNetworkInfo();
	mHaveContinuousConnectivity = networkInfo != null
	&& networkInfo.isAvailable() && networkInfo.isConnected();
	if (iteration == 0 \|\| !mHaveContinuousConnectivity) {
	// Save the connectivity state on the first pass and
	// the first time we lose connectivity
	SharedPreferences prefs = mIdleJobContext.getSharedPreferences(PREFS_FILE_NAME,
	Context.MODE_PRIVATE);
	SharedPreferences.Editor editor = prefs.edit();
	editor.putBoolean(PREFS_HAD_CONNECTIVITY, mHaveContinuousConnectivity);
	editor.commit();
	}
	}
	}
	};

	@Override
	public boolean onStopJob(JobParameters jobParameters) {
	Message msg = mHandler.obtainMessage(MSG_CANCEL_JOB, 0, 0, jobParameters);
	mHandler.sendMessage(msg);
	return false;
	}

	@Override
	public boolean onStartJob(final JobParameters jobParameters) {
	mIdleJobContext = getApplicationContext();
	if (mReportFirstExecution) {
	mReportFirstExecution = false;
	// Remember the start time
	SharedPreferences prefs = mIdleJobContext.getSharedPreferences(PREFS_FILE_NAME,
	Context.MODE_PRIVATE);
	SharedPreferences.Editor editor = prefs.edit();
	editor.putLong(PREFS_GARAGE_MODE_START, System.currentTimeMillis());
	editor.commit();
	Log.v(TAG, "Starting idle job");
	}
	Message msg = mHandler.obtainMessage(MSG_RUN_JOB, 0, 0, jobParameters);
	mHandler.sendMessage(msg);
	return true;
	}

	static int getBootCount(Context context) {
	int bootCount = 0;
	try {
	bootCount = Settings.Global.getInt(context.getContentResolver(),
	Settings.Global.BOOT_COUNT);
	} catch (Settings.SettingNotFoundException e) {
	Log.e(TAG, "Could not get Settings.Global.BOOT_COUNT: ", e);
	}
	return bootCount;
	}

	private final class GarageModeCheckerTask extends AsyncTask<Void, Void, Boolean> {
	private final WeakReference<Handler> mHandler;
	private final JobParameters mJobParameter;
	private final int mIteration;

	GarageModeCheckerTask(Handler handler, JobParameters jobParameters, int iteration) {
	mHandler = new WeakReference<Handler>(handler);
	mJobParameter = jobParameters;
	mIteration = iteration;
	}

	@Override
	protected Boolean doInBackground(Void... infos) {
	int remainingSeconds = mJobParameter.getExtras().getInt(REMAINING_SECONDS);
	int myMaxTime = Math.min(remainingSeconds, MAX_SECONDS_PER_JOB);
	int elapsedSeconds = SECONDS_PER_ITERATION * mIteration;
	long now = System.currentTimeMillis();
	SharedPreferences prefs = mIdleJobContext.getSharedPreferences(PREFS_FILE_NAME,
	Context.MODE_PRIVATE);
	SharedPreferences.Editor editor = null;

	if (elapsedSeconds >= myMaxTime + SECONDS_PER_ITERATION) {
	// This job is done
	if (myMaxTime == remainingSeconds) {
	// This is the final job. Note the completion time.
	editor = prefs.edit();
	editor.putLong(PREFS_GARAGE_MODE_END, now);
	editor.commit();
	Log.v(TAG, "Idle job is finished");
	}
	return false;
	}

	editor = prefs.edit();
	editor.putLong(PREFS_JOB_UPDATE, now);
	editor.commit();
	if (elapsedSeconds >= myMaxTime && (myMaxTime < remainingSeconds)) {
	// This job is about to finish and there is more time remaining.
	// Schedule another job.
	scheduleJob(mIdleJobContext, mJobParameter.getJobId() + 1,
	remainingSeconds - elapsedSeconds);
	}
	return true;
	}

	@Override
	protected void onPostExecute(Boolean result) {
	final Handler handler = mHandler.get();
	if (handler == null) {
	return;
	}
	if (result) {
	Message msg = handler.obtainMessage(MSG_RUN_JOB, mIteration + 1, 0, mJobParameter);
	handler.sendMessageDelayed(msg, MS_PER_ITERATION);
	} else {
	Message msg = handler.obtainMessage(MSG_FINISHED, 0, 0, mJobParameter);
	handler.sendMessage(msg);
	}
	}
	}
	}