hostsidetests/car/app/src/android/car/cts/app/CarWatchdogTestActivity.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2021 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 android.car.cts.app;

 import android.app.Activity;
 import android.car.Car;
 import android.car.watchdog.CarWatchdogManager;
 import android.car.watchdog.IoOveruseStats;
 import android.car.watchdog.ResourceOveruseStats;
 import android.content.Intent;
 import android.os.Bundle;
 import android.os.SystemClock;
 import android.util.Log;

 import androidx.annotation.GuardedBy;

 import java.io.File;
 import java.io.FileDescriptor;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InterruptedIOException;
 import java.io.PrintWriter;
 import java.nio.file.Files;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;

 public final class CarWatchdogTestActivity extends Activity {
     private static final String TAG = CarWatchdogTestActivity.class.getSimpleName();
     private static final String BYTES_TO_KILL = "bytes_to_kill";
     private static final long TEN_MEGABYTES = 1024 * 1024 * 10;
     private static final long TWO_HUNDRED_MEGABYTES = 1024 * 1024 * 200;
     private static final int DISK_DELAY_MS = 4000;
     private static final double WARN_THRESHOLD_PERCENT = 0.8;
     private static final double EXCEED_WARN_THRESHOLD_PERCENT = 0.9;

     private final ExecutorService mExecutor = Executors.newSingleThreadExecutor();
     private final Object mLock = new Object();

     @GuardedBy("mLock")
     private CarWatchdogManager mCarWatchdogManager;

     private String mDumpMessage = "";
     private Car mCar;
     private File mTestDir;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         initCarApi();
         try {
             mTestDir =
                     Files.createTempDirectory(getFilesDir().toPath(), "testDir").toFile();
         } catch (IOException e) {
             setDumpMessage("ERROR: " + e.getMessage());
             finish();
             return;
         }
         mExecutor.execute(
                 () -> {
                     synchronized (mLock) {
                         if (mCarWatchdogManager == null) {
                             Log.e(TAG, "CarWatchdogManager is null.");
                             finish();
                             return;
                         }
                     }
                     IoOveruseListener listener = addResourceOveruseListener();
                     try {
                         if (!writeToDisk(TEN_MEGABYTES)) {
                             finish();
                             return;
                         }

                         long remainingBytes = fetchRemainingBytes(TEN_MEGABYTES);
                         if (remainingBytes == 0) {
                             Log.d(TAG, "Remaining bytes is 0 after writing " + TEN_MEGABYTES
                                     + " bytes to disk.");
                             finish();
                             return;
                         }

                         /*
                          * Warning notification is received as soon as exceeding
                          * |WARN_THRESHOLD_PERCENT|. So, set expected minimum written bytes to
                          * |WARN_THRESHOLD_PERCENT| of the overuse threshold.
                          */
                         long bytesToWarnThreshold =
                                 (long) (TWO_HUNDRED_MEGABYTES * WARN_THRESHOLD_PERCENT);

                         listener.setExpectedMinWrittenBytes(bytesToWarnThreshold);

                         long bytesToExceedWarnThreshold =
                                 (long) Math.ceil(remainingBytes
                                         * EXCEED_WARN_THRESHOLD_PERCENT);

                         if (!writeToDisk(bytesToExceedWarnThreshold)) {
                             finish();
                             return;
                         }

                         listener.checkIsNotified();
                     } finally {
                         synchronized (mLock) {
                             mCarWatchdogManager.removeResourceOveruseListener(listener);
                         }
                         /* Foreground mode bytes dumped after removing listener to ensure hostside
                          * receives dump message after test is finished.
                          */
                         listener.dumpForegroundModeBytes();
                     }
                 });
     }

     @Override
     protected void onNewIntent(Intent intent) {
         super.onNewIntent(intent);

         setDumpMessage("");
         Bundle extras = intent.getExtras();
         if (extras == null) {
             Log.w(TAG, "onNewIntent: empty extras");
             return;
         }
         long remainingBytes = extras.getLong(BYTES_TO_KILL);
         Log.d(TAG, "Bytes to kill: " + remainingBytes);
         if (remainingBytes == 0) {
             Log.w(TAG, "onNewIntent: remaining bytes is 0");
             return;
         }
         mExecutor.execute(() -> {
             synchronized (mLock) {
                 if (mCarWatchdogManager == null) {
                     Log.e(TAG, "onNewIntent: CarWatchdogManager is null.");
                     finish();
                     return;
                 }
             }
             IoOveruseListener listener = addResourceOveruseListener();
             try {
                 listener.setExpectedMinWrittenBytes(TWO_HUNDRED_MEGABYTES);

                 writeToDisk(remainingBytes);

                 listener.checkIsNotified();
             } finally {
                 synchronized (mLock) {
                     mCarWatchdogManager.removeResourceOveruseListener(listener);
                 }
                 /* Foreground mode bytes dumped after removing listener to ensure hostside
                  * receives dump message after test is finished.
                  */
                 listener.dumpForegroundModeBytes();
             }
         });
     }

     @Override
     public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
         if (mDumpMessage.isEmpty()) {
             return;
         }
         writer.printf("%s: %s\n", TAG, mDumpMessage);
         Log.i(TAG, "Dumping message: '" + mDumpMessage + "'");
     }

     @Override
     protected void onDestroy() {
         if (mCar != null) {
             mCar.disconnect();
         }
         if (mTestDir.delete()) {
             Log.i(TAG, "Deleted directory '" + mTestDir.getAbsolutePath() + "' successfully");
         } else {
             Log.e(TAG, "Failed to delete directory '" + mTestDir.getAbsolutePath() + "'");
         }
         super.onDestroy();
     }

     private void initCarApi() {
         if (mCar != null && mCar.isConnected()) {
             mCar.disconnect();
             mCar = null;
         }
         mCar = Car.createCar(this, null, Car.CAR_WAIT_TIMEOUT_WAIT_FOREVER,
                 this::initManagers);
     }

     private void initManagers(Car car, boolean ready) {
         synchronized (mLock) {
             if (ready) {
                 mCarWatchdogManager = (CarWatchdogManager) car.getCarManager(
                         Car.CAR_WATCHDOG_SERVICE);
                 Log.d(TAG, "initManagers() completed");
             } else {
                 mCarWatchdogManager = null;
                 Log.wtf(TAG, "mCarWatchdogManager set to be null");
             }
         }
     }

     private IoOveruseListener addResourceOveruseListener() {
         IoOveruseListener listener = new IoOveruseListener();
         synchronized (mLock) {
             mCarWatchdogManager.addResourceOveruseListener(getMainExecutor(),
                     CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO, listener);
         }
         return listener;
     }

     private boolean writeToDisk(long bytes) {
         File uniqueFile = new File(mTestDir, Long.toString(System.nanoTime()));
         boolean result = writeToFile(uniqueFile, bytes);
         if (uniqueFile.delete()) {
             Log.i(TAG, "Deleted file: " + uniqueFile.getAbsolutePath());
         } else {
             Log.e(TAG, "Failed to delete file: " + uniqueFile.getAbsolutePath());
         }
         return result;
     }

     private boolean writeToFile(File uniqueFile, long bytes) {
         long writtenBytes = 0;
         try (FileOutputStream fos = new FileOutputStream(uniqueFile)) {
             Log.d(TAG, "Attempting to write " + bytes + " bytes");
             writtenBytes = writeToFos(fos, bytes);
             if (writtenBytes < bytes) {
                 setDumpMessage("ERROR: Failed to write '" + bytes
                         + "' bytes to disk. '" + writtenBytes
                         + "' bytes were successfully written, while '" + (bytes - writtenBytes)
                         + "' bytes were pending at the moment the exception occurred.");
                 return false;
             }
             fos.getFD().sync();
             // Wait for the IO event to propagate to the system
             Thread.sleep(DISK_DELAY_MS);
             return true;
         } catch (IOException | InterruptedException e) {
             String message;
             if (e instanceof IOException) {
                 message = "I/O exception";
             } else {
                 message = "Thread interrupted";
                 Thread.currentThread().interrupt();
             }
             if (writtenBytes > 0) {
                 message += " after successfully writing to disk.";
             }
             Log.e(TAG, message, e);
             setDumpMessage("ERROR: " + message);
             return false;
         }
     }

     private long writeToFos(FileOutputStream fos, long remainingBytes) {
         long totalBytesWritten = 0;
         while (remainingBytes != 0) {
             int writeBytes =
                     (int) Math.min(Integer.MAX_VALUE,
                             Math.min(Runtime.getRuntime().freeMemory(), remainingBytes));
             try {
                 fos.write(new byte[writeBytes]);
             }  catch (InterruptedIOException e) {
                 Thread.currentThread().interrupt();
                 continue;
             } catch (IOException e) {
                 Log.e(TAG, "I/O exception while writing " + writeBytes + " to disk", e);
                 return totalBytesWritten;
             }
             totalBytesWritten += writeBytes;
             remainingBytes -= writeBytes;
             if (writeBytes > 0 && remainingBytes > 0) {
                 Log.i(TAG, "Total bytes written: " + totalBytesWritten + "/"
                         + (totalBytesWritten + remainingBytes));
             }
         }
         Log.d(TAG, "Write completed.");
         return totalBytesWritten;
     }

     private long fetchRemainingBytes(long minWrittenBytes) {
         ResourceOveruseStats stats;
         synchronized (mLock) {
             stats = mCarWatchdogManager.getResourceOveruseStats(
                     CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO,
                     CarWatchdogManager.STATS_PERIOD_CURRENT_DAY);
         }
         Log.d(TAG, "Fetched resource overuse stats: " + stats);
         IoOveruseStats ioOveruseStats = stats.getIoOveruseStats();
         if (ioOveruseStats == null) {
             setDumpMessage(
                     "ERROR: No I/O overuse stats available for the application after writing "
                     + minWrittenBytes + " bytes.");
             return 0;
         }
         if (ioOveruseStats.getTotalBytesWritten() < minWrittenBytes) {
             setDumpMessage("ERROR: Actual written bytes to disk '" + minWrittenBytes
                     + "' don't match written bytes '" + ioOveruseStats.getTotalBytesWritten()
                     + "' returned by get request");
             return 0;
         }
         /*
          * Check for foreground mode bytes given CtsCarApp is running in the foreground
          * during testing.
          */
         return ioOveruseStats.getRemainingWriteBytes().getForegroundModeBytes();
     }

     private void setDumpMessage(String message) {
         if (mDumpMessage.startsWith("ERROR:")) {
             mDumpMessage += ", " + message;
         } else {
             mDumpMessage = message;
         }
     }

     private final class IoOveruseListener
             implements CarWatchdogManager.ResourceOveruseListener {
         private static final int NOTIFICATION_DELAY_MS = 5000;

         private final Object mLock = new Object();
         @GuardedBy("mLock")
         private boolean mNotificationReceived;
         @GuardedBy("mLock")
         private long mForegroundModeBytes;

         private long mExpectedMinWrittenBytes;

         @Override
         public void onOveruse(ResourceOveruseStats resourceOveruseStats) {
             synchronized (mLock) {
                 Log.d(TAG, "onOveruse callback received: " + resourceOveruseStats);
                 mForegroundModeBytes = -1;
                 mNotificationReceived = true;
                 mLock.notifyAll();
                 if (resourceOveruseStats.getIoOveruseStats() == null) {
                     setDumpMessage(
                             "ERROR: No I/O overuse stats reported for the application in the "
                             + "overuse notification.");
                     return;
                 }
                 long reportedWrittenBytes =
                         resourceOveruseStats.getIoOveruseStats().getTotalBytesWritten();
                 if (reportedWrittenBytes < mExpectedMinWrittenBytes) {
                     setDumpMessage("ERROR: Actual written bytes to disk '"
                             + mExpectedMinWrittenBytes + "' don't match written bytes '"
                             + reportedWrittenBytes + "' reported in overuse notification");
                     return;
                 }
                 mForegroundModeBytes =
                         resourceOveruseStats.getIoOveruseStats().getRemainingWriteBytes()
                                 .getForegroundModeBytes();
             }
         }

         public void dumpForegroundModeBytes() {
             synchronized (mLock) {
                 setDumpMessage(
                         "INFO: --Notification-- foregroundModeBytes = " + mForegroundModeBytes);
             }
         }

         public void setExpectedMinWrittenBytes(long expectedMinWrittenBytes) {
             mExpectedMinWrittenBytes = expectedMinWrittenBytes;
         }

         public void checkIsNotified() {
             synchronized (mLock) {
                 long now = SystemClock.uptimeMillis();
                 long deadline = now + NOTIFICATION_DELAY_MS;
                 while (!mNotificationReceived && now < deadline) {
                     try {
                         mLock.wait(deadline - now);
                     } catch (InterruptedException e) {
                         Thread.currentThread().interrupt();
                         continue;
                     } finally {
                         now = SystemClock.uptimeMillis();
                     }
                     break;
                 }
                 if (!mNotificationReceived) {
                     setDumpMessage("ERROR: I/O Overuse notification not received.");
                 }
             }
         }
     }
 }
	/*
	* Copyright (C) 2021 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 android.car.cts.app;

	import android.app.Activity;
	import android.car.Car;
	import android.car.watchdog.CarWatchdogManager;
	import android.car.watchdog.IoOveruseStats;
	import android.car.watchdog.ResourceOveruseStats;
	import android.content.Intent;
	import android.os.Bundle;
	import android.os.SystemClock;
	import android.util.Log;

	import androidx.annotation.GuardedBy;

	import java.io.File;
	import java.io.FileDescriptor;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InterruptedIOException;
	import java.io.PrintWriter;
	import java.nio.file.Files;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Executors;

	public final class CarWatchdogTestActivity extends Activity {
	private static final String TAG = CarWatchdogTestActivity.class.getSimpleName();
	private static final String BYTES_TO_KILL = "bytes_to_kill";
	private static final long TEN_MEGABYTES = 1024 * 1024 * 10;
	private static final long TWO_HUNDRED_MEGABYTES = 1024 * 1024 * 200;
	private static final int DISK_DELAY_MS = 4000;
	private static final double WARN_THRESHOLD_PERCENT = 0.8;
	private static final double EXCEED_WARN_THRESHOLD_PERCENT = 0.9;

	private final ExecutorService mExecutor = Executors.newSingleThreadExecutor();
	private final Object mLock = new Object();

	@GuardedBy("mLock")
	private CarWatchdogManager mCarWatchdogManager;

	private String mDumpMessage = "";
	private Car mCar;
	private File mTestDir;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	initCarApi();
	try {
	mTestDir =
	Files.createTempDirectory(getFilesDir().toPath(), "testDir").toFile();
	} catch (IOException e) {
	setDumpMessage("ERROR: " + e.getMessage());
	finish();
	return;
	}
	mExecutor.execute(
	() -> {
	synchronized (mLock) {
	if (mCarWatchdogManager == null) {
	Log.e(TAG, "CarWatchdogManager is null.");
	finish();
	return;
	}
	}
	IoOveruseListener listener = addResourceOveruseListener();
	try {
	if (!writeToDisk(TEN_MEGABYTES)) {
	finish();
	return;
	}

	long remainingBytes = fetchRemainingBytes(TEN_MEGABYTES);
	if (remainingBytes == 0) {
	Log.d(TAG, "Remaining bytes is 0 after writing " + TEN_MEGABYTES
	+ " bytes to disk.");
	finish();
	return;
	}

	/*
	* Warning notification is received as soon as exceeding
	* \|WARN_THRESHOLD_PERCENT\|. So, set expected minimum written bytes to
	* \|WARN_THRESHOLD_PERCENT\| of the overuse threshold.
	*/
	long bytesToWarnThreshold =
	(long) (TWO_HUNDRED_MEGABYTES * WARN_THRESHOLD_PERCENT);

	listener.setExpectedMinWrittenBytes(bytesToWarnThreshold);

	long bytesToExceedWarnThreshold =
	(long) Math.ceil(remainingBytes
	* EXCEED_WARN_THRESHOLD_PERCENT);

	if (!writeToDisk(bytesToExceedWarnThreshold)) {
	finish();
	return;
	}

	listener.checkIsNotified();
	} finally {
	synchronized (mLock) {
	mCarWatchdogManager.removeResourceOveruseListener(listener);
	}
	/* Foreground mode bytes dumped after removing listener to ensure hostside
	* receives dump message after test is finished.
	*/
	listener.dumpForegroundModeBytes();
	}
	});
	}

	@Override
	protected void onNewIntent(Intent intent) {
	super.onNewIntent(intent);

	setDumpMessage("");
	Bundle extras = intent.getExtras();
	if (extras == null) {
	Log.w(TAG, "onNewIntent: empty extras");
	return;
	}
	long remainingBytes = extras.getLong(BYTES_TO_KILL);
	Log.d(TAG, "Bytes to kill: " + remainingBytes);
	if (remainingBytes == 0) {
	Log.w(TAG, "onNewIntent: remaining bytes is 0");
	return;
	}
	mExecutor.execute(() -> {
	synchronized (mLock) {
	if (mCarWatchdogManager == null) {
	Log.e(TAG, "onNewIntent: CarWatchdogManager is null.");
	finish();
	return;
	}
	}
	IoOveruseListener listener = addResourceOveruseListener();
	try {
	listener.setExpectedMinWrittenBytes(TWO_HUNDRED_MEGABYTES);

	writeToDisk(remainingBytes);

	listener.checkIsNotified();
	} finally {
	synchronized (mLock) {
	mCarWatchdogManager.removeResourceOveruseListener(listener);
	}
	/* Foreground mode bytes dumped after removing listener to ensure hostside
	* receives dump message after test is finished.
	*/
	listener.dumpForegroundModeBytes();
	}
	});
	}

	@Override
	public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
	if (mDumpMessage.isEmpty()) {
	return;
	}
	writer.printf("%s: %s\n", TAG, mDumpMessage);
	Log.i(TAG, "Dumping message: '" + mDumpMessage + "'");
	}

	@Override
	protected void onDestroy() {
	if (mCar != null) {
	mCar.disconnect();
	}
	if (mTestDir.delete()) {
	Log.i(TAG, "Deleted directory '" + mTestDir.getAbsolutePath() + "' successfully");
	} else {
	Log.e(TAG, "Failed to delete directory '" + mTestDir.getAbsolutePath() + "'");
	}
	super.onDestroy();
	}

	private void initCarApi() {
	if (mCar != null && mCar.isConnected()) {
	mCar.disconnect();
	mCar = null;
	}
	mCar = Car.createCar(this, null, Car.CAR_WAIT_TIMEOUT_WAIT_FOREVER,
	this::initManagers);
	}

	private void initManagers(Car car, boolean ready) {
	synchronized (mLock) {
	if (ready) {
	mCarWatchdogManager = (CarWatchdogManager) car.getCarManager(
	Car.CAR_WATCHDOG_SERVICE);
	Log.d(TAG, "initManagers() completed");
	} else {
	mCarWatchdogManager = null;
	Log.wtf(TAG, "mCarWatchdogManager set to be null");
	}
	}
	}

	private IoOveruseListener addResourceOveruseListener() {
	IoOveruseListener listener = new IoOveruseListener();
	synchronized (mLock) {
	mCarWatchdogManager.addResourceOveruseListener(getMainExecutor(),
	CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO, listener);
	}
	return listener;
	}

	private boolean writeToDisk(long bytes) {
	File uniqueFile = new File(mTestDir, Long.toString(System.nanoTime()));
	boolean result = writeToFile(uniqueFile, bytes);
	if (uniqueFile.delete()) {
	Log.i(TAG, "Deleted file: " + uniqueFile.getAbsolutePath());
	} else {
	Log.e(TAG, "Failed to delete file: " + uniqueFile.getAbsolutePath());
	}
	return result;
	}

	private boolean writeToFile(File uniqueFile, long bytes) {
	long writtenBytes = 0;
	try (FileOutputStream fos = new FileOutputStream(uniqueFile)) {
	Log.d(TAG, "Attempting to write " + bytes + " bytes");
	writtenBytes = writeToFos(fos, bytes);
	if (writtenBytes < bytes) {
	setDumpMessage("ERROR: Failed to write '" + bytes
	+ "' bytes to disk. '" + writtenBytes
	+ "' bytes were successfully written, while '" + (bytes - writtenBytes)
	+ "' bytes were pending at the moment the exception occurred.");
	return false;
	}
	fos.getFD().sync();
	// Wait for the IO event to propagate to the system
	Thread.sleep(DISK_DELAY_MS);
	return true;
	} catch (IOException \| InterruptedException e) {
	String message;
	if (e instanceof IOException) {
	message = "I/O exception";
	} else {
	message = "Thread interrupted";
	Thread.currentThread().interrupt();
	}
	if (writtenBytes > 0) {
	message += " after successfully writing to disk.";
	}
	Log.e(TAG, message, e);
	setDumpMessage("ERROR: " + message);
	return false;
	}
	}

	private long writeToFos(FileOutputStream fos, long remainingBytes) {
	long totalBytesWritten = 0;
	while (remainingBytes != 0) {
	int writeBytes =
	(int) Math.min(Integer.MAX_VALUE,
	Math.min(Runtime.getRuntime().freeMemory(), remainingBytes));
	try {
	fos.write(new byte[writeBytes]);
	} catch (InterruptedIOException e) {
	Thread.currentThread().interrupt();
	continue;
	} catch (IOException e) {
	Log.e(TAG, "I/O exception while writing " + writeBytes + " to disk", e);
	return totalBytesWritten;
	}
	totalBytesWritten += writeBytes;
	remainingBytes -= writeBytes;
	if (writeBytes > 0 && remainingBytes > 0) {
	Log.i(TAG, "Total bytes written: " + totalBytesWritten + "/"
	+ (totalBytesWritten + remainingBytes));
	}
	}
	Log.d(TAG, "Write completed.");
	return totalBytesWritten;
	}

	private long fetchRemainingBytes(long minWrittenBytes) {
	ResourceOveruseStats stats;
	synchronized (mLock) {
	stats = mCarWatchdogManager.getResourceOveruseStats(
	CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO,
	CarWatchdogManager.STATS_PERIOD_CURRENT_DAY);
	}
	Log.d(TAG, "Fetched resource overuse stats: " + stats);
	IoOveruseStats ioOveruseStats = stats.getIoOveruseStats();
	if (ioOveruseStats == null) {
	setDumpMessage(
	"ERROR: No I/O overuse stats available for the application after writing "
	+ minWrittenBytes + " bytes.");
	return 0;
	}
	if (ioOveruseStats.getTotalBytesWritten() < minWrittenBytes) {
	setDumpMessage("ERROR: Actual written bytes to disk '" + minWrittenBytes
	+ "' don't match written bytes '" + ioOveruseStats.getTotalBytesWritten()
	+ "' returned by get request");
	return 0;
	}
	/*
	* Check for foreground mode bytes given CtsCarApp is running in the foreground
	* during testing.
	*/
	return ioOveruseStats.getRemainingWriteBytes().getForegroundModeBytes();
	}

	private void setDumpMessage(String message) {
	if (mDumpMessage.startsWith("ERROR:")) {
	mDumpMessage += ", " + message;
	} else {
	mDumpMessage = message;
	}
	}

	private final class IoOveruseListener
	implements CarWatchdogManager.ResourceOveruseListener {
	private static final int NOTIFICATION_DELAY_MS = 5000;

	private final Object mLock = new Object();
	@GuardedBy("mLock")
	private boolean mNotificationReceived;
	@GuardedBy("mLock")
	private long mForegroundModeBytes;

	private long mExpectedMinWrittenBytes;

	@Override
	public void onOveruse(ResourceOveruseStats resourceOveruseStats) {
	synchronized (mLock) {
	Log.d(TAG, "onOveruse callback received: " + resourceOveruseStats);
	mForegroundModeBytes = -1;
	mNotificationReceived = true;
	mLock.notifyAll();
	if (resourceOveruseStats.getIoOveruseStats() == null) {
	setDumpMessage(
	"ERROR: No I/O overuse stats reported for the application in the "
	+ "overuse notification.");
	return;
	}
	long reportedWrittenBytes =
	resourceOveruseStats.getIoOveruseStats().getTotalBytesWritten();
	if (reportedWrittenBytes < mExpectedMinWrittenBytes) {
	setDumpMessage("ERROR: Actual written bytes to disk '"
	+ mExpectedMinWrittenBytes + "' don't match written bytes '"
	+ reportedWrittenBytes + "' reported in overuse notification");
	return;
	}
	mForegroundModeBytes =
	resourceOveruseStats.getIoOveruseStats().getRemainingWriteBytes()
	.getForegroundModeBytes();
	}
	}

	public void dumpForegroundModeBytes() {
	synchronized (mLock) {
	setDumpMessage(
	"INFO: --Notification-- foregroundModeBytes = " + mForegroundModeBytes);
	}
	}

	public void setExpectedMinWrittenBytes(long expectedMinWrittenBytes) {
	mExpectedMinWrittenBytes = expectedMinWrittenBytes;
	}

	public void checkIsNotified() {
	synchronized (mLock) {
	long now = SystemClock.uptimeMillis();
	long deadline = now + NOTIFICATION_DELAY_MS;
	while (!mNotificationReceived && now < deadline) {
	try {
	mLock.wait(deadline - now);
	} catch (InterruptedException e) {
	Thread.currentThread().interrupt();
	continue;
	} finally {
	now = SystemClock.uptimeMillis();
	}
	break;
	}
	if (!mNotificationReceived) {
	setDumpMessage("ERROR: I/O Overuse notification not received.");
	}
	}
	}
	}
	}