Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add CameraToo, a sample point-and-shoot camera app

Browse Source 
It demonstrates basic use of the features of the new Camera2 API.

Change-Id: I593bc682e5c6203754e9a3ee9a78efbd1b208513
This commit is contained in:
Sol Boucher
2014-06-04 16:05:55 -07:00
committed by Solomon Boucher
parent 0aad830d1b
commit b84fdffad4
7 changed files with 759 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
tests/Camera2Tests/CameraToo/Android.mk Normal file
View File

@@ -0,0 +1,23 @@
# 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.
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := tests
LOCAL_PACKAGE_NAME := CameraToo
LOCAL_SDK_VERSION := current
LOCAL_SRC_FILES := $(call all-java-files-under,src)
include $(BUILD_PACKAGE)

33
tests/Camera2Tests/CameraToo/AndroidManifest.xml Normal file
View File

@@ -0,0 +1,33 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
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.
-->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.android.camera2.cameratoo">
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<application android:label="CameraToo">
<activity
android:name=".CameraTooActivity"
android:screenOrientation="portrait">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

23
tests/Camera2Tests/CameraToo/res/layout/mainactivity.xml Normal file
View File

@@ -0,0 +1,23 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
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.
-->
<SurfaceView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/mainSurfaceView"
android:layout_height="fill_parent"
android:layout_width="fill_parent"
android:onClick="onClickOnSurfaceView" />

437
tests/Camera2Tests/CameraToo/src/com/example/android/camera2/cameratoo/CameraTooActivity.java Normal file
View File

@@ -0,0 +1,437 @@
/*
* 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.example.android.camera2.cameratoo;
import android.app.Activity;
import android.graphics.ImageFormat;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureFailure;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.TotalCaptureResult;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.media.Image;
import android.media.ImageReader;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.util.Size;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* A basic demonstration of how to write a point-and-shoot camera app against the new
* android.hardware.camera2 API.
*/
public class CameraTooActivity extends Activity {
/** Output files will be saved as /sdcard/Pictures/cameratoo*.jpg */
static final String CAPTURE_FILENAME_PREFIX = "cameratoo";
/** Tag to distinguish log prints. */
static final String TAG = "CameraToo";
/** An additional thread for running tasks that shouldn't block the UI. */
HandlerThread mBackgroundThread;
/** Handler for running tasks in the background. */
Handler mBackgroundHandler;
/** Handler for running tasks on the UI thread. */
Handler mForegroundHandler;
/** View for displaying the camera preview. */
SurfaceView mSurfaceView;
/** Used to retrieve the captured image when the user takes a snapshot. */
ImageReader mCaptureBuffer;
/** Handle to the Android camera services. */
CameraManager mCameraManager;
/** The specific camera device that we're using. */
CameraDevice mCamera;
/** Our image capture session. */
CameraCaptureSession mCaptureSession;
/**
* Given {@code choices} of {@code Size}s supported by a camera, chooses the smallest one whose
* width and height are at least as large as the respective requested values.
* @param choices The list of sizes that the camera supports for the intended output class
* @param width The minimum desired width
* @param height The minimum desired height
* @return The optimal {@code Size}, or an arbitrary one if none were big enough
*/
static Size chooseBigEnoughSize(Size[] choices, int width, int height) {
// Collect the supported resolutions that are at least as big as the preview Surface
List<Size> bigEnough = new ArrayList<Size>();
for (Size option : choices) {
if (option.getWidth() >= width && option.getHeight() >= height) {
bigEnough.add(option);
}
}
// Pick the smallest of those, assuming we found any
if (bigEnough.size() > 0) {
return Collections.min(bigEnough, new CompareSizesByArea());
} else {
Log.e(TAG, "Couldn't find any suitable preview size");
return choices[0];
}
}
/**
* Compares two {@code Size}s based on their areas.
*/
static class CompareSizesByArea implements Comparator<Size> {
@Override
public int compare(Size lhs, Size rhs) {
// We cast here to ensure the multiplications won't overflow
return Long.signum((long) lhs.getWidth() * lhs.getHeight() -
(long) rhs.getWidth() * rhs.getHeight());
}
}
/**
* Called when our {@code Activity} gains focus. <p>Starts initializing the camera.</p>
*/
@Override
protected void onResume() {
super.onResume();
// Start a background thread to manage camera requests
mBackgroundThread = new HandlerThread("background");
mBackgroundThread.start();
mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
mForegroundHandler = new Handler(getMainLooper());
mCameraManager = (CameraManager) getSystemService(CAMERA_SERVICE);
// Inflate the SurfaceView, set it as the main layout, and attach a listener
View layout = getLayoutInflater().inflate(R.layout.mainactivity, null);
mSurfaceView = (SurfaceView) layout.findViewById(R.id.mainSurfaceView);
mSurfaceView.getHolder().addCallback(mSurfaceHolderCallback);
setContentView(mSurfaceView);
// Control flow continues in mSurfaceHolderCallback.surfaceChanged()
}
/**
* Called when our {@code Activity} loses focus. <p>Tears everything back down.</p>
*/
@Override
protected void onPause() {
super.onPause();
try {
// Ensure SurfaceHolderCallback#surfaceChanged() will run again if the user returns
mSurfaceView.getHolder().setFixedSize(/*width*/0, /*height*/0);
// Cancel any stale preview jobs
if (mCaptureSession != null) {
mCaptureSession.close();
mCaptureSession = null;
}
} finally {
if (mCamera != null) {
mCamera.close();
mCamera = null;
}
}
// Finish processing posted messages, then join on the handling thread
mBackgroundThread.quitSafely();
try {
mBackgroundThread.join();
} catch (InterruptedException ex) {
Log.e(TAG, "Background worker thread was interrupted while joined", ex);
}
// Close the ImageReader now that the background thread has stopped
if (mCaptureBuffer != null) mCaptureBuffer.close();
}
/**
* Called when the user clicks on our {@code SurfaceView}, which has ID {@code mainSurfaceView}
* as defined in the {@code mainactivity.xml} layout file. <p>Captures a full-resolution image
* and saves it to permanent storage.</p>
*/
public void onClickOnSurfaceView(View v) {
if (mCaptureSession != null) {
try {
CaptureRequest.Builder requester =
mCamera.createCaptureRequest(mCamera.TEMPLATE_STILL_CAPTURE);
requester.addTarget(mCaptureBuffer.getSurface());
try {
// This handler can be null because we aren't actually attaching any callback
mCaptureSession.capture(requester.build(), /*listener*/null, /*handler*/null);
} catch (CameraAccessException ex) {
Log.e(TAG, "Failed to file actual capture request", ex);
}
} catch (CameraAccessException ex) {
Log.e(TAG, "Failed to build actual capture request", ex);
}
} else {
Log.e(TAG, "User attempted to perform a capture outside our session");
}
// Control flow continues in mImageCaptureListener.onImageAvailable()
}
/**
* Callbacks invoked upon state changes in our {@code SurfaceView}.
*/
final SurfaceHolder.Callback mSurfaceHolderCallback = new SurfaceHolder.Callback() {
/** The camera device to use, or null if we haven't yet set a fixed surface size. */
private String mCameraId;
/** Whether we received a change callback after setting our fixed surface size. */
private boolean mGotSecondCallback;
@Override
public void surfaceCreated(SurfaceHolder holder) {
// This is called every time the surface returns to the foreground
Log.i(TAG, "Surface created");
mCameraId = null;
mGotSecondCallback = false;
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
Log.i(TAG, "Surface destroyed");
holder.removeCallback(this);
// We don't stop receiving callbacks forever because onResume() will reattach us
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
// On the first invocation, width and height were automatically set to the view's size
if (mCameraId == null) {
// Find the device's back-facing camera and set the destination buffer sizes
try {
for (String cameraId : mCameraManager.getCameraIdList()) {
CameraCharacteristics cameraCharacteristics =
mCameraManager.getCameraCharacteristics(cameraId);
if (cameraCharacteristics.get(cameraCharacteristics.LENS_FACING) ==
CameraCharacteristics.LENS_FACING_BACK) {
Log.i(TAG, "Found a back-facing camera");
StreamConfigurationMap info = cameraCharacteristics
.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
// Bigger is better when it comes to saving our image
Size largestSize = Collections.max(
Arrays.asList(info.getOutputSizes(ImageFormat.JPEG)),
new CompareSizesByArea());
// Prepare an ImageReader in case the user wants to capture images
Log.i(TAG, "Capture size: " + largestSize);
mCaptureBuffer = ImageReader.newInstance(largestSize.getWidth(),
largestSize.getHeight(), ImageFormat.JPEG, /*maxImages*/2);
mCaptureBuffer.setOnImageAvailableListener(
mImageCaptureListener, mBackgroundHandler);
// Danger, W.R.! Attempting to use too large a preview size could
// exceed the camera bus' bandwidth limitation, resulting in
// gorgeous previews but the storage of garbage capture data.
Log.i(TAG, "SurfaceView size: " +
mSurfaceView.getWidth() + 'x' + mSurfaceView.getHeight());
Size optimalSize = chooseBigEnoughSize(
info.getOutputSizes(SurfaceHolder.class), width, height);
// Set the SurfaceHolder to use the camera's largest supported size
Log.i(TAG, "Preview size: " + optimalSize);
SurfaceHolder surfaceHolder = mSurfaceView.getHolder();
surfaceHolder.setFixedSize(optimalSize.getWidth(),
optimalSize.getHeight());
mCameraId = cameraId;
return;
// Control flow continues with this method one more time
// (since we just changed our own size)
}
}
} catch (CameraAccessException ex) {
Log.e(TAG, "Unable to list cameras", ex);
}
Log.e(TAG, "Didn't find any back-facing cameras");
// This is the second time the method is being invoked: our size change is complete
} else if (!mGotSecondCallback) {
if (mCamera != null) {
Log.e(TAG, "Aborting camera open because it hadn't been closed");
return;
}
// Open the camera device
try {
mCameraManager.openCamera(mCameraId, mCameraStateListener,
mBackgroundHandler);
} catch (CameraAccessException ex) {
Log.e(TAG, "Failed to configure output surface", ex);
}
mGotSecondCallback = true;
// Control flow continues in mCameraStateListener.onOpened()
}
}};
/**
* Calledbacks invoked upon state changes in our {@code CameraDevice}. <p>These are run on
* {@code mBackgroundThread}.</p>
*/
final CameraDevice.StateListener mCameraStateListener =
new CameraDevice.StateListener() {
@Override
public void onOpened(CameraDevice camera) {
Log.i(TAG, "Successfully opened camera");
mCamera = camera;
try {
List<Surface> outputs = Arrays.asList(
mSurfaceView.getHolder().getSurface(), mCaptureBuffer.getSurface());
camera.createCaptureSession(outputs, mCaptureSessionListener,
mBackgroundHandler);
} catch (CameraAccessException ex) {
Log.e(TAG, "Failed to create a capture session", ex);
}
// Control flow continues in mCaptureSessionListener.onConfigured()
}
@Override
public void onDisconnected(CameraDevice camera) {
Log.e(TAG, "Camera was disconnected");
}
@Override
public void onError(CameraDevice camera, int error) {
Log.e(TAG, "State error on device '" + camera.getId() + "': code " + error);
}};
/**
* Callbacks invoked upon state changes in our {@code CameraCaptureSession}. <p>These are run on
* {@code mBackgroundThread}.</p>
*/
final CameraCaptureSession.StateListener mCaptureSessionListener =
new CameraCaptureSession.StateListener() {
@Override
public void onConfigured(CameraCaptureSession session) {
Log.i(TAG, "Finished configuring camera outputs");
mCaptureSession = session;
SurfaceHolder holder = mSurfaceView.getHolder();
if (holder != null) {
try {
// Build a request for preview footage
CaptureRequest.Builder requestBuilder =
mCamera.createCaptureRequest(mCamera.TEMPLATE_PREVIEW);
requestBuilder.addTarget(holder.getSurface());
CaptureRequest previewRequest = requestBuilder.build();
// Start displaying preview images
try {
session.setRepeatingRequest(previewRequest, /*listener*/null,
/*handler*/null);
} catch (CameraAccessException ex) {
Log.e(TAG, "Failed to make repeating preview request", ex);
}
} catch (CameraAccessException ex) {
Log.e(TAG, "Failed to build preview request", ex);
}
}
else {
Log.e(TAG, "Holder didn't exist when trying to formulate preview request");
}
}
@Override
public void onClosed(CameraCaptureSession session) {
mCaptureSession = null;
}
@Override
public void onConfigureFailed(CameraCaptureSession session) {
Log.e(TAG, "Configuration error on device '" + mCamera.getId());
}};
/**
* Callback invoked when we've received a JPEG image from the camera.
*/
final ImageReader.OnImageAvailableListener mImageCaptureListener =
new ImageReader.OnImageAvailableListener() {
@Override
public void onImageAvailable(ImageReader reader) {
// Save the image once we get a chance
mBackgroundHandler.post(new CapturedImageSaver(reader.acquireNextImage()));
// Control flow continues in CapturedImageSaver#run()
}};
/**
* Deferred processor responsible for saving snapshots to disk. <p>This is run on
* {@code mBackgroundThread}.</p>
*/
static class CapturedImageSaver implements Runnable {
/** The image to save. */
private Image mCapture;
public CapturedImageSaver(Image capture) {
mCapture = capture;
}
@Override
public void run() {
try {
// Choose an unused filename under the Pictures/ directory
File file = File.createTempFile(CAPTURE_FILENAME_PREFIX, ".jpg",
Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES));
try (FileOutputStream ostream = new FileOutputStream(file)) {
Log.i(TAG, "Retrieved image is" +
(mCapture.getFormat() == ImageFormat.JPEG ? "" : "n't") + " a JPEG");
ByteBuffer buffer = mCapture.getPlanes()[0].getBuffer();
Log.i(TAG, "Captured image size: " +
mCapture.getWidth() + 'x' + mCapture.getHeight());
// Write the image out to the chosen file
byte[] jpeg = new byte[buffer.remaining()];
buffer.get(jpeg);
ostream.write(jpeg);
} catch (FileNotFoundException ex) {
Log.e(TAG, "Unable to open output file for writing", ex);
} catch (IOException ex) {
Log.e(TAG, "Failed to write the image to the output file", ex);
}
} catch (IOException ex) {
Log.e(TAG, "Unable to create a new output file", ex);
} finally {
mCapture.close();
}
}
}
}

25
tests/Camera2Tests/CameraToo/tests/Android.mk Normal file
View File

@@ -0,0 +1,25 @@
# 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.
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := tests
LOCAL_PACKAGE_NAME := CameraTooTests
LOCAL_INSTRUMENTATION_FOR := CameraToo
LOCAL_SDK_VERSION := current
LOCAL_SRC_FILES := $(call all-java-files-under,src)
LOCAL_STATIC_JAVA_LIBRARIES := android-support-test mockito-target
include $(BUILD_PACKAGE)

29
tests/Camera2Tests/CameraToo/tests/AndroidManifest.xml Normal file
View File

@@ -0,0 +1,29 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
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.
-->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.android.camera2.cameratoo.tests">
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<application android:label="CameraToo">
<uses-library android:name="android.test.runner" />
</application>
<instrumentation android:name="android.support.test.runner.AndroidJUnitRunner"
android:targetPackage="com.example.android.camera2.cameratoo"
android:label="CameraToo tests" />
</manifest>

189
tests/Camera2Tests/CameraToo/tests/src/com/example/android/camera2/cameratoo/CameraTooTest.java Normal file
View File

@@ -0,0 +1,189 @@
/*
* 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.example.android.camera2.cameratoo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import android.media.Image;
import android.os.Environment;
import android.util.Size;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FilenameFilter;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import com.example.android.camera2.cameratoo.CameraTooActivity;
import org.junit.Test;
public class CameraTooTest {
private <T> void assertComparatorEq(T lhs, T rhs, Comparator<T> rel) {
assertEquals(String.format("%s should be equal to %s", lhs, rhs), rel.compare(lhs, rhs), 0);
assertEquals(String.format("%s should be equal to %s (reverse check)", lhs, rhs),
rel.compare(rhs, lhs), 0);
}
private <T> void assertComparatorLt(T lhs, T rhs, Comparator<T> rel) {
assertTrue(String.format("%s should be less than %s", lhs, rhs), rel.compare(lhs, rhs) < 0);
assertTrue(String.format("%s should be less than %s (reverse check)", lhs, rhs),
rel.compare(rhs, lhs) > 0);
}
@Test
public void compareSizesByArea() {
Size empty = new Size(0, 0), fatAndFlat = new Size(100, 0), tallAndThin = new Size(0, 100);
Size smallSquare = new Size(4, 4), horizRect = new Size(8, 2), vertRect = new Size(2, 8);
Size largeSquare = new Size(5, 5);
Comparator<Size> rel = new CameraTooActivity.CompareSizesByArea();
assertComparatorEq(empty, fatAndFlat, rel);
assertComparatorEq(empty, tallAndThin, rel);
assertComparatorEq(fatAndFlat, empty, rel);
assertComparatorEq(fatAndFlat, tallAndThin, rel);
assertComparatorEq(tallAndThin, empty, rel);
assertComparatorEq(tallAndThin, fatAndFlat, rel);
assertComparatorEq(smallSquare, horizRect, rel);
assertComparatorEq(smallSquare, vertRect, rel);
assertComparatorEq(horizRect, smallSquare, rel);
assertComparatorEq(horizRect, vertRect, rel);
assertComparatorEq(vertRect, smallSquare, rel);
assertComparatorEq(vertRect, horizRect, rel);
assertComparatorLt(empty, smallSquare, rel);
assertComparatorLt(empty, horizRect, rel);
assertComparatorLt(empty, vertRect, rel);
assertComparatorLt(fatAndFlat, smallSquare, rel);
assertComparatorLt(fatAndFlat, horizRect, rel);
assertComparatorLt(fatAndFlat, vertRect, rel);
assertComparatorLt(tallAndThin, smallSquare, rel);
assertComparatorLt(tallAndThin, horizRect, rel);
assertComparatorLt(tallAndThin, vertRect, rel);
assertComparatorLt(empty, largeSquare, rel);
assertComparatorLt(fatAndFlat, largeSquare, rel);
assertComparatorLt(tallAndThin, largeSquare, rel);
assertComparatorLt(smallSquare, largeSquare, rel);
assertComparatorLt(horizRect, largeSquare, rel);
assertComparatorLt(vertRect, largeSquare, rel);
}
private void assertOptimalSize(Size[] options, int minWidth, int minHeight, Size expected) {
Size verdict = CameraTooActivity.chooseBigEnoughSize(options, minWidth, minHeight);
assertEquals(String.format("Expected optimal size %s but got %s", expected, verdict),
verdict, expected);
}
@Test
public void chooseBigEnoughSize() {
Size empty = new Size(0, 0), fatAndFlat = new Size(100, 0), tallAndThin = new Size(0, 100);
Size smallSquare = new Size(4, 4), horizRect = new Size(8, 2), vertRect = new Size(2, 8);
Size largeSquare = new Size(5, 5);
Size[] siz =
{ empty, fatAndFlat, tallAndThin, smallSquare, horizRect, vertRect, largeSquare };
assertOptimalSize(siz, 0, 0, empty);
assertOptimalSize(siz, 1, 0, fatAndFlat);
assertOptimalSize(siz, 0, 1, tallAndThin);
assertOptimalSize(siz, 4, 4, smallSquare);
assertOptimalSize(siz, 1, 1, smallSquare);
assertOptimalSize(siz, 2, 1, smallSquare);
assertOptimalSize(siz, 1, 2, smallSquare);
assertOptimalSize(siz, 3, 4, smallSquare);
assertOptimalSize(siz, 4, 3, smallSquare);
assertOptimalSize(siz, 8, 2, horizRect);
assertOptimalSize(siz, 5, 1, horizRect);
assertOptimalSize(siz, 5, 2, horizRect);
assertOptimalSize(siz, 2, 8, vertRect);
assertOptimalSize(siz, 1, 5, vertRect);
assertOptimalSize(siz, 2, 5, vertRect);
assertOptimalSize(siz, 5, 5, largeSquare);
assertOptimalSize(siz, 3, 5, largeSquare);
assertOptimalSize(siz, 5, 3, largeSquare);
}
private static final FilenameFilter OUTPUT_FILE_DECIDER = new FilenameFilter() {
@Override
public boolean accept(File dir, String filename) {
return filename.indexOf("cameratoo") == 0 &&
filename.indexOf(".jpg") == filename.length() - ".jpg".length();
}};
private static <T> Set<T> newlyAddedElements(Set<T> before, Set<T> after) {
Set<T> result = new HashSet<T>(after);
result.removeAll(before);
return result;
}
@Test
public void capturedImageSaver() throws FileNotFoundException, IOException {
ByteBuffer buf = ByteBuffer.allocate(25);
for(int index = 0; index < buf.capacity(); ++index)
buf.put(index, (byte) index);
Image.Plane plane = mock(Image.Plane.class);
when(plane.getBuffer()).thenReturn(buf);
when(plane.getPixelStride()).thenReturn(1);
when(plane.getRowStride()).thenReturn(5);
Image.Plane[] onlyPlaneThatMatters = { plane };
Image image = mock(Image.class);
when(image.getPlanes()).thenReturn(onlyPlaneThatMatters);
when(image.getWidth()).thenReturn(5);
when(image.getHeight()).thenReturn(5);
File picturesFolder =
Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
Set<File> preListing =
new HashSet<File>(Arrays.asList(picturesFolder.listFiles(OUTPUT_FILE_DECIDER)));
CameraTooActivity.CapturedImageSaver saver =
new CameraTooActivity.CapturedImageSaver(image);
saver.run();
Set<File> postListing =
new HashSet<File>(Arrays.asList(picturesFolder.listFiles(OUTPUT_FILE_DECIDER)));
Set<File> newFiles = newlyAddedElements(preListing, postListing);
assertEquals(newFiles.size(), 1);
File picture = newFiles.iterator().next();
FileInputStream istream = new FileInputStream(picture);
for(int count = 0; count < buf.capacity(); ++count) {
assertEquals(istream.read(), buf.get(count));
}
assertEquals(istream.read(), -1);
assertTrue(picture.delete());
}
}