CameraFunctionalTest.java revision 6d8fd0a23fdc01b9414202c3de9bba41222583e6 
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.helpers.CameraTestHelper;
21
22import java.io.Writer;
23import java.util.concurrent.Semaphore;
24import java.util.concurrent.TimeUnit;
25import java.util.List;
26
27import android.hardware.Camera.Parameters;
28import android.os.Handler;
29import android.os.Looper;
30import android.test.ActivityInstrumentationTestCase2;
31import android.test.suitebuilder.annotation.LargeTest;
32import android.util.Log;
33import android.view.SurfaceHolder;
34
35/**
36 * Junit / Instrumentation test case for the following camera APIs:
37 * - flash
38 * - exposure compensation
39 * - white balance
40 * - focus mode
41 *
42 * adb shell am instrument
43 *  -e class com.android.mediaframeworktest.functional.camera.CameraFunctionalTest
44 *  -w com.android.mediaframework/.CameraStressTestRunner
45 */
46public class CameraFunctionalTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> {
47    private static final long WAIT_TIMEOUT = 10 * 1000; // 10 seconds
48    private CameraTestHelper mCameraTestHelper;
49    private Handler mHandler;
50    private Thread mLooperThread;
51    private Writer mOutput;
52
53    private String TAG = "CameraFunctionalTest";
54
55    public CameraFunctionalTest() {
56        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
57    }
58
59    protected void setUp() throws Exception {
60        final Semaphore sem = new Semaphore(0);
61        mLooperThread = new Thread() {
62            @Override
63            public void run() {
64                Log.v(TAG, "starting looper");
65                Looper.prepare();
66                mHandler = new Handler();
67                sem.release();
68                Looper.loop();
69                Log.v(TAG, "quit looper");
70            }
71        };
72        mLooperThread.start();
73        if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) {
74            fail("Failed to start the looper.");
75        }
76        getActivity();
77        super.setUp();
78
79        mCameraTestHelper = new CameraTestHelper();
80    }
81
82    @Override
83    protected void tearDown() throws Exception {
84        if (mHandler != null) {
85            mHandler.getLooper().quit();
86            mHandler = null;
87        }
88        if (mLooperThread != null) {
89            mLooperThread.join(WAIT_TIMEOUT);
90            if (mLooperThread.isAlive()) {
91                fail("Failed to stop the looper.");
92            }
93            mLooperThread = null;
94        }
95        super.tearDown();
96    }
97
98    private void runOnLooper(final Runnable command) throws InterruptedException {
99        final Semaphore sem = new Semaphore(0);
100        mHandler.post(new Runnable() {
101            @Override
102            public void run() {
103                try {
104                    command.run();
105                } finally {
106                    sem.release();
107                }
108            }
109        });
110        if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) {
111            fail("Failed to run the command on the looper.");
112        }
113    }
114
115    /**
116     * Functional test iterating on the range of supported exposure compensation levels
117     */
118    @LargeTest
119    public void testFunctionalCameraExposureCompensation() throws Exception {
120        try {
121            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
122            Parameters params = mCameraTestHelper.getCameraParameters();
123
124            int min = params.getMinExposureCompensation();
125            int max = params.getMaxExposureCompensation();
126            assertFalse("Adjusting exposure not supported", (max == 0 && min == 0));
127            float step = params.getExposureCompensationStep();
128            int stepsPerEV = (int) Math.round(Math.pow((double) step, -1));
129
130            // only get integer values for exposure compensation
131            for (int i = min; i <= max; i += stepsPerEV) {
132                runOnLooper(new Runnable() {
133                    @Override
134                    public void run() {
135                        mCameraTestHelper.setupCameraTest();
136                    }
137                });
138                Log.v(TAG, "Setting exposure compensation index to " + i);
139                params.setExposureCompensation(i);
140                mCameraTestHelper.setParameters(params);
141                mCameraTestHelper.startCameraPreview(surfaceHolder);
142                mCameraTestHelper.capturePhoto();
143            }
144            mCameraTestHelper.cleanupTestImages();
145        } catch (Exception e) {
146            Log.e(TAG, e.toString());
147            fail("Camera exposure compensation test Exception");
148        }
149    }
150
151    /**
152     * Functional test iterating on the various flash modes (on, off, auto, torch)
153     */
154    @LargeTest
155    public void testFunctionalCameraFlashModes() throws Exception {
156        try {
157            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
158            Parameters params = mCameraTestHelper.getCameraParameters();
159            List<String> supportedFlashModes = params.getSupportedFlashModes();
160            assertNotNull("No flash modes supported", supportedFlashModes);
161
162            for (int i = 0; i < supportedFlashModes.size(); i++) {
163                runOnLooper(new Runnable() {
164                    @Override
165                    public void run() {
166                        mCameraTestHelper.setupCameraTest();
167                    }
168                });
169                Log.v(TAG, "Setting flash mode to " + supportedFlashModes.get(i));
170                params.setFlashMode(supportedFlashModes.get(i));
171                mCameraTestHelper.setParameters(params);
172                mCameraTestHelper.startCameraPreview(surfaceHolder);
173                mCameraTestHelper.capturePhoto();
174            }
175            mCameraTestHelper.cleanupTestImages();
176        } catch (Exception e) {
177            Log.e(TAG, e.toString());
178            fail("Camera flash mode test Exception");
179        }
180    }
181
182    /**
183     * Functional test iterating on the various focus modes (auto, infinitiy, macro, etc.)
184     */
185    @LargeTest
186    public void testFunctionalCameraFocusModes() throws Exception {
187        try {
188            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
189            Parameters params = mCameraTestHelper.getCameraParameters();
190            List<String> supportedFocusModes = params.getSupportedFocusModes();
191            assertNotNull("No focus modes supported", supportedFocusModes);
192
193            for (int i = 0; i < supportedFocusModes.size(); i++) {
194                runOnLooper(new Runnable() {
195                    @Override
196                    public void run() {
197                        mCameraTestHelper.setupCameraTest();
198                    }
199                });
200                Log.v(TAG, "Setting focus mode to: " + supportedFocusModes.get(i));
201                params.setFocusMode(supportedFocusModes.get(i));
202                mCameraTestHelper.setParameters(params);
203                mCameraTestHelper.startCameraPreview(surfaceHolder);
204                mCameraTestHelper.capturePhoto();
205            }
206            mCameraTestHelper.cleanupTestImages();
207        } catch (Exception e) {
208            Log.e(TAG, e.toString());
209            fail("Camera focus modes test Exception");
210        }
211    }
212
213    /**
214     * Functional test iterating on the various white balances (auto, daylight, cloudy, etc.)
215     */
216    @LargeTest
217    public void testFunctionalCameraWhiteBalance() throws Exception {
218        try {
219            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
220            Parameters params = mCameraTestHelper.getCameraParameters();
221            List<String> supportedWhiteBalance = params.getSupportedWhiteBalance();
222            assertNotNull("No white balance modes supported", supportedWhiteBalance);
223
224            for (int i = 0; i < supportedWhiteBalance.size(); i++) {
225                runOnLooper(new Runnable() {
226                    @Override
227                    public void run() {
228                        mCameraTestHelper.setupCameraTest();
229                    }
230                });
231                Log.v(TAG, "Setting white balance to: " + supportedWhiteBalance.get(i));
232                params.setWhiteBalance(supportedWhiteBalance.get(i));
233                mCameraTestHelper.setParameters(params);
234                mCameraTestHelper.startCameraPreview(surfaceHolder);
235                mCameraTestHelper.capturePhoto();
236            }
237            mCameraTestHelper.cleanupTestImages();
238        } catch (Exception e) {
239            Log.e(TAG, e.toString());
240            fail("Camera focus modes test Exception");
241        }
242    }
243}
244