ScreenCapture.java
/*
* Copyright (C) 2016 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 androidx.test.runner.screenshot;
import static android.graphics.Bitmap.CompressFormat.PNG;
import static androidx.test.internal.util.Checks.checkNotNull;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import androidx.annotation.NonNull;
import androidx.test.annotation.ExperimentalTestApi;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
/**
* A ScreenCapture contains a bitmap of a device screen along with a set of {@link
* ScreenCaptureProcessor}s that will be used to process the {@link ScreenCapture} when {@link
* #process} is called.
*
* <p>If no {@link ScreenCaptureProcessor}s are added to the list the {@link
* BasicScreenCaptureProcessor} is used when {@link #process} is called.
*
* <p>If a set of processors are supplied with the call to {@link #process} then those processors
* will take precedence over the set of global processors and the {@link
* BasicScreenCaptureProcessor}.
*
* <p><b>This API is currently in beta.</b>
*/
@ExperimentalTestApi
public final class ScreenCapture {
private static final Bitmap.CompressFormat DEFAULT_FORMAT = PNG;
private final Bitmap bitmap;
private ScreenCaptureProcessor defaultProcessor = new BasicScreenCaptureProcessor();
private String filename;
private CompressFormat format;
private Set<ScreenCaptureProcessor> processorSet = new HashSet<>();
ScreenCapture(Bitmap bitmap) {
this.bitmap = bitmap;
this.format = DEFAULT_FORMAT;
}
ScreenCapture(Bitmap bitmap, ScreenCaptureProcessor defaultProcessor) {
this.bitmap = bitmap;
this.format = DEFAULT_FORMAT;
this.defaultProcessor = defaultProcessor;
}
/** Returns the {@link Bitmap} that was set when the {@link ScreenCapture} was created. */
public Bitmap getBitmap() {
return bitmap;
}
/** Returns the filename to save the bitmap as or null if none has been set. */
public String getName() {
return filename;
}
/** Returns the format to save the bitmap as or PNG if none has been set. */
public CompressFormat getFormat() {
return format;
}
/**
* Sets the filename to save the {@link ScreenCapture} as.
*
* @param filename the filename to use to save the capture as
* @return a fluent interface
*/
public ScreenCapture setName(String filename) {
this.filename = filename;
return this;
}
/**
* Sets the format to save the {@link ScreenCapture} as.
*
* @param format the format to use to save the screenshot as
* @return a fluent interface
*/
public ScreenCapture setFormat(CompressFormat format) {
this.format = format;
return this;
}
/**
* Set the set of processors that belong to this {@link ScreenCapture} to the given set.
*
* @param processorSet the set of processor to set.
*/
ScreenCapture setProcessors(@NonNull Set<ScreenCaptureProcessor> processorSet) {
this.processorSet = checkNotNull(processorSet);
return this;
}
/** Returns the set of processors that belong to this {@link ScreenCapture}. */
Set<ScreenCaptureProcessor> getProcessors() {
return processorSet;
}
/**
* Process the {@link ScreenCapture} using the global set of {@link ScreenCaptureProcessor}s or
* the {@link BasicScreenCaptureProcessor} if no processors are set.
*
* @throws IOException if there is an IOException while any of the processors are processing the
* ScreenCapture
*/
public void process() throws IOException {
process(processorSet);
}
/**
* Process the {@link ScreenCapture} using the given set of {@link ScreenCaptureProcessor}s or the
* {@link BasicScreenCaptureProcessor} if no processors are in the given set.
*
* @param processorSet the set of processors to use to process the ScreenCapture
* @throws IOException if there is an IOException while any of the processors are processing the
* ScreenCapture
*/
public void process(@NonNull Set<ScreenCaptureProcessor> processorSet) throws IOException {
checkNotNull(processorSet);
if (processorSet.isEmpty()) {
defaultProcessor.process(this);
return;
}
for (ScreenCaptureProcessor processor : processorSet) {
processor.process(this);
}
}
@Override
public int hashCode() {
final int prime = 37;
int result = 1;
if (bitmap != null) {
result = prime * result + bitmap.hashCode();
}
if (format != null) {
result = prime * result + format.hashCode();
}
if (filename != null) {
result = prime * result + filename.hashCode();
}
if (!processorSet.isEmpty()) {
result = prime * result + processorSet.hashCode();
}
return result;
}
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof ScreenCapture)) {
return false;
}
ScreenCapture other = (ScreenCapture) obj;
boolean bitmapsEqual;
if (bitmap == null) {
bitmapsEqual = (other.getBitmap() == null) ? true : false;
} else {
bitmapsEqual = getBitmap().sameAs(other.getBitmap());
}
boolean nameEqual;
if (filename == null) {
nameEqual = (other.getName() == null) ? true : false;
} else {
nameEqual = filename.equals(other.getName());
}
boolean formatEqual;
if (format == null) {
formatEqual = (other.getFormat() == null) ? true : false;
} else {
formatEqual = format.equals(other.getFormat());
}
return bitmapsEqual
&& nameEqual
&& formatEqual
&& processorSet.containsAll(other.getProcessors())
&& other.getProcessors().containsAll(processorSet);
}
}