diff options
12 files changed, 562 insertions, 17 deletions
diff --git a/packages/SystemUI/src/com/android/systemui/dump/DumpHandler.kt b/packages/SystemUI/src/com/android/systemui/dump/DumpHandler.kt index f8a1b7d4d1f1..fa951fa09ef6 100644 --- a/packages/SystemUI/src/com/android/systemui/dump/DumpHandler.kt +++ b/packages/SystemUI/src/com/android/systemui/dump/DumpHandler.kt @@ -79,7 +79,8 @@ import javax.inject.Inject */ class DumpHandler @Inject constructor( private val context: Context, - private val dumpManager: DumpManager + private val dumpManager: DumpManager, + private val logBufferEulogizer: LogBufferEulogizer ) { /** * Dump the diagnostics! Behavior can be controlled via [args]. @@ -125,6 +126,7 @@ class DumpHandler @Inject constructor( private fun dumpNormal(pw: PrintWriter, args: ParsedArgs) { dumpManager.dumpBuffers(pw, args.tailLength) + logBufferEulogizer.readEulogyIfPresent(pw) } private fun dumpDumpables(fw: FileDescriptor, pw: PrintWriter, args: ParsedArgs) { diff --git a/packages/SystemUI/src/com/android/systemui/dump/LogBufferEulogizer.kt b/packages/SystemUI/src/com/android/systemui/dump/LogBufferEulogizer.kt new file mode 100644 index 000000000000..603cb672175d --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/dump/LogBufferEulogizer.kt @@ -0,0 +1,150 @@ +/* + * 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.systemui.dump + +import android.content.Context +import android.util.Log +import com.android.systemui.log.LogBuffer +import com.android.systemui.util.io.Files +import com.android.systemui.util.time.SystemClock +import java.io.IOException +import java.io.PrintWriter +import java.io.UncheckedIOException +import java.nio.file.Path +import java.nio.file.Paths +import java.nio.file.StandardOpenOption.CREATE +import java.nio.file.StandardOpenOption.TRUNCATE_EXISTING +import java.nio.file.attribute.BasicFileAttributes +import java.text.SimpleDateFormat +import java.util.Locale +import java.util.concurrent.TimeUnit +import javax.inject.Inject +import javax.inject.Singleton + +/** + * Dumps all [LogBuffer]s to a file + * + * Intended for emergencies, i.e. we're about to crash. This file can then be read at a later date + * (usually in a bug report). + */ +@Singleton +class LogBufferEulogizer( + private val dumpManager: DumpManager, + private val systemClock: SystemClock, + private val files: Files, + private val logPath: Path, + private val minWriteGap: Long, + private val maxLogAgeToDump: Long +) { + @Inject constructor( + context: Context, + dumpManager: DumpManager, + systemClock: SystemClock, + files: Files + ) : this( + dumpManager, + systemClock, + files, + Paths.get(context.filesDir.toPath().toString(), "log_buffers.txt"), + MIN_WRITE_GAP, + MAX_AGE_TO_DUMP + ) + + /** + * Dumps all active log buffers to a file + * + * The file will be prefaced by the [reason], which will then be returned (presumably so it can + * be thrown). + */ + fun <T : Exception> record(reason: T): T { + val start = systemClock.uptimeMillis() + var duration = 0L + + Log.i(TAG, "Performing emergency dump of log buffers") + + val millisSinceLastWrite = getMillisSinceLastWrite(logPath) + if (millisSinceLastWrite < minWriteGap) { + Log.w(TAG, "Cannot dump logs, last write was only $millisSinceLastWrite ms ago") + return reason + } + + try { + val writer = files.newBufferedWriter(logPath, CREATE, TRUNCATE_EXISTING) + writer.use { out -> + val pw = PrintWriter(out) + + pw.println(DATE_FORMAT.format(systemClock.currentTimeMillis())) + pw.println() + pw.println("Dump triggered by exception:") + reason.printStackTrace(pw) + dumpManager.dumpBuffers(pw, 0) + duration = systemClock.uptimeMillis() - start + pw.println() + pw.println("Buffer eulogy took ${duration}ms") + } + } catch (e: Exception) { + Log.e(TAG, "Exception while attempting to dump buffers, bailing", e) + } + + Log.i(TAG, "Buffer eulogy took ${duration}ms") + + return reason + } + + /** + * If a eulogy file is present, writes its contents to [pw]. + */ + fun readEulogyIfPresent(pw: PrintWriter) { + try { + val millisSinceLastWrite = getMillisSinceLastWrite(logPath) + if (millisSinceLastWrite > maxLogAgeToDump) { + Log.i(TAG, "Not eulogizing buffers; they are " + + TimeUnit.HOURS.convert(millisSinceLastWrite, TimeUnit.MILLISECONDS) + + " hours old") + return + } + + files.lines(logPath).use { s -> + pw.println() + pw.println() + pw.println("=============== BUFFERS FROM MOST RECENT CRASH ===============") + s.forEach { line -> + pw.println(line) + } + } + } catch (e: IOException) { + // File doesn't exist, okay + } catch (e: UncheckedIOException) { + Log.e(TAG, "UncheckedIOException while dumping the core", e) + } + } + + private fun getMillisSinceLastWrite(path: Path): Long { + val stats = try { + files.readAttributes(path, BasicFileAttributes::class.java) + } catch (e: IOException) { + // File doesn't exist + null + } + return systemClock.currentTimeMillis() - (stats?.lastModifiedTime()?.toMillis() ?: 0) + } +} + +private const val TAG = "BufferEulogizer" +private val MIN_WRITE_GAP = TimeUnit.MINUTES.toMillis(5) +private val MAX_AGE_TO_DUMP = TimeUnit.HOURS.toMillis(48) +private val DATE_FORMAT = SimpleDateFormat("MM-dd HH:mm:ss.SSS", Locale.US)
\ No newline at end of file diff --git a/packages/SystemUI/src/com/android/systemui/log/LogBuffer.kt b/packages/SystemUI/src/com/android/systemui/log/LogBuffer.kt index 7defef90380f..342db346e14b 100644 --- a/packages/SystemUI/src/com/android/systemui/log/LogBuffer.kt +++ b/packages/SystemUI/src/com/android/systemui/log/LogBuffer.kt @@ -209,4 +209,4 @@ class LogBuffer( } private const val TAG = "LogBuffer" -private val DATE_FORMAT = SimpleDateFormat("MM-dd HH:mm:ss.S", Locale.US) +private val DATE_FORMAT = SimpleDateFormat("MM-dd HH:mm:ss.SSS", Locale.US) diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/NotifCollection.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/NotifCollection.java index a3621b6cabf6..fb5bfd88e3e1 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/NotifCollection.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/NotifCollection.java @@ -61,6 +61,7 @@ import androidx.annotation.NonNull; import com.android.internal.statusbar.IStatusBarService; import com.android.systemui.Dumpable; import com.android.systemui.dump.DumpManager; +import com.android.systemui.dump.LogBufferEulogizer; import com.android.systemui.statusbar.FeatureFlags; import com.android.systemui.statusbar.notification.collection.coalescer.CoalescedEvent; import com.android.systemui.statusbar.notification.collection.coalescer.GroupCoalescer; @@ -126,6 +127,7 @@ public class NotifCollection implements Dumpable { private final IStatusBarService mStatusBarService; private final FeatureFlags mFeatureFlags; private final NotifCollectionLogger mLogger; + private final LogBufferEulogizer mEulogizer; private final Map<String, NotificationEntry> mNotificationSet = new ArrayMap<>(); private final Collection<NotificationEntry> mReadOnlyNotificationSet = @@ -146,10 +148,12 @@ public class NotifCollection implements Dumpable { IStatusBarService statusBarService, DumpManager dumpManager, FeatureFlags featureFlags, - NotifCollectionLogger logger) { + NotifCollectionLogger logger, + LogBufferEulogizer logBufferEulogizer) { Assert.isMainThread(); mStatusBarService = statusBarService; mLogger = logger; + mEulogizer = logBufferEulogizer; dumpManager.registerDumpable(TAG, this); mFeatureFlags = featureFlags; } @@ -223,7 +227,8 @@ public class NotifCollection implements Dumpable { requireNonNull(stats); if (entry != mNotificationSet.get(entry.getKey())) { - throw new IllegalStateException("Invalid entry: " + entry.getKey()); + throw mEulogizer.record( + new IllegalStateException("Invalid entry: " + entry.getKey())); } if (entry.getDismissState() == DISMISSED) { @@ -367,8 +372,11 @@ public class NotifCollection implements Dumpable { final NotificationEntry entry = mNotificationSet.get(sbn.getKey()); if (entry == null) { - throw new IllegalStateException("No notification to remove with key " + sbn.getKey()); + throw mEulogizer.record( + new IllegalStateException("No notification to remove with key " + + sbn.getKey())); } + entry.mCancellationReason = reason; tryRemoveNotification(entry); applyRanking(rankingMap); @@ -426,12 +434,15 @@ public class NotifCollection implements Dumpable { */ private boolean tryRemoveNotification(NotificationEntry entry) { if (mNotificationSet.get(entry.getKey()) != entry) { - throw new IllegalStateException("No notification to remove with key " + entry.getKey()); + throw mEulogizer.record( + new IllegalStateException("No notification to remove with key " + + entry.getKey())); } if (!isCanceled(entry)) { - throw new IllegalStateException("Cannot remove notification " + entry.getKey() - + ": has not been marked for removal"); + throw mEulogizer.record( + new IllegalStateException("Cannot remove notification " + entry.getKey() + + ": has not been marked for removal")); } if (isDismissedByUser(entry)) { @@ -501,11 +512,11 @@ public class NotifCollection implements Dumpable { checkForReentrantCall(); if (!entry.mLifetimeExtenders.remove(extender)) { - throw new IllegalStateException( + throw mEulogizer.record(new IllegalStateException( String.format( "Cannot end lifetime extension for extender \"%s\" (%s)", extender.getName(), - extender)); + extender))); } mLogger.logLifetimeExtensionEnded( @@ -581,11 +592,11 @@ public class NotifCollection implements Dumpable { checkForReentrantCall(); if (!entry.mDismissInterceptors.remove(interceptor)) { - throw new IllegalStateException( + throw mEulogizer.record(new IllegalStateException( String.format( "Cannot end dismiss interceptor for interceptor \"%s\" (%s)", interceptor.getName(), - interceptor)); + interceptor))); } if (!isDismissIntercepted(entry)) { @@ -608,7 +619,7 @@ public class NotifCollection implements Dumpable { private void checkForReentrantCall() { if (mAmDispatchingToOtherCode) { - throw new IllegalStateException("Reentrant call detected"); + throw mEulogizer.record(new IllegalStateException("Reentrant call detected")); } } diff --git a/packages/SystemUI/src/com/android/systemui/util/io/Files.java b/packages/SystemUI/src/com/android/systemui/util/io/Files.java new file mode 100644 index 000000000000..7d633a769600 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/util/io/Files.java @@ -0,0 +1,58 @@ +/* + * 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.systemui.util.io; + +import androidx.annotation.NonNull; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.LinkOption; +import java.nio.file.OpenOption; +import java.nio.file.Path; +import java.nio.file.attribute.BasicFileAttributes; +import java.util.stream.Stream; + +import javax.inject.Inject; +import javax.inject.Singleton; + +/** + * Wrapper around {@link java.nio.file.Files} that can be mocked in tests. + */ +@Singleton +public class Files { + @Inject + public Files() { } + + /** See {@link java.nio.file.Files#newBufferedWriter} */ + public BufferedWriter newBufferedWriter(Path path, OpenOption... options) throws IOException { + return java.nio.file.Files.newBufferedWriter(path, StandardCharsets.UTF_8, options); + } + + /** See {@link java.nio.file.Files#lines} */ + public Stream<String> lines(Path path) throws IOException { + return java.nio.file.Files.lines(path); + } + + /** See {@link java.nio.file.Files#readAttributes} */ + public <A extends BasicFileAttributes> A readAttributes( + @NonNull Path path, + @NonNull Class<A> type, + @NonNull LinkOption... options) throws IOException { + return java.nio.file.Files.readAttributes(path, type, options); + } +} diff --git a/packages/SystemUI/src/com/android/systemui/util/time/SystemClock.java b/packages/SystemUI/src/com/android/systemui/util/time/SystemClock.java index 6fef59f6b995..6f32cc1a156d 100644 --- a/packages/SystemUI/src/com/android/systemui/util/time/SystemClock.java +++ b/packages/SystemUI/src/com/android/systemui/util/time/SystemClock.java @@ -37,4 +37,7 @@ public interface SystemClock { /** @see android.os.SystemClock#currentThreadTimeMillis() */ long currentThreadTimeMillis(); + + /** @see System#currentTimeMillis() */ + long currentTimeMillis(); } diff --git a/packages/SystemUI/src/com/android/systemui/util/time/SystemClockImpl.java b/packages/SystemUI/src/com/android/systemui/util/time/SystemClockImpl.java index f0c701490f13..4e508cfaed19 100644 --- a/packages/SystemUI/src/com/android/systemui/util/time/SystemClockImpl.java +++ b/packages/SystemUI/src/com/android/systemui/util/time/SystemClockImpl.java @@ -42,4 +42,9 @@ public class SystemClockImpl implements SystemClock { public long currentThreadTimeMillis() { return android.os.SystemClock.currentThreadTimeMillis(); } + + @Override + public long currentTimeMillis() { + return System.currentTimeMillis(); + } } diff --git a/packages/SystemUI/tests/src/com/android/systemui/dump/DumpHandlerTest.kt b/packages/SystemUI/tests/src/com/android/systemui/dump/DumpHandlerTest.kt index da7ec55bb0a8..9e67eda57607 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/dump/DumpHandlerTest.kt +++ b/packages/SystemUI/tests/src/com/android/systemui/dump/DumpHandlerTest.kt @@ -37,6 +37,9 @@ class DumpHandlerTest : SysuiTestCase() { private lateinit var dumpHandler: DumpHandler @Mock + private lateinit var logBufferEulogizer: LogBufferEulogizer + + @Mock private lateinit var fd: FileDescriptor @Mock private lateinit var pw: PrintWriter @@ -59,7 +62,7 @@ class DumpHandlerTest : SysuiTestCase() { fun setUp() { MockitoAnnotations.initMocks(this) - dumpHandler = DumpHandler(mContext, dumpManager) + dumpHandler = DumpHandler(mContext, dumpManager, logBufferEulogizer) } @Test diff --git a/packages/SystemUI/tests/src/com/android/systemui/dump/LogEulogizerTest.kt b/packages/SystemUI/tests/src/com/android/systemui/dump/LogEulogizerTest.kt new file mode 100644 index 000000000000..cb38846a0514 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/dump/LogEulogizerTest.kt @@ -0,0 +1,169 @@ +/* + * 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.systemui.dump + +import androidx.test.filters.SmallTest +import com.android.systemui.SysuiTestCase +import com.android.systemui.util.io.FakeBasicFileAttributes +import com.android.systemui.util.io.Files +import com.android.systemui.util.mockito.any +import com.android.systemui.util.mockito.eq +import com.android.systemui.util.time.FakeSystemClock +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.mockito.Mock +import org.mockito.Mockito +import org.mockito.Mockito.never +import org.mockito.Mockito.verify +import org.mockito.MockitoAnnotations +import java.io.BufferedWriter +import java.io.ByteArrayOutputStream +import java.io.IOException +import java.io.OutputStreamWriter +import java.io.PrintWriter +import java.nio.file.LinkOption +import java.nio.file.OpenOption +import java.nio.file.Paths +import java.nio.file.attribute.BasicFileAttributes +import java.util.Arrays + +@SmallTest +class LogEulogizerTest : SysuiTestCase() { + + lateinit var eulogizer: LogBufferEulogizer + + @Mock + lateinit var dumpManager: DumpManager + + @Mock + lateinit var files: Files + + private val clock = FakeSystemClock() + + private val path = Paths.get("/foo/bar/baz.txt") + private val fileAttrs = FakeBasicFileAttributes() + private val fileStream = ByteArrayOutputStream() + private val fileWriter = BufferedWriter(OutputStreamWriter(fileStream)) + + private val dumpStream = ByteArrayOutputStream() + private val dumpWriter = PrintWriter(OutputStreamWriter(dumpStream)) + + @Before + fun setUp() { + MockitoAnnotations.initMocks(this) + + eulogizer = + LogBufferEulogizer(dumpManager, clock, files, path, MIN_WRITE_GAP, MAX_READ_AGE) + + Mockito.`when`(files.newBufferedWriter(eq(path), any(OpenOption::class.java))) + .thenReturn(fileWriter) + + Mockito.`when`( + files.readAttributes(eq(path), + eq(BasicFileAttributes::class.java), + any(LinkOption::class.java)) + ).thenReturn(fileAttrs) + + Mockito.`when`(files.lines(eq(path))).thenReturn(Arrays.stream(FAKE_LINES)) + } + + @Test + fun testFileIsCreated() { + // GIVEN that the log file doesn't already exist + Mockito.`when`( + files.readAttributes(eq(path), + eq(BasicFileAttributes::class.java), + any(LinkOption::class.java)) + ).thenThrow(IOException("File not found")) + + // WHEN .record() is called + val exception = RuntimeException("Something bad happened") + assertEquals(exception, eulogizer.record(exception)) + + // THEN the buffers are dumped to the file + verify(dumpManager).dumpBuffers(any(PrintWriter::class.java), Mockito.anyInt()) + assertTrue(fileStream.toString().isNotEmpty()) + } + + @Test + fun testExistingFileIsOverwritten() { + // GIVEN that the log file already exists but hasn't been modified in a while + fileAttrs.setLastModifiedTime(clock.currentTimeMillis() - MIN_WRITE_GAP - 20) + + // WHEN .record() is called + val exception = RuntimeException("Something bad happened") + assertEquals(exception, eulogizer.record(exception)) + + // THEN the buffers are dumped to the file + verify(dumpManager).dumpBuffers(any(PrintWriter::class.java), Mockito.anyInt()) + assertTrue(fileStream.toString().isNotEmpty()) + } + + @Test + fun testYoungFileIsNotOverwritten() { + // GIVEN that the log file has been modified recently + fileAttrs.setLastModifiedTime(clock.currentTimeMillis() - MIN_WRITE_GAP + 7) + + // WHEN .record() is called + val exception = RuntimeException("Something bad happened") + assertEquals(exception, eulogizer.record(exception)) + + // THEN the file isn't written to + verify(dumpManager, never()).dumpBuffers(any(PrintWriter::class.java), Mockito.anyInt()) + assertTrue(fileStream.toString().isEmpty()) + } + + @Test + fun testRecentFileIsDumped() { + // GIVEN that the log file was written to "recently" + fileAttrs.setLastModifiedTime(clock.currentTimeMillis() - MAX_READ_AGE + 7) + + // WHEN we're asked to eulogize the log + eulogizer.readEulogyIfPresent(dumpWriter) + dumpWriter.close() + + // THEN the log file is written to the output stream + verify(files).lines(eq(path)) + assertTrue(dumpStream.toString().isNotBlank()) + } + + @Test + fun testOldFileIsNotDumped() { + // GIVEN that the log file was written to a long time ago + fileAttrs.setLastModifiedTime(clock.currentTimeMillis() - MAX_READ_AGE - 7) + + // WHEN we're asked to eulogize the log + eulogizer.readEulogyIfPresent(dumpWriter) + dumpWriter.close() + + // THEN the log file is NOT written to the output stream + verify(files, never()).lines(eq(path)) + assertTrue(dumpStream.toString().isEmpty()) + } +} + +private const val MIN_WRITE_GAP = 10L +private const val MAX_READ_AGE = 100L + +private val FAKE_LINES = + arrayOf( + "First line", + "Second line", + "Third line" + ) diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/NotifCollectionTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/NotifCollectionTest.java index 82de4a3b490c..ca9cc299b36d 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/NotifCollectionTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/NotifCollectionTest.java @@ -34,6 +34,7 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.clearInvocations; @@ -65,6 +66,7 @@ import com.android.internal.statusbar.IStatusBarService; import com.android.internal.statusbar.NotificationVisibility; import com.android.systemui.SysuiTestCase; import com.android.systemui.dump.DumpManager; +import com.android.systemui.dump.LogBufferEulogizer; import com.android.systemui.statusbar.FeatureFlags; import com.android.systemui.statusbar.RankingBuilder; import com.android.systemui.statusbar.notification.collection.NoManSimulator.NotifEvent; @@ -100,11 +102,13 @@ import java.util.Map; public class NotifCollectionTest extends SysuiTestCase { @Mock private IStatusBarService mStatusBarService; + @Mock private FeatureFlags mFeatureFlags; @Mock private NotifCollectionLogger mLogger; + @Mock private LogBufferEulogizer mEulogizer; + @Mock private GroupCoalescer mGroupCoalescer; @Spy private RecordingCollectionListener mCollectionListener; @Mock private CollectionReadyForBuildListener mBuildListener; - @Mock private FeatureFlags mFeatureFlags; @Spy private RecordingLifetimeExtender mExtender1 = new RecordingLifetimeExtender("Extender1"); @Spy private RecordingLifetimeExtender mExtender2 = new RecordingLifetimeExtender("Extender2"); @@ -136,13 +140,16 @@ public class NotifCollectionTest extends SysuiTestCase { when(mFeatureFlags.isNewNotifPipelineRenderingEnabled()).thenReturn(true); when(mFeatureFlags.isNewNotifPipelineEnabled()).thenReturn(true); + when(mEulogizer.record(any(Exception.class))).thenAnswer(i -> i.getArguments()[0]); + mListenerInOrder = inOrder(mCollectionListener); mCollection = new NotifCollection( mStatusBarService, mock(DumpManager.class), mFeatureFlags, - mLogger); + mLogger, + mEulogizer); mCollection.attach(mGroupCoalescer); mCollection.addCollectionListener(mCollectionListener); mCollection.setBuildListener(mBuildListener); diff --git a/packages/SystemUI/tests/src/com/android/systemui/util/io/FakeBasicFileAttributes.java b/packages/SystemUI/tests/src/com/android/systemui/util/io/FakeBasicFileAttributes.java new file mode 100644 index 000000000000..f7a04dcdbbd8 --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/util/io/FakeBasicFileAttributes.java @@ -0,0 +1,126 @@ +/* + * 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.systemui.util.io; + +import java.nio.file.attribute.BasicFileAttributes; +import java.nio.file.attribute.FileTime; +import java.util.concurrent.TimeUnit; + +/** + * Fake implementation of {@link BasicFileAttributes} (for use in tests) + */ +public class FakeBasicFileAttributes implements BasicFileAttributes { + private FileTime mLastModifiedTime = FileTime.from(0, TimeUnit.MILLISECONDS); + private FileTime mLastAccessTime = FileTime.from(0, TimeUnit.MILLISECONDS); + private FileTime mCreationTime = FileTime.from(0, TimeUnit.MILLISECONDS); + private boolean mIsRegularFile = true; + private boolean mIsDirectory = false; + private boolean mIsSymbolicLink = false; + private boolean mIsOther = false; + private long mSize = 0; + private Object mFileKey = null; + + @Override + public FileTime lastModifiedTime() { + return mLastModifiedTime; + } + + @Override + public FileTime lastAccessTime() { + return mLastAccessTime; + } + + @Override + public FileTime creationTime() { + return mCreationTime; + } + + @Override + public boolean isRegularFile() { + return mIsRegularFile; + } + + @Override + public boolean isDirectory() { + return mIsDirectory; + } + + @Override + public boolean isSymbolicLink() { + return mIsSymbolicLink; + } + + @Override + public boolean isOther() { + return mIsOther; + } + + @Override + public long size() { + return mSize; + } + + @Override + public Object fileKey() { + return mFileKey; + } + + public FakeBasicFileAttributes setLastModifiedTime(long millis) { + mLastModifiedTime = FileTime.from(millis, TimeUnit.MILLISECONDS); + return this; + } + + public FakeBasicFileAttributes setLastAccessTime(long millis) { + mLastAccessTime = FileTime.from(millis, TimeUnit.MILLISECONDS); + return this; + } + + public FakeBasicFileAttributes setCreationTime(long millis) { + mCreationTime = FileTime.from(millis, TimeUnit.MILLISECONDS); + return this; + } + + public FakeBasicFileAttributes setRegularFile(boolean regularFile) { + mIsRegularFile = regularFile; + return this; + } + + public FakeBasicFileAttributes setDirectory(boolean directory) { + mIsDirectory = directory; + return this; + } + + public FakeBasicFileAttributes setSymbolicLink(boolean symbolicLink) { + mIsSymbolicLink = symbolicLink; + return this; + } + + public FakeBasicFileAttributes setOther(boolean other) { + mIsOther = other; + return this; + } + + public FakeBasicFileAttributes setSize(long size) { + mSize = size; + return this; + } + + public FakeBasicFileAttributes setFileKey(Object fileKey) { + mFileKey = fileKey; + return this; + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/util/time/FakeSystemClock.java b/packages/SystemUI/tests/src/com/android/systemui/util/time/FakeSystemClock.java index 601f88e0a9c6..ecfb357aa068 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/util/time/FakeSystemClock.java +++ b/packages/SystemUI/tests/src/com/android/systemui/util/time/FakeSystemClock.java @@ -36,8 +36,9 @@ public class FakeSystemClock implements SystemClock { private long mElapsedRealtime = 10000; private long mCurrentThreadTimeMillis = 10000; - private final List<ClockTickListener> mListeners = new ArrayList<>(); + private long mCurrentTimeMillis = 1555555500000L; + private final List<ClockTickListener> mListeners = new ArrayList<>(); @Override public long uptimeMillis() { return mUptimeMillis; @@ -58,10 +59,19 @@ public class FakeSystemClock implements SystemClock { return mCurrentThreadTimeMillis; } + @Override + public long currentTimeMillis() { + return mCurrentTimeMillis; + } + public void setUptimeMillis(long uptime) { advanceTime(uptime - mUptimeMillis); } + public void setCurrentTimeMillis(long millis) { + mCurrentTimeMillis = millis; + } + public void advanceTime(long uptime) { advanceTime(uptime, 0); } @@ -74,6 +84,7 @@ public class FakeSystemClock implements SystemClock { if (uptime > 0 || sleepTime > 0) { mUptimeMillis += uptime; mElapsedRealtime += uptime + sleepTime; + mCurrentTimeMillis += uptime + sleepTime; mCurrentThreadTimeMillis += Math.ceil(uptime * 0.5); |