CameraFunctionalTest.java revision 33253a4baa6279f81a73425b49dfb6abe5f5416e 
1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.mediaframeworktest.functional.camera;
18
19import com.android.mediaframeworktest.MediaFrameworkTest;
20import com.android.mediaframeworktest.CameraTestHelper;
21
22import java.io.BufferedWriter;
23import java.io.File;
24import java.io.FileWriter;
25import java.io.IOException;
26import java.io.Writer;
27import java.util.concurrent.Semaphore;
28import java.util.concurrent.TimeUnit;
29import java.util.HashMap;
30import java.util.List;
31import java.util.Map;
32
33import android.hardware.Camera;
34import android.hardware.Camera.Parameters;
35import android.os.Environment;
36import android.os.Handler;
37import android.os.Looper;
38import android.test.ActivityInstrumentationTestCase2;
39import android.test.suitebuilder.annotation.LargeTest;
40import android.util.Log;
41import android.view.SurfaceHolder;
42import com.android.mediaframeworktest.CameraStressTestRunner;
43
44import junit.framework.Assert;
45
46/**
47 * Junit / Instrumentation test case for the following camera APIs:
48 * - flash
49 * - exposure compensation
50 * - white balance
51 * - focus mode
52 *
53 * adb shell am instrument
54 *  -e class com.android.mediaframeworktest.functional.camera.CameraFunctionalTest
55 *  -w com.android.mediaframework/.CameraStressTestRunner
56 */
57public class CameraFunctionalTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> {
58    private static final long WAIT_TIMEOUT = 10 * 1000; // 10 seconds
59    private CameraTestHelper mCameraTestHelper;
60    private Handler mHandler;
61    private Thread mLooperThread;
62    private Writer mOutput;
63
64    private String TAG = "CameraFunctionalTest";
65
66    public CameraFunctionalTest() {
67        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
68    }
69
70    protected void setUp() throws Exception {
71        final Semaphore sem = new Semaphore(0);
72        mLooperThread = new Thread() {
73            @Override
74            public void run() {
75                Log.v(TAG, "starting looper");
76                Looper.prepare();
77                mHandler = new Handler();
78                sem.release();
79                Looper.loop();
80                Log.v(TAG, "quit looper");
81            }
82        };
83        mLooperThread.start();
84        if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) {
85            fail("Failed to start the looper.");
86        }
87        getActivity();
88        super.setUp();
89
90        mCameraTestHelper = new CameraTestHelper();
91    }
92
93    @Override
94    protected void tearDown() throws Exception {
95        if (mHandler != null) {
96            mHandler.getLooper().quit();
97            mHandler = null;
98        }
99        if (mLooperThread != null) {
100            mLooperThread.join(WAIT_TIMEOUT);
101            if (mLooperThread.isAlive()) {
102                fail("Failed to stop the looper.");
103            }
104            mLooperThread = null;
105        }
106        super.tearDown();
107    }
108
109    private void runOnLooper(final Runnable command) throws InterruptedException {
110        final Semaphore sem = new Semaphore(0);
111        mHandler.post(new Runnable() {
112            @Override
113            public void run() {
114                try {
115                    command.run();
116                } finally {
117                    sem.release();
118                }
119            }
120        });
121        if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) {
122            fail("Failed to run the command on the looper.");
123        }
124    }
125
126    /**
127     * Functional test iterating on the range of supported exposure compensation levels
128     */
129    @LargeTest
130    public void testFunctionalCameraExposureCompensation() throws Exception {
131        try {
132            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
133            Parameters params = mCameraTestHelper.getCameraParameters();
134
135            int min = params.getMinExposureCompensation();
136            int max = params.getMaxExposureCompensation();
137            assertFalse("Adjusting exposure not supported", (max == 0 && min == 0));
138            float step = params.getExposureCompensationStep();
139            int stepsPerEV = (int) Math.round(Math.pow((double) step, -1));
140
141            // only get integer values for exposure compensation
142            for (int i = min; i <= max; i += stepsPerEV) {
143                runOnLooper(new Runnable() {
144                    @Override
145                    public void run() {
146                        mCameraTestHelper.setupCameraTest();
147                    }
148                });
149                Log.v(TAG, "Setting exposure compensation index to " + i);
150                params.setExposureCompensation(i);
151                mCameraTestHelper.setParameters(params);
152                mCameraTestHelper.startCameraPreview(surfaceHolder);
153                mCameraTestHelper.capturePhoto();
154            }
155            mCameraTestHelper.cleanupTestImages();
156        } catch (Exception e) {
157            Log.e(TAG, e.toString());
158            fail("Camera exposure compensation test Exception");
159        }
160    }
161
162    /**
163     * Functional test iterating on the various flash modes (on, off, auto, torch)
164     */
165    @LargeTest
166    public void testFunctionalCameraFlashModes() throws Exception {
167        try {
168            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
169            Parameters params = mCameraTestHelper.getCameraParameters();
170            List<String> supportedFlashModes = params.getSupportedFlashModes();
171            assertNotNull("No flash modes supported", supportedFlashModes);
172
173            for (int i = 0; i < supportedFlashModes.size(); i++) {
174                runOnLooper(new Runnable() {
175                    @Override
176                    public void run() {
177                        mCameraTestHelper.setupCameraTest();
178                    }
179                });
180                Log.v(TAG, "Setting flash mode to " + supportedFlashModes.get(i));
181                params.setFlashMode(supportedFlashModes.get(i));
182                mCameraTestHelper.setParameters(params);
183                mCameraTestHelper.startCameraPreview(surfaceHolder);
184                mCameraTestHelper.capturePhoto();
185            }
186            mCameraTestHelper.cleanupTestImages();
187        } catch (Exception e) {
188            Log.e(TAG, e.toString());
189            fail("Camera flash mode test Exception");
190        }
191    }
192
193    /**
194     * Functional test iterating on the various focus modes (auto, infinitiy, macro, etc.)
195     */
196    @LargeTest
197    public void testFunctionalCameraFocusModes() throws Exception {
198        try {
199            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
200            Parameters params = mCameraTestHelper.getCameraParameters();
201            List<String> supportedFocusModes = params.getSupportedFocusModes();
202            assertNotNull("No focus modes supported", supportedFocusModes);
203
204            for (int i = 0; i < supportedFocusModes.size(); i++) {
205                runOnLooper(new Runnable() {
206                    @Override
207                    public void run() {
208                        mCameraTestHelper.setupCameraTest();
209                    }
210                });
211                Log.v(TAG, "Setting focus mode to: " + supportedFocusModes.get(i));
212                params.setFocusMode(supportedFocusModes.get(i));
213                mCameraTestHelper.setParameters(params);
214                mCameraTestHelper.startCameraPreview(surfaceHolder);
215                mCameraTestHelper.capturePhoto();
216            }
217            mCameraTestHelper.cleanupTestImages();
218        } catch (Exception e) {
219            Log.e(TAG, e.toString());
220            fail("Camera focus modes test Exception");
221        }
222    }
223
224    /**
225     * Functional test iterating on the various white balances (auto, daylight, cloudy, etc.)
226     */
227    @LargeTest
228    public void testFunctionalCameraWhiteBalance() throws Exception {
229        try {
230            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
231            Parameters params = mCameraTestHelper.getCameraParameters();
232            List<String> supportedWhiteBalance = params.getSupportedWhiteBalance();
233            assertNotNull("No white balance modes supported", supportedWhiteBalance);
234
235            for (int i = 0; i < supportedWhiteBalance.size(); i++) {
236                runOnLooper(new Runnable() {
237                    @Override
238                    public void run() {
239                        mCameraTestHelper.setupCameraTest();
240                    }
241                });
242                Log.v(TAG, "Setting white balance to: " + supportedWhiteBalance.get(i));
243                params.setWhiteBalance(supportedWhiteBalance.get(i));
244                mCameraTestHelper.setParameters(params);
245                mCameraTestHelper.startCameraPreview(surfaceHolder);
246                mCameraTestHelper.capturePhoto();
247            }
248            mCameraTestHelper.cleanupTestImages();
249        } catch (Exception e) {
250            Log.e(TAG, e.toString());
251            fail("Camera focus modes test Exception");
252        }
253    }
254}
255