1 /*
2  * Copyright 2019 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 @file:Suppress("DEPRECATION")
18 
19 package androidx.camera.integration.antelope
20 
21 import android.content.SharedPreferences
22 import android.os.Build
23 import android.preference.PreferenceManager
24 import java.util.Collections
25 import kotlin.collections.ArrayList
26 import kotlin.collections.HashMap
27 import kotlin.collections.HashSet
28 import kotlin.collections.asList
29 import kotlin.collections.iterator
30 
31 /** Convenience class to simplify getting values for Shared Preferences */
32 class PrefHelper {
33     companion object {
getAutoDeletenull34         internal fun getAutoDelete(activity: MainActivity): Boolean {
35             val sharedPref: SharedPreferences =
36                 PreferenceManager.getDefaultSharedPreferences(activity)
37             return sharedPref.getBoolean(activity.getString(R.string.settings_autodelete_key), true)
38         }
39 
getNumTestsnull40         internal fun getNumTests(activity: MainActivity): Int {
41             val sharedPref: SharedPreferences =
42                 PreferenceManager.getDefaultSharedPreferences(activity)
43             return (sharedPref.getString(activity.getString(R.string.settings_numtests_key), "30")
44                     ?: "30")
45                 .toInt()
46         }
47 
getPreviewBuffernull48         internal fun getPreviewBuffer(activity: MainActivity): Long {
49             val sharedPref: SharedPreferences =
50                 PreferenceManager.getDefaultSharedPreferences(activity)
51             return (sharedPref.getString(
52                     activity.getString(R.string.settings_previewbuffer_key),
53                     "1500"
54                 ) ?: "1500")
55                 .toLong()
56         }
57 
getAPIsnull58         internal fun getAPIs(activity: MainActivity): ArrayList<CameraAPI> {
59             val sharedPref: SharedPreferences =
60                 PreferenceManager.getDefaultSharedPreferences(activity)
61             val defApis: HashSet<String> =
62                 HashSet(activity.resources.getStringArray(R.array.array_settings_api).asList())
63 
64             val apiStrings: HashSet<String> =
65                 sharedPref.getStringSet(
66                     activity.getString(R.string.settings_autotest_api_key),
67                     defApis
68                 ) as HashSet<String>
69 
70             val apis: ArrayList<CameraAPI> = ArrayList()
71 
72             for (apiString in apiStrings) {
73                 when (apiString) {
74                     "Camera1" -> apis.add(CameraAPI.CAMERA1)
75                     "Camera2" -> apis.add(CameraAPI.CAMERA2)
76                     "CameraX" -> apis.add(CameraAPI.CAMERAX)
77                 }
78             }
79 
80             Collections.sort(apis, ApiComparator())
81             return apis
82         }
83 
getImageSizesnull84         internal fun getImageSizes(activity: MainActivity): ArrayList<ImageCaptureSize> {
85             val sharedPref: SharedPreferences =
86                 PreferenceManager.getDefaultSharedPreferences(activity)
87             val defSizes: HashSet<String> =
88                 HashSet(
89                     activity.resources.getStringArray(R.array.array_settings_imagesize).asList()
90                 )
91 
92             val sizeStrings: HashSet<String> =
93                 sharedPref.getStringSet(
94                     activity.getString(R.string.settings_autotest_imagesize_key),
95                     defSizes
96                 ) as HashSet<String>
97 
98             val sizes: ArrayList<ImageCaptureSize> = ArrayList()
99 
100             for (sizeString in sizeStrings) {
101                 when (sizeString) {
102                     "Min" -> sizes.add(ImageCaptureSize.MIN)
103                     "Max" -> sizes.add(ImageCaptureSize.MAX)
104                 }
105             }
106 
107             Collections.sort(sizes, ImageSizeComparator())
108             return sizes
109         }
110 
getFocusModesnull111         internal fun getFocusModes(activity: MainActivity): ArrayList<FocusMode> {
112             val sharedPref: SharedPreferences =
113                 PreferenceManager.getDefaultSharedPreferences(activity)
114             val defModes: HashSet<String> =
115                 HashSet(activity.resources.getStringArray(R.array.array_settings_focus).asList())
116 
117             val modeStrings: HashSet<String> =
118                 sharedPref.getStringSet(
119                     activity.getString(R.string.settings_autotest_focus_key),
120                     defModes
121                 ) as HashSet<String>
122 
123             val modes: ArrayList<FocusMode> = ArrayList()
124 
125             for (modeString in modeStrings) {
126                 when (modeString) {
127                     "Auto" -> modes.add(FocusMode.AUTO)
128                     "Continuous" -> modes.add(FocusMode.CONTINUOUS)
129                     "Fixed" -> modes.add(FocusMode.FIXED)
130                 }
131             }
132 
133             Collections.sort(modes, FocusModeComparator())
134             return modes
135         }
136 
getOnlyLogicalnull137         internal fun getOnlyLogical(activity: MainActivity): Boolean {
138             val sharedPref: SharedPreferences =
139                 PreferenceManager.getDefaultSharedPreferences(activity)
140             return sharedPref.getBoolean(
141                 activity.getString(R.string.settings_autotest_cameras_key),
142                 true
143             )
144         }
145 
getSwitchTestnull146         internal fun getSwitchTest(activity: MainActivity): Boolean {
147             val sharedPref: SharedPreferences =
148                 PreferenceManager.getDefaultSharedPreferences(activity)
149             return sharedPref.getBoolean(
150                 activity.getString(R.string.settings_autotest_switchtest_key),
151                 true
152             )
153         }
154 
getSingleTestTypenull155         internal fun getSingleTestType(activity: MainActivity): String {
156             val sharedPref: SharedPreferences =
157                 PreferenceManager.getDefaultSharedPreferences(activity)
158             return sharedPref.getString(
159                 activity.getString(R.string.settings_single_test_type_key),
160                 "PHOTO"
161             ) ?: "PHOTO"
162         }
163 
getSingleTestFocusnull164         internal fun getSingleTestFocus(activity: MainActivity): String {
165             val sharedPref: SharedPreferences =
166                 PreferenceManager.getDefaultSharedPreferences(activity)
167             return sharedPref.getString(
168                 activity.getString(R.string.settings_single_test_focus_key),
169                 "Auto"
170             ) ?: "Auto"
171         }
172 
getSingleTestImageSizenull173         internal fun getSingleTestImageSize(activity: MainActivity): String {
174             val sharedPref: SharedPreferences =
175                 PreferenceManager.getDefaultSharedPreferences(activity)
176             return sharedPref.getString(
177                 activity.getString(R.string.settings_single_test_imagesize_key),
178                 "Max"
179             ) ?: "Max"
180         }
181 
getSingleTestCameranull182         internal fun getSingleTestCamera(activity: MainActivity): String {
183             val sharedPref: SharedPreferences =
184                 PreferenceManager.getDefaultSharedPreferences(activity)
185             return sharedPref.getString(
186                 activity.getString(R.string.settings_single_test_camera_key),
187                 "0"
188             ) ?: "0"
189         }
190 
getSingleTestApinull191         internal fun getSingleTestApi(activity: MainActivity): String {
192             val sharedPref: SharedPreferences =
193                 PreferenceManager.getDefaultSharedPreferences(activity)
194             return sharedPref.getString(
195                 activity.getString(R.string.settings_single_test_api_key),
196                 "Camera2"
197             ) ?: "Camera2"
198         }
199 
getCameraIdsnull200         internal fun getCameraIds(
201             activity: MainActivity,
202             cameraParams: HashMap<String, CameraParams>
203         ): ArrayList<String> {
204 
205             val cameraIds: ArrayList<String> = ArrayList()
206             val onlyLogical: Boolean = getOnlyLogical(activity)
207 
208             // First we add all the cameras, then we either remove the logical ones or physical ones
209             for (params in cameraParams) cameraIds.add(params.value.id)
210 
211             // Before 28, no physical camera access
212             if (Build.VERSION.SDK_INT < 28) return cameraIds
213 
214             // For logical cameras, we remove all physical camera ids
215             if (onlyLogical) {
216                 for (params in cameraParams) {
217                     for (physicalId in params.value.physicalCameras) cameraIds.remove(physicalId)
218                 }
219 
220                 // For only physical, we check if it is backed by physical cameras, if so, remove it
221                 // as the physical cameras should already be in the list
222             } else {
223                 for (params in cameraParams) {
224                     if (params.value.hasMulti) cameraIds.remove(params.value.id)
225                 }
226             }
227 
228             Collections.sort(cameraIds)
229             return cameraIds
230         }
231 
getLogicalCameraIdsnull232         internal fun getLogicalCameraIds(
233             cameraParams: HashMap<String, CameraParams>
234         ): ArrayList<String> {
235 
236             val cameraIds: ArrayList<String> = ArrayList()
237 
238             // First we add all the cameras, then we either remove the logical ones or physical ones
239             for (params in cameraParams) {
240                 cameraIds.add(params.value.id)
241             }
242             // Before 28, no physical camera access
243             if (Build.VERSION.SDK_INT < 28) return cameraIds
244 
245             // For logical cameras, we remove all physical camera ids
246             for (params in cameraParams) {
247                 for (physicalId in params.value.physicalCameras) {
248                     cameraIds.remove(physicalId)
249                 }
250             }
251 
252             Collections.sort(cameraIds)
253             return cameraIds
254         }
255     }
256 
257     // Order: Camera2, CameraX, Camera1
258     internal class ApiComparator : Comparator<CameraAPI> {
comparenull259         override fun compare(api1: CameraAPI, api2: CameraAPI): Int {
260             if (api1 == api2) return 0
261             if (api1 == CameraAPI.CAMERA2) return -1
262             if (api2 == CameraAPI.CAMERA2) return 1
263             if (api1 == CameraAPI.CAMERAX) return -1
264             if (api2 == CameraAPI.CAMERAX) return 1
265 
266             // This should never happen
267             return -1
268         }
269     }
270 
271     // Order: Max, Min
272     internal class ImageSizeComparator : Comparator<ImageCaptureSize> {
comparenull273         override fun compare(size1: ImageCaptureSize, size2: ImageCaptureSize): Int {
274             if (size1 == size2) return 0
275             if (size1 == ImageCaptureSize.MAX) return -1
276             if (size2 == ImageCaptureSize.MAX) return 1
277 
278             // This should never happen
279             return -1
280         }
281     }
282 
283     // Order: Auto, Continuous
284     internal class FocusModeComparator : Comparator<FocusMode> {
comparenull285         override fun compare(mode1: FocusMode, mode2: FocusMode): Int {
286             if (mode1 == mode2) return 0
287             if (mode1 == FocusMode.AUTO) return -1
288             if (mode2 == FocusMode.AUTO) return 1
289 
290             // This should never happen
291             return -1
292         }
293     }
294 }
295