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 
17 package com.android.camera.stress;
18 
19 import android.app.Instrumentation;
20 import android.os.Environment;
21 import android.test.ActivityInstrumentationTestCase2;
22 import android.test.suitebuilder.annotation.LargeTest;
23 import android.util.Log;
24 import android.view.KeyEvent;
25 import com.android.camera.CameraActivity;
26 import java.io.BufferedWriter;
27 import java.io.File;
28 import java.io.FilenameFilter;
29 import java.io.FileWriter;
30 import java.io.IOException;
31 import java.util.ArrayList;
32 
33 /**
34  * Junit / Instrumentation test case for measuring camera shot to shot latency
35  */
36 public class ShotToShotLatency extends ActivityInstrumentationTestCase2<CameraActivity> {
37     private String TAG = "ShotToShotLatency";
38     private static final int TOTAL_NUMBER_OF_SNAPSHOTS = 250;
39     private static final long SNAPSHOT_WAIT = 1000;
40     private static final String CAMERA_TEST_OUTPUT_FILE =
41             Environment.getExternalStorageDirectory().toString() + "/mediaStressOut.txt";
42     private static final String CAMERA_IMAGE_DIRECTORY =
43             Environment.getExternalStorageDirectory().toString() + "/DCIM/Camera/";
44 
ShotToShotLatency()45     public ShotToShotLatency() {
46         super(CameraActivity.class);
47     }
48 
49     @Override
setUp()50     protected void setUp() throws Exception {
51         getActivity();
52         super.setUp();
53     }
54 
55     @Override
tearDown()56     protected void tearDown() throws Exception {
57         super.tearDown();
58     }
59 
cleanupLatencyImages()60     private void cleanupLatencyImages() {
61         try {
62             File sdcard = new File(CAMERA_IMAGE_DIRECTORY);
63             File[] pics = null;
64             FilenameFilter filter = new FilenameFilter() {
65                 public boolean accept(File dir, String name) {
66                     return name.endsWith(".jpg");
67                 }
68             };
69             pics = sdcard.listFiles(filter);
70             for (File f : pics) {
71                 f.delete();
72             }
73         } catch (SecurityException e) {
74             Log.e(TAG, "Security manager access violation: " + e.toString());
75         }
76     }
77 
sleep(long time)78     private void sleep(long time) {
79         try {
80             Thread.sleep(time);
81         } catch (InterruptedException e) {
82             Log.e(TAG, "Sleep InterruptedException " + e.toString());
83         }
84     }
85 
testShotToShotLatency()86     public void testShotToShotLatency() {
87         long sigmaOfDiffFromMeanSquared = 0;
88         double mean = 0;
89         double standardDeviation = 0;
90         ArrayList<Long> captureTimes = new ArrayList<Long>();
91         ArrayList<Long> latencyTimes = new ArrayList<Long>();
92 
93         Log.v(TAG, "start testShotToShotLatency test");
94         Instrumentation inst = getInstrumentation();
95 
96         // Generate data points
97         for (int i = 0; i < TOTAL_NUMBER_OF_SNAPSHOTS; i++) {
98             inst.sendKeyDownUpSync(KeyEvent.KEYCODE_DPAD_CENTER);
99             sleep(SNAPSHOT_WAIT);
100             CameraActivity c = getActivity();
101             if (c.getCaptureStartTime() > 0) {
102                 captureTimes.add(c.getCaptureStartTime());
103             }
104         }
105 
106         // Calculate latencies
107         for (int j = 1; j < captureTimes.size(); j++) {
108             latencyTimes.add(captureTimes.get(j) - captureTimes.get(j - 1));
109         }
110 
111         // Crunch numbers
112         for (long dataPoint : latencyTimes) {
113             mean += (double) dataPoint;
114         }
115         mean /= latencyTimes.size();
116 
117         for (long dataPoint : latencyTimes) {
118             sigmaOfDiffFromMeanSquared += (dataPoint - mean) * (dataPoint - mean);
119         }
120         standardDeviation = Math.sqrt(sigmaOfDiffFromMeanSquared / latencyTimes.size());
121 
122         // Report statistics
123         File outFile = new File(CAMERA_TEST_OUTPUT_FILE);
124         BufferedWriter output = null;
125         try {
126             output = new BufferedWriter(new FileWriter(outFile, true));
127             output.write("Shot to shot latency - mean: " + mean + "\n");
128             output.write("Shot to shot latency - standard deviation: " + standardDeviation + "\n");
129             cleanupLatencyImages();
130         } catch (IOException e) {
131             Log.e(TAG, "testShotToShotLatency IOException writing to log " + e.toString());
132         } finally {
133             try {
134                 if (output != null) {
135                     output.close();
136                 }
137             } catch (IOException e) {
138                 Log.e(TAG, "Error closing file: " + e.toString());
139             }
140         }
141     }
142 }
143