CameraStressTest.java revision c6cedc84f49b8b72d32069cfa515a51b8c128cc0 
1/*
2 * Copyright (C) 2012 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.stress;
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.List;
30
31import android.hardware.Camera;
32import android.hardware.Camera.Parameters;
33import android.os.Environment;
34import android.os.Handler;
35import android.os.Looper;
36import android.test.ActivityInstrumentationTestCase2;
37import android.test.suitebuilder.annotation.LargeTest;
38import android.util.Log;
39import android.view.SurfaceHolder;
40import com.android.mediaframeworktest.CameraStressTestRunner;
41
42import junit.framework.Assert;
43
44/**
45 * Junit / Instrumentation test case for the following camera APIs:
46 *  - camera zoom
47 *  - scene mode
48 *
49 * adb shell am instrument
50 *  -e class com.android.mediaframeworktest.stress.CameraStressTest
51 *  -w com.android.mediaframeworktest/.CameraStressTestRunner
52 */
53public class CameraStressTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> {
54
55    private static final int NUMBER_OF_SCENE_MODE_LOOPS = 10;
56    private static final int NUMBER_OF_ZOOM_LOOPS = 100;
57    private static final long WAIT_TIMEOUT = 10 * 1000; // 10 seconds
58    private static final String CAMERA_STRESS_OUTPUT = "cameraStressOutput.txt";
59
60    private CameraTestHelper mCameraTestHelper;
61    private Handler mHandler;
62    private Thread mLooperThread;
63    private Writer mOutput;
64
65    private String TAG = "CameraStressTest";
66
67    public CameraStressTest() {
68        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
69    }
70
71    protected void setUp() throws Exception {
72        final Semaphore sem = new Semaphore(0);
73        mLooperThread = new Thread() {
74            @Override
75            public void run() {
76                Log.v(TAG, "starting looper");
77                Looper.prepare();
78                mHandler = new Handler();
79                sem.release();
80                Looper.loop();
81                Log.v(TAG, "quit looper");
82            }
83        };
84        mLooperThread.start();
85        if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) {
86            fail("Failed to start the looper.");
87        }
88        getActivity();
89        super.setUp();
90
91        mCameraTestHelper = new CameraTestHelper();
92        File stressOutFile = new File(String.format("%s/%s",
93                Environment.getExternalStorageDirectory(), CAMERA_STRESS_OUTPUT));
94        mOutput = new BufferedWriter(new FileWriter(stressOutFile, true));
95        mOutput.write(this.getName() + "\n");
96    }
97
98    @Override
99    protected void tearDown() throws Exception {
100        if (mHandler != null) {
101            mHandler.getLooper().quit();
102            mHandler = null;
103        }
104        if (mLooperThread != null) {
105            mLooperThread.join(WAIT_TIMEOUT);
106            if (mLooperThread.isAlive()) {
107                fail("Failed to stop the looper.");
108            }
109            mLooperThread = null;
110        }
111        mOutput.write("\n\n");
112        mOutput.close();
113        super.tearDown();
114    }
115
116    private void runOnLooper(final Runnable command) throws InterruptedException {
117        final Semaphore sem = new Semaphore(0);
118        mHandler.post(new Runnable() {
119            @Override
120            public void run() {
121                try {
122                    command.run();
123                } finally {
124                    sem.release();
125                }
126            }
127        });
128        if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) {
129            fail("Failed to run the command on the looper.");
130        }
131    }
132
133    /**
134     * Stress test iterating on the various scene modes (action, night, party, etc.)
135     */
136    @LargeTest
137    public void testStressCameraSceneModes() throws Exception {
138        try {
139            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
140            Parameters params = mCameraTestHelper.getCameraParameters();
141            List<String> supportedSceneModes = params.getSupportedSceneModes();
142            assertNotNull("No scene modes supported", supportedSceneModes);
143
144            mOutput.write("Total number of loops: " +
145                    (NUMBER_OF_SCENE_MODE_LOOPS * supportedSceneModes.size()) + "\n");
146            Log.v(TAG, "Start preview");
147            mOutput.write("No of loop: ");
148
149            for (int i = 0; i < supportedSceneModes.size(); i++) {
150                for (int j = 0; j < NUMBER_OF_SCENE_MODE_LOOPS; j++) {
151                    runOnLooper(new Runnable() {
152                        @Override
153                        public void run() {
154                            mCameraTestHelper.setupCameraTest();
155                        }
156                    });
157                    Log.v(TAG, "Setting scene mode to " + supportedSceneModes.get(i));
158                    params.setSceneMode(supportedSceneModes.get(i));
159                    mCameraTestHelper.setParameters(params);
160                    mCameraTestHelper.startCameraPreview(surfaceHolder);
161                    mCameraTestHelper.capturePhoto();
162
163                    if (i == 0 && j == 0) {
164                        mOutput.write(Integer.toString(j + i * NUMBER_OF_SCENE_MODE_LOOPS));
165                    } else {
166                        mOutput.write(", " + (j + i * NUMBER_OF_SCENE_MODE_LOOPS));
167                    }
168                }
169            }
170            mCameraTestHelper.cleanupTestImages();
171        } catch (Exception e) {
172            Log.e(TAG, e.toString());
173            fail("Camera scene mode test Exception");
174        }
175    }
176
177    /**
178     * Stress test iterating on the range of supported camera zoom levels
179     */
180    @LargeTest
181    public void testStressCameraZoom() throws Exception {
182        try {
183            SurfaceHolder surfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
184            Parameters params = mCameraTestHelper.getCameraParameters();
185
186            if (!params.isSmoothZoomSupported() && !params.isZoomSupported()) {
187                Log.v(TAG, "Device camera does not support zoom");
188                fail("Camera zoom stress test failed due to unsupported feature");
189            } else {
190                Log.v(TAG, "Device camera does support zoom");
191                Log.v(TAG, "Start preview");
192                mOutput.write("Total number of loops: " + NUMBER_OF_ZOOM_LOOPS + "\n");
193                mOutput.write("No of loops: ");
194
195                int nextZoomLevel = 0;
196
197                for (int i = 0; i < NUMBER_OF_ZOOM_LOOPS; i++) {
198                    runOnLooper(new Runnable() {
199                        @Override
200                        public void run() {
201                            mCameraTestHelper.setupCameraTest();
202                        }
203                    });
204
205                    mCameraTestHelper.startCameraPreview(surfaceHolder);
206                    params = mCameraTestHelper.mCamera.getParameters();
207                    int currentZoomLevel = params.getZoom();
208
209                    if (nextZoomLevel >= params.getMaxZoom()) {
210                        nextZoomLevel = 0;
211                    }
212                    ++nextZoomLevel;
213
214                    if (params.isSmoothZoomSupported()) {
215                        mCameraTestHelper.mCamera.startSmoothZoom(nextZoomLevel);
216                    } else {
217                        params.setZoom(nextZoomLevel);
218                        mCameraTestHelper.setParameters(params);
219                    }
220                    mCameraTestHelper.capturePhoto();
221
222                    if (i == 0) {
223                        mOutput.write(Integer.toString(i));
224                    } else {
225                        mOutput.write(", " + i);
226                    }
227                }
228            }
229            mCameraTestHelper.cleanupTestImages();
230        } catch (Exception e) {
231            Log.e(TAG, e.toString());
232            fail("Camera zoom stress test Exception");
233        }
234    }
235}
236