.github/CONTRIBUTING.md

@@ -1 +0,0 @@
-Contributing guidelines are [hosted here](https://natario1.github.io/CameraView/extra/contributing).

.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: [natario1]
-patreon: # Replace with a single Patreon username
-open_collective: cameraview
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE/bug_report.md

@@ -8,39 +8,26 @@ assignees: ''
 ---
 
 ### Describe the bug
-Please add a clear description of what the bug is, **and** fill the list below.
+A clear and concise description of what the bug is.
+
 - CameraView version: *version number*
-- Camera engine used: *camera1/camera2/both*
 - Reproducible in official demo app: *yes/no*
 - Device / Android version: *Pixel, API 28*
-- I have read the [FAQ page](https://natario1.github.io/CameraView/about/faq): *yes/no*
 
 ### To Reproduce
 Steps to reproduce the behavior, possibly in the demo app:
 1. Go to '...'
-2. Click on '...'
+2. Click on '....'
 3. See error
 
 ### Expected behavior
 A clear and concise description of what you expected to happen.
 
-### XML layout
-Part of the XML layout with the CameraView declaration, so we can read its attributes.
-
-```xml
-<CameraView
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"       
-    ...>
-</CameraView>
-```
-
 ### Screenshots
 If applicable, add screenshots to help explain your problem.
 
 ### Logs
-Use `CameraLogger.setLogLevel(LEVEL_INFO)` to see all logs into LogCat.
+Use `CameraLogger.setLogLevel(LEVEL_VERBOSE)` to see all logs into LogCat.
-
 Use `CameraLogger.registerLogger()` to export to file or crash reporting service.
 
 ### APK

.github/ISSUE_TEMPLATE/question.md

@@ -8,8 +8,5 @@ assignees: ''
 ---
 
 ### How do I?
-Describe your problem here. Please, read the [docs](https://natario1.github.io/CameraView) and [FAQ page](https://natario1.github.io/CameraView/about/faq) first.
+Describe your problem here. Please, read the docs first.
 Questions not strictly related to CameraView should be asked elsewhere.
-
-### Version used
-CameraView exact version.

.github/pull_request_template.md

@@ -1,14 +1,10 @@
 ### Before you go
-Unless this is a simple fix (typos, bugs with obvious solution), please open an issue first so that
+Unless this is a simple fix (typos, bugs with obvious solution), please open an issue first.
-we can discuss the best approach to address the problem. Without a reference issue and discussion, 
+If the edited files were covered by tests, updated tests are required for merging. Please look into the tests folders and make sure you cover new code.
-unfortunately, this PR will likely be ignored.
 
-If the edited files were covered by tests, updated tests are required for merging. 
+- Fixes ... (*issue number*)
-Please look into the tests folders and make sure you cover new code.
-
-- Fixes: ... (*issue number*)
 - Tests: ... (*yes/no*)
 - Docs updated: ... (*yes/no*)
 
 ### Solution
-If applicable, describe briefly how the issue was addressed.
+If applicable, briefly describe how the issue was addressed.

.github/workflows/build.yml

@@ -1,119 +0,0 @@
-# https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions
-# Renaming ? Change the README badge.
-name: Build
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-jobs:
-  ANDROID_BASE_CHECKS:
-    name: Base Checks
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v2
-        with:
-          java-version: 11
-          distribution: temurin
-          cache: gradle
-      - name: Perform base checks
-        run: ./gradlew demo:assembleDebug cameraview:publishToDirectory --stacktrace
-  ANDROID_UNIT_TESTS:
-    name: Unit Tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v2
-        with:
-          java-version: 11
-          distribution: temurin
-          cache: gradle
-      - name: Execute unit tests
-        run: ./gradlew cameraview:runUnitTests --stacktrace
-      - name: Upload unit tests artifact
-        uses: actions/upload-artifact@v1
-        with:
-          name: unit_tests
-          path: ./cameraview/build/coverage_input/unit_tests
-  ANDROID_EMULATOR_TESTS:
-    name: Emulator Tests
-    runs-on: macos-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        # TODO 29 fails due to Mockito issues, probably reproducible locally
-        # 22-28 work (some of them, with SdkExclude restrictions)
-        EMULATOR_API: [22, 23, 24, 25, 26, 27, 28]
-        include:
-          - EMULATOR_API: 28
-            EMULATOR_ARCH: x86_64
-          - EMULATOR_API: 27
-            EMULATOR_ARCH: x86_64
-          - EMULATOR_API: 26
-            EMULATOR_ARCH: x86_64
-          - EMULATOR_API: 25
-            EMULATOR_ARCH: x86
-          - EMULATOR_API: 24
-            EMULATOR_ARCH: x86
-          - EMULATOR_API: 23
-            EMULATOR_ARCH: x86
-          - EMULATOR_API: 22
-            EMULATOR_ARCH: x86
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v2
-        with:
-          java-version: 11
-          distribution: temurin
-          cache: gradle
-      - name: Execute emulator tests
-        timeout-minutes: 30
-        uses: reactivecircus/android-emulator-runner@v2.21.0
-        with:
-          api-level: ${{ matrix.EMULATOR_API }}
-          arch: ${{ matrix.EMULATOR_ARCH }}
-          disable-animations: true
-          profile: Nexus 5X
-          emulator-options: -no-snapshot -no-window -no-boot-anim -camera-back emulated -camera-front emulated -gpu swiftshader_indirect
-          script: ./.github/workflows/emulator_script.sh
-      - name: Upload emulator tests artifact
-        uses: actions/upload-artifact@v1
-        with:
-          name: emulator_tests_${{ matrix.EMULATOR_API }}
-          path: ./cameraview/build/coverage_input/android_tests
-  CODE_COVERAGE:
-    name: Code Coverage Report
-    runs-on: ubuntu-latest
-    needs: [ANDROID_UNIT_TESTS, ANDROID_EMULATOR_TESTS]
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v2
-        with:
-          java-version: 11
-          distribution: temurin
-          cache: gradle
-      - name: Download unit tests artifact
-        uses: actions/download-artifact@v1
-        with:
-          name: unit_tests
-          path: ./cameraview/build/coverage_input/unit_tests
-      - name: Download emulator tests artifact
-        uses: actions/download-artifact@v1
-        with:
-          # 27 is the EMULATOR_API with less SdkExclude annotations, and should have
-          # the best possible coverage.
-          name: emulator_tests_27
-          path: ./cameraview/build/coverage_input/android_tests
-      - name: Create merged coverage report
-        run: ./gradlew cameraview:computeCoverage
-      - name: Upload merged coverage report (GitHub)
-        uses: actions/upload-artifact@v1
-        with:
-          name: report
-          path: ./cameraview/build/coverage_output/xml
-      - name: Upload merged coverage report (Codecov)
-        uses: codecov/codecov-action@v1
-        with:
-          file: ./cameraview/build/coverage_output/xml/*
-          fail_ci_if_error: true

.github/workflows/deploy.yml

@@ -1,23 +0,0 @@
-# https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions
-name: Deploy
-on:
-  release:
-    types: [published]
-jobs:
-  MAVEN_UPLOAD:
-    name: Maven Upload
-    runs-on: ubuntu-latest
-    env:
-      SIGNING_KEY: ${{ secrets.SIGNING_KEY }}
-      SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
-      SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
-      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v2
-        with:
-          java-version: 11
-          distribution: temurin
-          cache: gradle
-      - name: Perform maven upload
-        run: ./gradlew publishToSonatype

.github/workflows/emulator_script.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-# Core
-ADB_TAGS="CameraView:I CameraCallbacks:I CameraOrchestrator:I CameraEngine:I"
-ADB_TAGS="$ADB_TAGS CameraUtils:I WorkerHandler:I"
-# Recorders
-ADB_TAGS="$ADB_TAGS VideoRecorder:I FullVideoRecorder:I SnapshotVideoRecorder:I"
-ADB_TAGS="$ADB_TAGS FullPictureRecorder:I SnapshotPictureRecorder:I DeviceEncoders:I"
-# Video encoders
-ADB_TAGS="$ADB_TAGS MediaEncoderEngine:I MediaEncoder:I AudioMediaEncoder:I VideoMediaEncoder:I TextureMediaEncoder:I"
-# Debugging
-ADB_TAGS="$ADB_TAGS CameraIntegrationTest:I MessageQueue:W MPEG4Writer:I"
-adb logcat -c
-adb logcat $ADB_TAGS *:E -v color &
-./gradlew cameraview:runAndroidTests

.github/workflows/snapshot.yml

@@ -1,25 +0,0 @@
-# https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions
-# Renaming ? Change the README badge.
-name: Snapshot
-on:
-  push:
-    branches:
-      - main
-jobs:
-  SNAPSHOT:
-    name: Publish Snapshot
-    runs-on: ubuntu-latest
-    env:
-      SIGNING_KEY: ${{ secrets.SIGNING_KEY }}
-      SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
-      SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
-      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v2
-        with:
-          java-version: 11
-          distribution: temurin
-          cache: gradle
-      - name: Publish sonatype snapshot
-        run: ./gradlew publishToSonatypeSnapshot

.run/runAndroidTests.run.xml

@@ -1,23 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="runAndroidTests" type="GradleRunConfiguration" factoryName="Gradle">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$/cameraview" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value="runAndroidTests" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
-    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
-    <DebugAllEnabled>false</DebugAllEnabled>
-    <method v="2" />
-  </configuration>
-</component>

.run/runUnitTests.run.xml

@@ -1,23 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="runUnitTests" type="GradleRunConfiguration" factoryName="Gradle">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$/cameraview" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value="runUnitTests" />
-        </list>
-      </option>
-      <option name="vmOptions" value="" />
-    </ExternalSystemSettings>
-    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
-    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
-    <DebugAllEnabled>false</DebugAllEnabled>
-    <method v="2" />
-  </configuration>
-</component>

.travis.yml

@@ -0,0 +1,86 @@
+# https://github.com/andstatus/andstatus/blob/master/.travis.yml
+
+language: android
+
+branches:
+  only:
+    - master
+    - /^v\d+\.\d+\.\d+$/
+
+sudo: false
+
+jdk:
+  - oraclejdk8
+
+env:
+  global:
+    # Where to run androidTests
+    - EMULATOR_API=22 # 24 has some issues, probably some overlayed window
+    - EMULATOR_ABI=armeabi-v7a
+    - EMULATOR_TAG=default
+    - PATH=$ANDROID_HOME:$ANDROID_HOME/emulator:$ANDROID_HOME/platform-tools:$PATH
+
+android:
+  components:
+    - tools
+    - platform-tools
+    - build-tools-28.0.2
+    - android-28
+    - doc-28
+
+install:
+  # Setup
+  - echo $ANDROID_HOME # We assume this is correctly set when setting path
+  - sdkmanager --list || true # Look at the packages
+  - echo yes | sdkmanager "tools" # Ensure tools is updated
+  - echo yes | sdkmanager "emulator" # Ensure emulator is present
+
+  # Install emulator
+  - export EMULATOR="system-images;android-$EMULATOR_API;$EMULATOR_TAG;$EMULATOR_ABI"
+  - echo yes | sdkmanager "platforms;android-$EMULATOR_API" # Install sdk
+  - echo yes | sdkmanager "$EMULATOR" # Install system image
+  - sdkmanager --list || true # Check everything is updated
+
+  # Create adn start emulator
+  - echo no | avdmanager create avd -n test -k "$EMULATOR" -f # Create emulator
+  - which emulator # ensure we are using the right emulator (home/emulator/)
+  - emulator -avd test -no-window -camera-back emulated -camera-front emulated -memory 2048 -writable-system & # Launch
+  - adb wait-for-device # Wait for adb process
+  - adb remount # Mount as writable
+
+before_script:
+  # Wait for emulator
+  - android-wait-for-emulator # Wait for emulator ready to interact
+  - adb shell settings put global window_animation_scale 0 & # Disable animations
+  - adb shell settings put global transition_animation_scale 0 & # Disable animations
+  - adb shell settings put global animator_duration_scale 0 & # Disable animations
+
+  # Unlock and configure logs.
+  # Would be great to use -v color to adb logcat but looks not supported on travis.
+  - sleep 20 # Sleep 20 seconds just in case
+  - adb shell input keyevent 82 & # Dispatch unlock event
+  - adb logcat --help # See if this version supports color
+  - adb logcat -c # Clear logcat
+  - adb logcat Test:V TestRunner:V CameraView:V CameraController:V Camera1:V WorkerHandler:V THREAD_STATE:S *:E &
+  # - export LOGCAT_PID=$! # Save PID of the logcat process. Should kill later with kill $LOGCAT_PID
+
+
+
+script:
+  - ./gradlew clean testDebugUnitTest connectedCheck mergedCoverageReport
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash) -s "*/build/reports/mergedCoverageReport/"
+
+cache:
+  directories:
+    - $HOME/.gradle
+    - $HOME/.m2/repository
+
+deploy:
+  provider: script
+  script: ./gradlew bintrayUpload
+  skip_cleanup: true
+  on:
+    branch: master
+    tags: true

CHANGELOG.md

@@ -0,0 +1,156 @@
+## v1.6.1
+
+This is the last release before v2.
+
+- Fixed: crash when using TextureView in API 28, thanks to [@Keyrillanskiy][Keyrillanskiy] ([#297][297])
+- Fixed: restore Frame Processor callbacks after taking videos, thanks to [@stefanJi][stefanJi] ([#344][344])
+- Enhancement: when horizontal, camera now uses the last available orientation, thanks to [@aartikov][aartikov] ([#290][290])
+- Changed: we now swallow exceptions during autoFocus that were happening unpredictably on some devices, thanks to [@mahdi-ninja][mahdi-ninja] ([#332][332])
+https://github.com/natario1/CameraView/compare/v1.6.0...v1.6.1
+
+## v1.6.0
+
+- Lifecycle support. Use `setLifecycleOwner` instead of calling start, stop and destroy ([#265][265])
+- Enhancement: provide synchronous version of CameraUtils.decodeBitmap thanks to [@athornz][athornz] ([#224][224])
+- Enhancement: prevent possible context leak thanks to [@MatFl][MatFl] ([#245][245])
+- Bug: fix crash when using default VideoCodec thanks to [@Namazed][Namazed] ([#264][264])
+- Enhancement: CameraException.getReason() gives some insight about the error ([#265][265])
+- Enhancement: Common crashes are now being posted to the error callback instead of crashing the app ([#265][265])
+
+https://github.com/natario1/CameraView/compare/v1.5.1...v1.6.0
+
+### v1.5.1
+
+- Bug: byte array length for Frames was incorrect thanks to [@ssakhavi][ssakhavi] ([#205][205])
+- Bug: gestures were crashing in some conditions ([#222][222])
+- Bug: import correctly the ExifInterface library ([#222][222])
+- Updated dependencies thanks to [@caleb-allen][caleb-allen] ([#190][190])
+
+https://github.com/natario1/CameraView/compare/v1.5.0...v1.5.1
+
+## v1.5.0
+
+- New: set encoder for video recordings with `cameraVideoCodec` ([#174][174])
+- New: set max duration for videos with `cameraVideoMaxDuration` ([#172][172])
+- Enhancement: reduced lag with continuous gestures (ev, zoom) ([#170][170])
+- Bug: tap to focus was crashing on some devices ([#167][167])
+- Bug: capturePicture was breaking if followed by another event soon after ([#173][173])
+
+https://github.com/natario1/CameraView/compare/v1.4.2...v1.5.0
+
+### v1.4.2
+
+- Add prefix to XML resources so they don't collide, thanks to [@RocketRider][RocketRider] ([#162][162])
+- Add `videoMaxSize` API and XML attribute, to set max size video in bytes, thanks to [@chaitanyaraghav][chaitanyaraghav] ([#104][104])
+- Improved the preview size selection, thanks to [@YeungKC][YeungKC] ([#133][133])
+- Improved the playSounds attribute, was playing incorrectly, thanks to [@xp-vit][xp-vit] ([#143][143])
+
+https://github.com/natario1/CameraView/compare/v1.4.1...v1.4.2
+
+### v1.4.1
+
+- Fixed a bug that would flip the front camera preview on some devices ([#112][112])
+- Two new `CameraOptions` APIs: `o.getSupportedPictureSizes()` and `o.getSupportedPictureAspectRatios()` ([#101][101])
+- Most controls (video quality, hdr, grid, session type, audio, white balance, flash, facing) now inherit
+  from a base `Control` class ([#105][105]). This let us add new APIs:
+
+  - `CameraView.set(Control)`: sets the control to the given value, e.g. `set(Flash.AUTO)`
+  - `CameraOptions.supports(Control)`: returns true if the control is supported
+  - `CameraOptions.getSupportedControls(Class<? extends Control>)`: returns list of supported controls of a given kind
+
+https://github.com/natario1/CameraView/compare/v1.4.0...v1.4.1
+
+## v1.4.0
+
+- CameraView is now completely thread-safe. All actions are asynchronous. ([#97][97])
+  This has some breaking drawbacks. Specifically, the `get` methods (e.g., `getWhiteBalance`) might
+  not return the correct value while it is being changed. So don't trust them right after you have changed the value.
+  Instead, always check the `CameraOptions` to see if the value you want is supported.
+- Added error handling ([#97][97]) in `CameraListener.onCameraError(CameraException)`.
+  At the moment, all exceptions there are unrecoverable. When the method is called, the camera is showing
+  a black preview. This is a good moment to show an error dialog to the user.
+  You can also try to `start()` again but that is not guaranteed to work.
+- Long requested ability to set the picture output size ([#99][99]). Can be done through
+  `CameraView.setPictureSize()` or through new XML attributes starting with `cameraPictureSize`.
+  Please refer to docs about it.
+- Deprecated `toggleFacing`. It was unreliable and will be removed.
+- Deprecated `getCaptureSize`. Use `getPictureSize` instead.
+- Fixed bugs.
+
+https://github.com/natario1/CameraView/compare/v1.3.2...v1.4.0
+
+### v1.3.2
+
+- Fixed a memory leak thanks to [@andrewmunn][andrewmunn] ([#92][92])
+- Reduced memory usage when using cropOutput thanks to [@RobertoMorelos][RobertoMorelos] ([#93][93])
+- Improved efficiency for Frame processors, recycle buffers and Frames ([#94][94])
+
+https://github.com/natario1/CameraView/compare/v1.3.1...v1.3.2
+
+### v1.3.1
+
+- Fixed a bug that would make setFacing and other APIs freeze the camera ([#86][86])
+- Fixed ConcurrentModificationExceptions during CameraListener callbacks ([#88][88])
+
+https://github.com/natario1/CameraView/compare/v1.3.0...v1.3.1
+
+## v1.3.0
+
+- Ability to inject frame processors to do your own visual tasks (barcodes, facial recognition etc.) ([#82][82])
+- Ability to inject external loggers (e.g. Crashlytics) to listen for internal logging events ([#80][80])
+- Improved CameraUtils.decodeBitmap, you can now pass maxWidth and maxHeight to avoid OOM ([#83][83])
+- Updated dependencies thanks to [@v-gar][v-gar] ([#73][73])
+
+https://github.com/natario1/CameraView/compare/v1.2.3...v1.3.0
+
+[aartikov]: https://github.com/aartikov
+[athornz]: https://github.com/athornz
+[v-gar]: https://github.com/v-gar
+[andrewmunn]: https://github.com/andrewmunn
+[chaitanyaraghav]: https://github.com/chaitanyaraghav
+[YeungKC]: https://github.com/YeungKC
+[RobertoMorelos]: https://github.com/RobertoMorelos
+[RocketRider]: https://github.com/RocketRider
+[xp-vit]: https://github.com/xp-vit
+[caleb-allen]: https://github.com/caleb-allen
+[ssakhavi]: https://github.com/ssakhavi
+[MatFl]: https://github.com/MatFl
+[Namazed]: https://github.com/Namazed
+[Keyrillanskiy]: https://github.com/Keyrillanskiy
+[mahdi-ninja]: https://github.com/mahdi-ninja
+[stefanJi]: https://github.com/stefanJi
+
+[73]: https://github.com/natario1/CameraView/pull/73
+[80]: https://github.com/natario1/CameraView/pull/80
+[82]: https://github.com/natario1/CameraView/pull/82
+[83]: https://github.com/natario1/CameraView/pull/83
+[86]: https://github.com/natario1/CameraView/pull/86
+[88]: https://github.com/natario1/CameraView/pull/88
+[92]: https://github.com/natario1/CameraView/pull/92
+[93]: https://github.com/natario1/CameraView/pull/93
+[94]: https://github.com/natario1/CameraView/pull/94
+[97]: https://github.com/natario1/CameraView/pull/97
+[99]: https://github.com/natario1/CameraView/pull/99
+[101]: https://github.com/natario1/CameraView/pull/101
+[104]: https://github.com/natario1/CameraView/pull/104
+[105]: https://github.com/natario1/CameraView/pull/105
+[112]: https://github.com/natario1/CameraView/pull/112
+[133]: https://github.com/natario1/CameraView/pull/133
+[143]: https://github.com/natario1/CameraView/pull/143
+[162]: https://github.com/natario1/CameraView/pull/162
+[167]: https://github.com/natario1/CameraView/pull/167
+[170]: https://github.com/natario1/CameraView/pull/170
+[172]: https://github.com/natario1/CameraView/pull/172
+[173]: https://github.com/natario1/CameraView/pull/173
+[174]: https://github.com/natario1/CameraView/pull/174
+[190]: https://github.com/natario1/CameraView/pull/190
+[205]: https://github.com/natario1/CameraView/pull/205
+[222]: https://github.com/natario1/CameraView/pull/222
+[224]: https://github.com/natario1/CameraView/pull/224
+[245]: https://github.com/natario1/CameraView/pull/245
+[264]: https://github.com/natario1/CameraView/pull/264
+[265]: https://github.com/natario1/CameraView/pull/265
+[290]: https://github.com/natario1/CameraView/pull/290
+[297]: https://github.com/natario1/CameraView/pull/297
+[332]: https://github.com/natario1/CameraView/pull/332
+[334]: https://github.com/natario1/CameraView/pull/334

LICENSE

@@ -1,7 +1,7 @@
 Copyrights for portions of project CameraView are held by WonderKiln, Inc as
 part of project CameraKit-Android (https://github.com/wonderkiln/CameraKit-Android).
 Their original license is available below, or at
-https://github.com/wonderkiln/CameraKit-Android/blob/main/LICENSE .
+https://github.com/wonderkiln/CameraKit-Android/blob/master/LICENSE .
 All other copyrights for project CameraView are held by Otalia Studios, 2017.
 
 ------------------------------------------------------------------------------

README.md

@@ -1,166 +1,782 @@
-[![Build Status](https://github.com/natario1/CameraView/workflows/Build/badge.svg?event=push)](https://github.com/natario1/CameraView/actions)
+[![Build Status](https://travis-ci.org/natario1/CameraView.svg?branch=master)](https://travis-ci.org/natario1/CameraView)
-[![Code Coverage](https://codecov.io/gh/natario1/CameraView/branch/main/graph/badge.svg)](https://codecov.io/gh/natario1/CameraView)
+[![Code Coverage](https://codecov.io/gh/natario1/CameraView/branch/master/graph/badge.svg)](https://codecov.io/gh/natario1/CameraView)
-[![Release](https://img.shields.io/github/release/natario1/CameraView.svg)](https://github.com/natario1/CameraView/releases)
-[![Issues](https://img.shields.io/github/issues-raw/natario1/CameraView.svg)](https://github.com/natario1/CameraView/issues)
-[![Funding](https://img.shields.io/opencollective/all/CameraView.svg?colorB=r)](https://natario1.github.io/CameraView/extra/donate)
-
-&#10240;  <!-- Hack to add whitespace -->
 
 <p align="center">
-  <img src="docs/static/banner.png" width="100%">
+  <img src="art/icon.png" vspace="10" width="250" height="250">
 </p>
 
-*Post-processing videos or want to reduce video size before uploading? Take a look at our [Transcoder](https://github.com/natario1/Transcoder).*
-
-*Like the project, make profit from it, or simply want to thank back? Please consider [sponsoring me](https://github.com/sponsors/natario1) or [donating](https://natario1.github.io/CameraView/extra/donate)!*
-
-*Need support, consulting, or have any other business-related question? Feel free to <a href="mailto:mat.iavarone@gmail.com">get in touch</a>.*
-
 # CameraView
 
 CameraView is a well documented, high-level library that makes capturing pictures and videos easy,
 addressing most of the common issues and needs, and still leaving you with flexibility where needed.
+See [CHANGELOG](https://github.com/natario1/CameraView/blob/master/CHANGELOG.md).
 
 ```groovy
-api 'com.otaliastudios:cameraview:2.7.2'
+compile 'com.otaliastudios:cameraview:1.6.1'
-```
+```
-
-- Fast & reliable
-- Gestures support [[docs]](https://natario1.github.io/CameraView/docs/gestures)
-- Real-time filters [[docs]](https://natario1.github.io/CameraView/docs/filters)
-- Camera1 or Camera2 powered engine [[docs]](https://natario1.github.io/CameraView/docs/previews)
-- Frame processing support [[docs]](https://natario1.github.io/CameraView/docs/frame-processing)
-- Watermarks & animated overlays [[docs]](https://natario1.github.io/CameraView/docs/watermarks-and-overlays)
-- OpenGL powered preview [[docs]](https://natario1.github.io/CameraView/docs/previews)
-- Take high-quality content with `takePicture` and `takeVideo` [[docs]](https://natario1.github.io/CameraView/docs/capturing-media)
-- Take super-fast snapshots with `takePictureSnapshot` and `takeVideoSnapshot` [[docs]](https://natario1.github.io/CameraView/docs/capturing-media)
-- Smart sizing: create a `CameraView` of any size [[docs]](https://natario1.github.io/CameraView/docs/preview-size)
-- Control HDR, flash, zoom, white balance, exposure, location, grid drawing & more [[docs]](https://natario1.github.io/CameraView/docs/controls)
-- RAW pictures support [[docs]](https://natario1.github.io/CameraView/docs/controls)
-- Lightweight
-- Works down to API level 15
-- Well tested
 
-&#10240;  <!-- Hack to add whitespace -->
+Make sure your project repositories include the `jcenter()`:
 
-<p align="center">
+```groovy
-  <img src="docs/static/screen1.png" width="250" hspace="5"><img src="docs/static/screen2.png" width="250" hspace="5"><img src="docs/static/screen3.png" width="250" hspace="5">
+allprojects {
+  repositories {
+    jcenter()
+  }
+}
+```
+
+
+<p>
+  <img src="art/screen1.jpg" width="250" vspace="20" hspace="5">
+  <img src="art/screen2.jpg" width="250" vspace="20" hspace="5">
+  <img src="art/screen3.jpg" width="250" vspace="20" hspace="5">
 </p>
 
-&#10240;  <!-- Hack to add whitespace -->
+*This was a fork of [CameraKit-Android](https://github.com/gogopop/CameraKit-Android), originally a
+fork of [Google's CameraView](https://github.com/google/cameraview), but has been
+[completely rewritten](https://github.com/natario1/CameraView/graphs/contributors?type=d).
+See below for a [list of what was done](#roadmap) and [licensing info](#contributing-and-licenses).*
 
-## Support 
+### Features
 
-If you like the project, make profit from it, or simply want to thank back, please consider 
+- Seamless image and video capturing
-[sponsoring me](https://github.com/sponsors/natario1) through the GitHub Sponsors program! You can
+- **Gestures** support (tap to focus, pinch to zoom and much more)
-have your company logo here, get private support hours or simply help me push this forward.
+- System permission handling
-If you prefer, you can also [donate](https://natario1.github.io/CameraView/extra/donate) 
+- **Smart sizing** behavior
-to our OpenCollective page.
+  - Preview: Create a `CameraView` of **any size**
+  - Preview: Center inside or center crop behaviors
+  - Output: Handy utilities to set the output size
+  - Output: Automatic cropping to match your `CameraView` preview bounds
+- Built-in **grid drawing**
+- Multiple capture methods
+  - Take high-resolution pictures with `capturePicture`
+  - Take **quick snapshots** as a freeze frame of the preview with `captureSnapshot`
+- Control HDR, flash, zoom, white balance, exposure correction and more
+- **Frame processing** support
+- **Metadata** support for pictures and videos
+  - Automatically detected orientation tags
+  - Plug in **location tags** with `setLocation()` API
+- `CameraUtils` to help with Bitmaps and orientations
+- Error handling
+- Thread safe, **well tested**
+- **Lightweight**, no dependencies, just support `ExifInterface`
+- Works down to API level 15
 
-CameraView is trusted and supported by [ShareChat](https://sharechat.com/), a social media app with over 100 million downloads. 
+# Docs
 
-<p align="center">
+- [Usage](#usage)
-  <img src="docs/static/sharechat.png" width="100%">
+  - [Capturing Images](#capturing-images)
-</p>
+  - [Capturing Video](#capturing-video)
+  - [Other camera events](#other-camera-events)
+- [Gestures](#gestures)  
+- [Sizing Behavior](#sizing-behavior)
+  - [Preview Size](#preview-size)
+  - [Picture Size](#picture-size)
+- [Camera Controls](#camera-controls)
+- [Frame Processing](#frame-processing)
+- [Other APIs](#other-apis)  
+- [Permissions Behavior](#permissions-behavior)
+- [Logging](#logging)
+- [Device-specific issues](#device-specific-issues)
+- [Roadmap](#roadmap)
+
+## Usage
+
+To use the CameraView engine, simply add a `CameraView` to your layout:
+
+```xml
+<com.otaliastudios.cameraview.CameraView
+    android:id="@+id/camera"
+    android:keepScreenOn="true"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content" />
+```
+
+`CameraView` is a component bound to your activity or fragment lifecycle. This means that you must pass the 
+lifecycle owner using `setLifecycleOwner`: 
+
+```java
+@Override
+protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    CameraView camera = findViewById(R.id.camera);
+    camera.setLifecycleOwner(this);
+    // From fragments, use fragment.viewLifecycleOwner instead of this!
+}
+```
+
+For those who are not using the support libraries and the lifecycle implementation, make sure you override `onResume`,
+`onPause` and  `onDestroy` in your component, and call `CameraView.start()`, `stop()`
+and `destroy()`.
+
+```java
+@Override
+protected void onResume() {
+    super.onResume();
+    cameraView.start();
+}
+
+@Override
+protected void onPause() {
+    super.onPause();
+    cameraView.stop();
+}
+
+@Override
+protected void onDestroy() {
+    super.onDestroy();
+    cameraView.destroy();
+}
+```
+
+### Capturing Images
+
+To capture an image just call `CameraView.capturePicture()`. Make sure you setup a `CameraListener`
+to handle the image callback.
+
+```java
+camera.addCameraListener(new CameraListener() {
+    @Override
+    public void onPictureTaken(byte[] picture) {
+        // Create a bitmap or a file...
+        // CameraUtils will read EXIF orientation for you, in a worker thread.
+        CameraUtils.decodeBitmap(picture, ...);
+    }
+});
+
+camera.capturePicture();
+```
+
+You can also use `camera.captureSnapshot()` to capture a preview frame. This is faster, though will
+ensure lower quality output.
+
+### Capturing Video
+
+To capture video just call `CameraView.startCapturingVideo(file)` to start, and
+`CameraView.stopCapturingVideo()` to finish. Make sure you setup a `CameraListener` to handle
+the video callback.
+
+```java
+camera.addCameraListener(new CameraListener() {
+    @Override
+    public void onVideoTaken(File video) {
+        // The File is the same you passed before.
+        // Now it holds a MP4 video.
+    }
+});
+
+// Select output file. Make sure you have write permissions.
+File file = ...;
+camera.startCapturingVideo(file);
+
+// Later... stop recording. This will trigger onVideoTaken().
+camera.stopCapturingVideo();
+
+// You can also use one of the video constraints:
+// videoMaxSize and videoMaxDuration will automatically stop recording when satisfied.
+camera.setVideoMaxSize(100000);
+camera.setVideoMaxDuration(5000);
+camera.startCapturingVideo(file);
+```
+
+### Other camera events
+
+Make sure you can react to different camera events by setting up one or more `CameraListener`
+instances. All these are executed on the UI thread.
+
+```java
+camera.addCameraListener(new CameraListener() {
+
+    /**
+     * Notifies that the camera was opened.
+     * The options object collects all supported options by the current camera.
+     */
+    @Override
+    public void onCameraOpened(CameraOptions options) {}
+
+    /**
+     * Notifies that the camera session was closed.
+     */
+    @Override
+    public void onCameraClosed() {}
+
+    /**
+     * Notifies about an error during the camera setup or configuration.
+     * At the moment, errors that are passed here are unrecoverable. When this is called,
+     * the camera has been released and is presumably showing a black preview.
+     *
+     * This is the right moment to show an error dialog to the user.
+     */
+    @Override
+    public void onCameraError(CameraException error) {}
+
+    /**
+     * Notifies that a picture previously captured with capturePicture()
+     * or captureSnapshot() is ready to be shown or saved.
+     *
+     * If planning to get a bitmap, you can use CameraUtils.decodeBitmap()
+     * to decode the byte array taking care about orientation.
+     */
+    @Override
+    public void onPictureTaken(byte[] picture) {}
 
-Feel free to <a href="mailto:mat.iavarone@gmail.com">contact me</a> for support, consulting or any other business-related question.
+    /**
+     * Notifies that a video capture has just ended. The file parameter is the one that
+     * was passed to startCapturingVideo(File), or a fallback video file.
+     */
+    @Override
+    public void onVideoTaken(File video) {}
     
-Thanks to all our project backers... [[become a backer]](https://opencollective.com/cameraview#backer)
+    /**
+     * Notifies that the device was tilted or the window offset changed.
+     * The orientation passed can be used to align views (e.g. buttons) to the current
+     * camera viewport so they will appear correctly oriented to the user.
+     */
+    @Override
+    public void onOrientationChanged(int orientation) {}
 
-<a href="https://opencollective.com/cameraview#backers" target="_blank"><img src="https://opencollective.com/cameraview/backers.svg?width=890"></a>
+    /**
+     * Notifies that user interacted with the screen and started focus with a gesture,
+     * and the autofocus is trying to focus around that area.
+     * This can be used to draw things on screen.
+     */    
+    @Override
+    public void onFocusStart(PointF point) {}
     
-...and to all our project sponsors! [[become a sponsor]](https://opencollective.com/cameraview#sponsor)
+    /**
+     * Notifies that a gesture focus event just ended, and the camera converged
+     * to a new focus (and possibly exposure and white balance).
+     */
+    @Override
+    public void onFocusEnd(boolean successful, PointF point) {}
     
-<a href="https://opencollective.com/cameraview/sponsor/0/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/0/avatar.svg"></a>
+    /**
-<a href="https://opencollective.com/cameraview/sponsor/1/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/1/avatar.svg"></a>
+     * Noitifies that a finger gesture just caused the camera zoom
-<a href="https://opencollective.com/cameraview/sponsor/2/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/2/avatar.svg"></a>
+     * to be changed. This can be used, for example, to draw a seek bar.
-<a href="https://opencollective.com/cameraview/sponsor/3/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/3/avatar.svg"></a>
+     */
-<a href="https://opencollective.com/cameraview/sponsor/4/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/4/avatar.svg"></a>
+    @Override
-<a href="https://opencollective.com/cameraview/sponsor/5/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/5/avatar.svg"></a>
+    public void onZoomChanged(float newValue, float[] bounds, PointF[] fingers) {}
-<a href="https://opencollective.com/cameraview/sponsor/6/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/6/avatar.svg"></a>
-<a href="https://opencollective.com/cameraview/sponsor/7/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/7/avatar.svg"></a>
-<a href="https://opencollective.com/cameraview/sponsor/8/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/8/avatar.svg"></a>
-<a href="https://opencollective.com/cameraview/sponsor/9/website" target="_blank"><img src="https://opencollective.com/cameraview/sponsor/9/avatar.svg"></a>
     
-## Setup
+    /**
+     * Noitifies that a finger gesture just caused the camera exposure correction
+     * to be changed. This can be used, for example, to draw a seek bar.
+     */
+    @Override 
+    public void onExposureCorrectionChanged(float newValue, float[] bounds, PointF[] fingers) {}
+
+});
+```
+
+## Gestures
+
+`CameraView` listen to lots of different gestures inside its bounds. You have the chance to map
+these gestures to particular actions or camera controls, using `mapGesture()`.
+This lets you emulate typical behaviors in a single line:
+
+```java
+cameraView.mapGesture(Gesture.PINCH, GestureAction.ZOOM); // Pinch to zoom!
+cameraView.mapGesture(Gesture.TAP, GestureAction.FOCUS_WITH_MARKER); // Tap to focus!
+cameraView.mapGesture(Gesture.LONG_TAP, GestureAction.CAPTURE); // Long tap to shoot!
+```
+
+Simple as that. More gestures are coming. There are two things to be noted:
+
+- Not every mapping is valid. For example, you can't control zoom with long taps, or start focusing by pinching.
+- Some actions might not be supported by the sensor. Check out `CameraOptions` to know what's legit and what's not.
+
+|Gesture (XML)|Description|Can be mapped to|
+|-------------|-----------|----------------|
+|`PINCH` (`cameraGesturePinch`)|Pinch gesture, typically assigned to the zoom control.|`zoom` `exposureCorrection` `none`|
+|`TAP` (`cameraGestureTap`)|Single tap gesture, typically assigned to the focus control.|`focus` `focusWithMarker` `capture` `none`|
+|`LONG_TAP` (`cameraGestureLongTap`)|Long tap gesture.|`focus` `focusWithMarker` `capture` `none`|
+|`SCROLL_HORIZONTAL` (`cameraGestureScrollHorizontal`)|Horizontal movement gesture.|`zoom` `exposureCorrection` `none`|
+|`SCROLL_VERTICAL` (`cameraGestureScrollVertical`)|Vertical movement gesture.|`zoom` `exposureCorrection` `none`|
+
+
+## Sizing Behavior
+
+### Preview Size
+
+`CameraView` has a smart measuring behavior that will let you do what you want with a few flags.
+Measuring is controlled simply by `layout_width` and `layout_height` attributes, with this meaning:
+
+- `WRAP_CONTENT` : try to stretch this dimension to respect the preview aspect ratio.
+- `MATCH_PARENT` : fill this dimension, even if this means ignoring the aspect ratio.
+- Fixed values (e.g. `500dp`) : respect this dimension.
+
+You can have previews of all sizes, not just the supported presets. Whaterever you do,
+the preview will never be distorted.
+
+#### Center Inside
+
+You can emulate a **center inside** behavior (like the `ImageView` scaletype) by setting
+both dimensions to `wrap_content`. The camera will get the biggest possible size that fits
+into your bounds, just like what happens with image views.
 
-Please read the [official website](https://natario1.github.io/CameraView) for setup instructions and documentation.
-You might also be interested in our [changelog](https://natario1.github.io/CameraView/about/changelog)
-or in the [v1 migration guide](https://natario1.github.io/CameraView/extra/v1-migration-guide). 
-Using CameraView is extremely simple:
 
 ```xml
 <com.otaliastudios.cameraview.CameraView
-    xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="wrap_content"
+    android:layout_height="wrap_content" />
+```
+
+This means that the whole preview is visible, and the image output matches what was visible
+during the capture.
+
+#### Center Crop
+
+You can emulate a **center crop** behavior by setting both dimensions to fixed values or to
+`MATCH_PARENT`. The camera view will fill the rect. If your dimensions don't match the aspect ratio
+of the internal preview surface, the surface will be cropped to fill the view,
+just like `android:scaleType="centerCrop"` on an `ImageView`.
+
+```xml
+<com.otaliastudios.cameraview.CameraView
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" />
+```
+
+This means that part of the preview is hidden, and the image output will contain parts of the scene
+that were not visible during the capture. If this is a problem, see [cameraCropOutput](#cameracropoutput).
+
+### Picture Size
+
+On top of this, you can control the actual size of the output picture, among the list of available sizes.
+It is the size of the final JPEG picture. This can be achieved directly through XML, or
+using the `SizeSelector` class:
+
+```java
+cameraView.setPictureSize(new SizeSelector() {
+    @Override
+    public List<Size> select(List<Size> source) {
+        // Receives a list of available sizes.
+        // Must return a list of acceptable sizes.
+    }
+});
+```
+
+In practice, this is way easier using XML attributes or leveraging the `SizeSelectors` utilities:
+
+|Constraint|XML attr|SizeSelector|
+|----------|--------|------------|
+|min. width|`app:cameraPictureSizeMinWidth="100"`|`SizeSelectors.minWidth(100)`|
+|min. height|`app:cameraPictureSizeMinHeight="100"`|`SizeSelectors.minHeight(100)`|
+|max. width|`app:cameraPictureSizeMaxWidth="3000"`|`SizeSelectors.maxWidth(3000)`|
+|max. height|`app:cameraPictureSizeMaxHeight="3000"`|`SizeSelectors.maxHeight(3000)`|
+|min. area|`app:cameraPictureSizeMinArea="1000000"`|`SizeSelectors.minArea(1000000)`|
+|max. area|`app:cameraPictureSizeMaxArea="5000000"`|`SizeSelectors.maxArea(5000000)`|
+|aspect ratio|`app:cameraPictureSizeAspectRatio="1:1"`|`SizeSelectors.aspectRatio(AspectRatio.of(1,1), 0)`|
+|smallest|`app:cameraPictureSizeSmallest="true"`|`SizeSelectors.smallest()`|
+|biggest (**default**)|`app:cameraPictureSizeBiggest="true"`|`SizeSelectors.biggest()`|
+
+If you declare more than one XML constraint, the resulting selector will try to match **all** the
+constraints. Be careful - it is very likely that applying lots of constraints will give
+empty results.
+
+#### SizeSelectors utilities
+
+For more versatility, or to address selection issues with multiple constraints,
+we encourage you to use `SizeSelectors` utilities, that will let you merge different selectors.
+
+This selector will try to find square sizes bigger than 1000x2000. If none is found, it falls back
+to just square sizes:
+
+```java
+SizeSelector width = SizeSelectors.minWidth(1000);
+SizeSelector height = SizeSelectors.minHeight(2000);
+SizeSelector dimensions = SizeSelectors.and(width, height); // Matches sizes bigger than 1000x2000.
+SizeSelector ratio = SizeSelectors.aspectRatio(AspectRatio.of(1, 1), 0); // Matches 1:1 sizes.
+
+SizeSelector result = SizeSelectors.or(
+    SizeSelectors.and(ratio, dimensions), // Try to match both constraints
+    ratio, // If none is found, at least try to match the aspect ratio
+    SizeSelectors.biggest() // If none is found, take the biggest
+);
+camera.setPictureSize(result);
+```
+
+## Camera controls
+
+Most camera parameters can be controlled through XML attributes or linked methods.
+
+```xml
+<com.otaliastudios.cameraview.CameraView
+    android:id="@+id/camera"
+    android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    app:cameraPictureSizeMinWidth="@integer/picture_min_width"
+    android:keepScreenOn="true"
-    app:cameraPictureSizeMinHeight="@integer/picture_min_height"
+    app:cameraFacing="back"
-    app:cameraPictureSizeMaxWidth="@integer/picture_max_width"
+    app:cameraFlash="off"
-    app:cameraPictureSizeMaxHeight="@integer/picture_max_height"
+    app:cameraGrid="off"
-    app:cameraPictureSizeMinArea="@integer/picture_min_area"
+    app:cameraSessionType="picture"
-    app:cameraPictureSizeMaxArea="@integer/picture_max_area"
+    app:cameraCropOutput="false"  
-    app:cameraPictureSizeSmallest="false|true"
+    app:cameraJpegQuality="100"
-    app:cameraPictureSizeBiggest="false|true"
+    app:cameraVideoQuality="max480p"
-    app:cameraPictureSizeAspectRatio="@string/video_ratio"
+    app:cameraVideoCodec="deviceDefault"
-    app:cameraVideoSizeMinWidth="@integer/video_min_width"
+    app:cameraWhiteBalance="auto"
-    app:cameraVideoSizeMinHeight="@integer/video_min_height"
+    app:cameraHdr="off"
-    app:cameraVideoSizeMaxWidth="@integer/video_max_width"
+    app:cameraAudio="on"
-    app:cameraVideoSizeMaxHeight="@integer/video_max_height"
+    app:cameraPlaySounds="true"
-    app:cameraVideoSizeMinArea="@integer/video_min_area"
+    app:cameraVideoMaxSize="0"
-    app:cameraVideoSizeMaxArea="@integer/video_max_area"
+    app:cameraVideoMaxDuration="0"/>
-    app:cameraVideoSizeSmallest="false|true"
+```
-    app:cameraVideoSizeBiggest="false|true"
+
-    app:cameraVideoSizeAspectRatio="@string/video_ratio"
+|XML Attribute|Method|Values|Default Value|
-    app:cameraSnapshotMaxWidth="@integer/snapshot_max_width"
+|-------------|------|------|-------------|
-    app:cameraSnapshotMaxHeight="@integer/snapshot_max_height"
+|[`cameraSessionType`](#camerasessiontype)|`setSessionType()`|`picture` `video`|`picture`|
-    app:cameraFrameProcessingMaxWidth="@integer/processing_max_width"
+|[`cameraFacing`](#camerafacing)|`setFacing()`|`back` `front`|`back`|
-    app:cameraFrameProcessingMaxHeight="@integer/processing_max_height"
+|[`cameraFlash`](#cameraflash)|`setFlash()`|`off` `on` `auto` `torch`|`off`|
-    app:cameraFrameProcessingFormat="@integer/processing_format"
+|[`cameraGrid`](#cameragrid)|`setGrid()`|`off` `draw3x3` `draw4x4` `drawPhi`|`off`|
-    app:cameraFrameProcessingPoolSize="@integer/processing_pool_size"
+|[`cameraCropOutput`](#cameracropoutput)|`setCropOutput()`|`true` `false`|`false`|
-    app:cameraFrameProcessingExecutors="@integer/processing_executors"
+|[`cameraJpegQuality`](#camerajpegquality)|`setJpegQuality()`|`0 < n <= 100`|`100`|
-    app:cameraVideoBitRate="@integer/video_bit_rate"
+|[`cameraVideoQuality`](#cameravideoquality)|`setVideoQuality()`|`lowest` `highest` `maxQvga` `max480p` `max720p` `max1080p` `max2160p`|`max480p`|
-    app:cameraAudioBitRate="@integer/audio_bit_rate"
+|[`cameraVideoCodec`](#cameravideocodec)|`setVideoCodec()`|`deviceDefault` `h263` `h264`|`deviceDefault`|
-    app:cameraGestureTap="none|autoFocus|takePicture"
+|[`cameraWhiteBalance`](#camerawhitebalance)|`setWhiteBalance()`|`auto` `incandescent` `fluorescent` `daylight` `cloudy`|`auto`|
-    app:cameraGestureLongTap="none|autoFocus|takePicture"
+|[`cameraHdr`](#camerahdr)|`setHdr()`|`off` `on`|`off`|
-    app:cameraGesturePinch="none|zoom|exposureCorrection|filterControl1|filterControl2"
+|[`cameraAudio`](#cameraaudio)|`setAudio()`|`off` `on`|`on`|
-    app:cameraGestureScrollHorizontal="none|zoom|exposureCorrection|filterControl1|filterControl2"
+|[`cameraPlaySounds`](#cameraplaysounds)|`setPlaySounds()`|`true` `false`|`true`|
-    app:cameraGestureScrollVertical="none|zoom|exposureCorrection|filterControl1|filterControl2"
+|[`cameraVideoMaxSize`](#cameravideomaxsize)|`setVideoMaxSize()`|number|`0`|
-    app:cameraEngine="camera1|camera2"
+|[`cameraVideoMaxDuration`](#cameravideomaxduration)|`setVideoMaxDuration()`|number|`0`|
-    app:cameraPreview="glSurface|surface|texture"
+
-    app:cameraPreviewFrameRate="@integer/preview_frame_rate"
+#### cameraSessionType
-    app:cameraPreviewFrameRateExact="false|true"
+
-    app:cameraFacing="back|front"
+What to capture - either picture or video. This has a couple of consequences:
-    app:cameraHdr="on|off"
+
-    app:cameraFlash="on|auto|torch|off"
+- Sizing: picture and preview size are chosen among the available picture or video sizes,
-    app:cameraWhiteBalance="auto|cloudy|daylight|fluorescent|incandescent"
+  depending on the flag. The picture size is chosen according to the given [size selector](#picture-size).
-    app:cameraMode="picture|video"
+  When `video`, in addition, we try to match the `videoQuality` aspect ratio.
-    app:cameraAudio="on|off|mono|stereo"
+- Picture capturing: due to sizing behavior, capturing pictures in `video` mode might lead to
-    app:cameraGrid="draw3x3|draw4x4|drawPhi|off"
+  inconsistent results. In this case it is encouraged to use `captureSnapshot` instead, which will
-    app:cameraGridColor="@color/grid_color"
+  capture preview frames. This is fast and thus works well with slower camera sensors.
-    app:cameraPlaySounds="true|false"
+- Picture capturing: while recording a video, image capturing might work, but it is not guaranteed
-    app:cameraVideoMaxSize="@integer/video_max_size"
+  (it's device dependent)
-    app:cameraVideoMaxDuration="@integer/video_max_duration"
+- Permission behavior: when requesting a `video` session, the record audio permission will be requested.
-    app:cameraVideoCodec="deviceDefault|h264|h263"
+  If this is needed, the audio permission should be added to your manifest or the app will crash.
-    app:cameraAutoFocusResetDelay="@integer/autofocus_delay"
+
-    app:cameraAutoFocusMarker="@string/cameraview_default_autofocus_marker"
+```java
-    app:cameraUseDeviceOrientation="true|false"
+cameraView.setSessionType(SessionType.PICTURE);
-    app:cameraFilter="@string/real_time_filter"
+cameraView.setSessionType(SessionType.VIDEO);
-    app:cameraPictureMetering="true|false"
+```
-    app:cameraPictureSnapshotMetering="false|true"
+
-    app:cameraPictureFormat="jpeg|dng"
+#### cameraFacing
-    app:cameraRequestPermissions="true|false"
+
-    app:cameraExperimental="false|true">
+Which camera to use, either back facing or front facing.
-    
+
-    <!-- Watermark! -->
+```java
-    <ImageView
+cameraView.setFacing(Facing.BACK);
-        android:layout_width="wrap_content"
+cameraView.setFacing(Facing.FRONT);
-        android:layout_height="wrap_content"
+```
-        android:layout_gravity="bottom|end"
+
-        android:src="@drawable/watermark"
+#### cameraFlash
-        app:layout_drawOnPreview="true|false"
+
-        app:layout_drawOnPictureSnapshot="true|false"
+Flash mode, either off, on, auto or *torch*.
-        app:layout_drawOnVideoSnapshot="true|false"/>
+
-        
+```java
-</com.otaliastudios.cameraview.CameraView>
+cameraView.setFlash(Flash.OFF);
+cameraView.setFlash(Flash.ON);
+cameraView.setFlash(Flash.AUTO);
+cameraView.setFlash(Flash.TORCH);
+```
+
+#### cameraGrid
+
+Lets you draw grids over the camera preview. Supported values are `off`, `draw3x3` and `draw4x4`
+for regular grids, and `drawPhi` for a grid based on the golden ratio constant, often used in photography.
+
+```java
+cameraView.setGrid(Grid.OFF);
+cameraView.setGrid(Grid.DRAW_3X3);
+cameraView.setGrid(Grid.DRAW_4X4);
+cameraView.setGrid(Grid.DRAW_PHI);
+```
+
+#### cameraCropOutput
+
+Whether the output picture should be cropped to fit the aspect ratio of the preview surface.
+This can guarantee consistency between what the user sees and the final output, if you fixed
+the camera view dimensions. This does not support videos.
+
+#### cameraJpegQuality
+
+Sets the JPEG quality of pictures.
+
+```java
+cameraView.setJpegQuality(100);
+cameraView.setJpegQuality(50);
+```
+
+#### cameraVideoQuality
+
+Sets the desired video quality.
+
+```java
+cameraView.setVideoQuality(VideoQuality.LOWEST);
+cameraView.setVideoQuality(VideoQuality.HIGHEST);
+cameraView.setVideoQuality(VideoQuality.MAX_QVGA);
+cameraView.setVideoQuality(VideoQuality.MAX_480P);
+cameraView.setVideoQuality(VideoQuality.MAX_720P);
+cameraView.setVideoQuality(VideoQuality.MAX_1080P);
+cameraView.setVideoQuality(VideoQuality.MAX_2160P);
+```
+
+#### cameraVideoCodec
+
+Sets the encoder for video recordings.
+
+```java
+cameraView.setVideoCodec(VideoCodec.DEVICE_DEFAULT);
+cameraView.setVideoCodec(VideoCodec.H_263);
+cameraView.setVideoCodec(VideoCodec.H_264);
+```
+
+#### cameraWhiteBalance
+
+Sets the desired white balance for the current session.
+
+```java
+cameraView.setWhiteBalance(WhiteBalance.AUTO);
+cameraView.setWhiteBalance(WhiteBalance.INCANDESCENT);
+cameraView.setWhiteBalance(WhiteBalance.FLUORESCENT);
+cameraView.setWhiteBalance(WhiteBalance.DAYLIGHT);
+cameraView.setWhiteBalance(WhiteBalance.CLOUDY);
+```
+
+#### cameraHdr
+
+Turns on or off HDR captures.
+
+```java
+cameraView.setHdr(Hdr.OFF);
+cameraView.setHdr(Hdr.ON);
+```
+
+#### cameraAudio
+
+Turns on or off audio stream while recording videos.
+
+```java
+cameraView.setAudio(Audio.OFF);
+cameraView.setAudio(Audio.ON);
+```
+
+#### cameraPlaySounds
+
+Controls whether we should play platform-provided sounds during certain events
+(shutter click, focus completed). Please note that:
+
+- on API < 16, this flag is always set to `false`
+- the Camera1 engine will always play shutter sounds regardless of this flag
+
+```java
+cameraView.setPlaySounds(true);
+cameraView.setPlaySounds(false);
+```
+
+#### cameraVideoMaxSize
+
+Defines the maximum size in bytes for recorded video files.
+Once this size is reached, the recording will automatically stop.
+Defaults to unlimited size. Use 0 or negatives to disable.
+
+```java
+cameraView.setVideoMaxSize(100000);
+cameraView.setVideoMaxSize(0); // Disable
+```
+
+#### cameraVideoMaxDuration
+
+Defines the maximum duration in milliseconds for video recordings.
+Once this duration is reached, the recording will automatically stop.
+Defaults to unlimited duration. Use 0 or negatives to disable.
+
+```java
+cameraView.setVideoMaxDuration(100000);
+cameraView.setVideoMaxDuration(0); // Disable
+```
+
+## Frame Processing
+
+We support frame processors that will receive data from the camera preview stream:
+
+```java
+cameraView.addFrameProcessor(new FrameProcessor() {
+    @Override
+    @WorkerThread
+    public void process(Frame frame) {
+        byte[] data = frame.getData();
+        int rotation = frame.getRotation();
+        long time = frame.getTime();
+        Size size = frame.getSize();
+        int format = frame.getFormat();
+        // Process...
+    }
+}
 ```
+
+For your convenience, the `FrameProcessor` method is run in a background thread so you can do your job
+in a synchronous fashion. Once the process method returns, internally we will re-use the `Frame` instance and
+apply new data to it. So:
+
+- you can do your job synchronously in the `process()` method
+- if you must hold the `Frame` instance longer, use `frame = frame.freeze()` to get a frozen instance
+  that will not be affected
+
+|Frame API|Type|Description|
+|---------|----|-----------|
+|`frame.getData()`|`byte[]`|The current preview frame, in its original orientation.|
+|`frame.getTime()`|`long`|The preview timestamp, in `System.currentTimeMillis()` reference.|
+|`frame.getRotation()`|`int`|The rotation that should be applied to the byte array in order to see what the user sees.|
+|`frame.getSize()`|`Size`|The frame size, before any rotation is applied, to access data.|
+|`frame.getFormat()`|`int`|The frame `ImageFormat`. This will always be `ImageFormat.NV21` for now.|
+|`frame.freeze()`|`Frame`|Clones this frame and makes it immutable. Can be expensive because requires copying the byte array.|
+|`frame.release()`|`-`|Disposes the content of this frame. Should be used on frozen frames to release memory.|
+
+## Other APIs
+
+Other APIs not mentioned above are provided, and are well documented and commented in code.
+
+|Method|Description|
+|------|-----------|
+|`isStarted()`|Returns true if `start()` was called succesfully. This does not mean that camera is open or showing preview.|
+|`mapGesture(Gesture, GestureAction)`|Maps a certain gesture to a certain action. No-op if the action is not supported.|
+|`getGestureAction(Gesture)`|Returns the action currently mapped to the given gesture.|
+|`clearGesture(Gesture)`|Clears any action mapped to the given gesture.|
+|`getCameraOptions()`|If camera was started, returns non-null object with information about what is supported.|
+|`getExtraProperties()`|If camera was started, returns non-null object with extra information about the camera sensor. Not very useful at the moment.|
+|`setZoom(float)`, `getZoom()`|Sets a zoom value, where 0 means camera zoomed out and 1 means zoomed in. No-op if zoom is not supported, or camera not started.|
+|`setExposureCorrection(float)`, `getExposureCorrection()`|Sets exposure compensation EV value, in camera stops. No-op if this is not supported. Should be between the bounds returned by CameraOptions.|
+|`toggleFacing()`|Toggles the facing value between `Facing.FRONT` and `Facing.BACK`.|
+|`setLocation(Location)`|Sets location data to be appended to picture/video metadata.|
+|`setLocation(double, double)`|Sets latitude and longitude to be appended to picture/video metadata.|
+|`getLocation()`|Retrieves location data previously applied with setLocation().|
+|`startAutoFocus(float, float)`|Starts an autofocus process at the given coordinates, with respect to the view dimensions.|
+|`getPreviewSize()`|Returns the size of the preview surface. If CameraView was not constrained in its layout phase (e.g. it was `wrap_content`), this will return the same aspect ratio of CameraView.|
+|`getSnapshotSize()`|Returns `getPreviewSize()`, since a snapshot is a preview frame.|
+|`getPictureSize()`|Returns the size of the output picture. The aspect ratio is consistent with `getPreviewSize()`.|
+
+Take also a look at public methods in `CameraUtils`, `CameraOptions`, `ExtraProperties`.
+
+## Permissions behavior
+
+`CameraView` needs two permissions:
+
+- `android.permission.CAMERA` : required for capturing pictures and videos
+- `android.permission.RECORD_AUDIO` : required for capturing videos with `Audio.ON` (the default)
+
+### Declaration
+
+The library manifest file declares the `android.permission.CAMERA` permission, but not the audio one.
+This means that:
+
+- If you wish to record videos with `Audio.ON` (the default), you should also add
+  `android.permission.RECORD_AUDIO` to required permissions
+
+```xml
+<uses-permission android:name="android.permission.RECORD_AUDIO"/>
+```
+
+- If you want your app to be installed only on devices that have a camera, you should add:
+
+```xml
+<uses-feature
+    android:name="android.hardware.camera"
+    android:required="true"/>
+```
+
+If you don't request this feature, you can use `CameraUtils.hasCameras()` to detect if current
+device has cameras, and then start the camera view.
+
+### Handling
+
+On Marshmallow+, the user must explicitly approve our permissions. You can
+
+- handle permissions yourself and then call `cameraView.start()` once they are acquired
+- or call `cameraView.start()` anyway: `CameraView` will present a permission request to the user based on
+  whether they are needed or not with the current configuration.
+
+In the second case, you should restart the camera if you have a successful response from `onRequestPermissionResults()`.
+
+## Logging
+
+`CameraView` will log a lot of interesting events related to the camera lifecycle. These are important
+to identify bugs. The default logger will simply use Android `Log` methods posting to logcat.
+
+You can attach and detach external loggers using `CameraLogger.registerLogger()`:
+
+```java
+CameraLogger.registerLogger(new Logger() {
+    @Override
+    public void log(@LogLevel int level, String tag, String message, @Nullable Throwable throwable) {
+        // For example...
+        Crashlytics.log(message);
+    }
+});
+```
+
+Make sure you enable the logger using `CameraLogger.setLogLevel(@LogLevel int)`. The default will only
+log error events.
+
+## Device-specific issues
+
+There are a couple of known issues if you are working with certain devices. The emulator is one of
+the most tricky in this sense.
+
+- Devices, or activities, with hardware acceleration turned off: this can be the case with emulators.
+  In this case we will use SurfaceView as our surface provider. That is intrinsically flawed and can't
+  deal with all we want to do here (runtime layout changes, scaling, etc.). So, nothing to do in this case.
+- Devices with no support for MediaRecorder: the emulator does not support it, officially. This means
+  that video/audio recording is flawed. Again, not our fault.
+
+## Roadmap
+
+This is what was done since the library was forked. I have kept the original structure, but practically
+all the code was changed.
+
+- *a huge number of serious bugs fixed*
+- *decent orientation support for both pictures and videos*
+- *less dependencies*
+- *EXIF support*
+- *real tap-to-focus support*
+- *pinch-to-zoom support*
+- *simpler APIs, docs and heavily commented code*
+- *new `captureSnapshot` API*
+- *new `setLocation` and `setWhiteBalance` APIs*
+- *new `setGrid` APIs, to draw 3x3, 4x4 or golden ratio grids*
+- *option to pass a `File` when recording a video*
+- *other minor API additions*
+- *replacing Method and Permissions stuff with simpler `sessionType`* 
+- *smart measuring and sizing behavior, replacing bugged `adjustViewBounds`*
+- *measure `CameraView` as center crop or center inside*
+- *add multiple `CameraListener`s for events*
+- *gesture framework support, map gestures to camera controls*
+- *pinch gesture support*
+- *tap & long tap gesture support*
+- *scroll gestures support*
+- *MediaActionSound support*
+- *Hdr controls*
+- *zoom and exposure correction controls*
+- *Tests!*
+- *`CameraLogger` APIs for logging and bug reports*
+- *Better threading, start() in worker thread and callbacks in UI*
+- *Frame processor support*
+- *inject external loggers*
+- *error handling*
+- *capture size selectors*
+
+These are still things that need to be done, off the top of my head:
+
+- [ ] `Camera2` integration
+- [ ] animate grid lines similar to stock camera app
+- [ ] add onRequestPermissionResults for easy permission callback
+- [ ] decent code coverage
+
+# Contributing and licenses
+
+The original project which served as a starting point for this library,
+[CameraKit-Android](https://github.com/wonderkiln/CameraKit-Android), is licensed under the
+[MIT](https://github.com/wonderkiln/CameraKit-Android/blob/master/LICENSE) license.
+Additional work is now licensed under the [MIT](https://github.com/natario1/CameraView/blob/master/LICENSE)
+license as well.
+
+You are welcome to contribute with suggestions or pull requests, this is under active development.
+To contact me, <a href="mailto:mat.iavarone@gmail.com">send an email.</a>

build.gradle

@@ -0,0 +1,35 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        jcenter()
+        google()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:3.2.0-rc03'
+        // https://inthecheesefactory.com/blog/how-to-upload-library-to-jcenter-maven-central-as-dependency/en
+        // https://www.theguardian.com/technology/developer-blog/2016/dec/06/how-to-publish-an-android-library-a-mysterious-conversation
+        classpath 'com.github.dcendents:android-maven-gradle-plugin:1.5'
+        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.0'
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+        google()
+    }
+}
+
+ext {
+    compileSdkVersion = 28
+    supportLibVersion = '28.0.0-rc02'
+    lifecycleVersion = '1.1.1'
+    minSdkVersion = 15
+    targetSdkVersion = 28
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

build.gradle.kts

@@ -1,30 +0,0 @@
-
-buildscript {
-
-    extra["minSdkVersion"] = 15
-    extra["compileSdkVersion"] = 31
-    extra["targetSdkVersion"] = 31
-
-    repositories {
-        google()
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath("com.android.tools.build:gradle:7.0.3")
-        classpath("io.deepmedia.tools:publisher:0.6.0")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.31")
-
-    }
-}
-
-allprojects {
-    repositories {
-        google()
-        mavenCentral()
-    }
-}
-
-tasks.register("clean", Delete::class) {
-    delete(buildDir)
-}

cameraview/build.gradle

@@ -0,0 +1,217 @@
+apply plugin: 'com.android.library'
+apply plugin: 'com.github.dcendents.android-maven'
+apply plugin: 'com.jfrog.bintray'
+
+// Required by bintray
+version = '1.6.1'
+group = 'com.otaliastudios'
+
+//region android dependencies
+
+android {
+    compileSdkVersion rootProject.ext.compileSdkVersion
+    // buildToolsVersion rootProject.ext.buildToolsVersion
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode 1
+        versionName project.version
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        debug {
+            testCoverageEnabled true
+        }
+
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    sourceSets {
+        main.java.srcDirs += 'src/main/options'
+        main.java.srcDirs += 'src/main/views'
+        main.java.srcDirs += 'src/main/utils'
+    }
+}
+
+dependencies {
+    testImplementation 'junit:junit:4.12'
+    testImplementation 'org.mockito:mockito-core:1.10.19'
+
+    androidTestImplementation 'com.android.support.test:runner:1.0.2'
+    androidTestImplementation 'com.android.support.test:rules:1.0.2'
+    androidTestImplementation 'com.google.dexmaker:dexmaker:1.2'
+    androidTestImplementation 'com.google.dexmaker:dexmaker-mockito:1.2'
+    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
+
+    api "com.android.support:exifinterface:$supportLibVersion"
+    api "android.arch.lifecycle:common:$lifecycleVersion"
+    implementation "com.android.support:support-annotations:$supportLibVersion"
+}
+
+//endregion
+
+//region bintray
+
+install {
+    repositories.mavenInstaller {
+        pom.project {
+            name 'CameraView'
+            description 'A well documented, high-level Android interface that makes capturing pictures ' +
+                    'and videos easy, addressing most of the common issues and needs.'
+            url 'https://github.com/natario1/CameraView'
+
+            packaging 'aar'
+            groupId project.group
+            artifactId 'cameraview'
+            version project.version
+
+            licenses {
+                license {
+                    name 'The Apache Software License, Version 2.0'
+                    url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                }
+            }
+            scm {
+                connection 'https://github.com/natario1/CameraView.git'
+                developerConnection 'https://github.com/natario1/CameraView.git'
+                url 'https://github.com/natario1/CameraView'
+
+            }
+            developers {
+                developer {
+                    id = 'natario'
+                    name 'Natario'
+                }
+            }
+        }
+    }
+}
+
+def bintrayUser
+def bintrayKey
+def travis = System.getenv("TRAVIS")
+if (travis) {
+    bintrayUser = System.getenv("BINTRAY_USER")
+    bintrayKey = System.getenv("BINTRAY_KEY")
+} else {
+    Properties props = new Properties()
+    props.load(project.rootProject.file('local.properties').newDataInputStream())
+    bintrayUser = props.getProperty('bintray.user')
+    bintrayKey = props.get('bintray.key')
+}
+
+bintray {
+    // https://github.com/bintray/gradle-bintray-plugin
+    user = bintrayUser
+    key = bintrayKey
+    configurations = ['archives']
+    pkg {
+        repo = 'android'
+        name = 'CameraView'
+        licenses = ['Apache-2.0']
+        vcsUrl = 'https://github.com/natario1/CameraView.git'
+        publish = true
+        override = true
+        version {
+            name = project.version
+            desc = 'CameraView v. '+project.version
+            released = new Date()
+            vcsTag = 'v'+project.version
+        }
+    }
+}
+
+//endregion
+
+//region javadoc and sources
+
+// From official sample https://github.com/bintray/bintray-examples/blob/master/gradle-aar-example/build.gradle
+task sourcesJar(type: Jar) {
+    classifier = 'sources'
+    from android.sourceSets.main.java.sourceFiles
+}
+
+task javadoc(type: Javadoc) {
+    source = android.sourceSets.main.java.srcDirs
+    classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
+    classpath += project.files("${android.sdkDirectory}/platforms/${android.compileSdkVersion}/android.jar")
+    project.android.libraryVariants.all { variant ->
+        if (variant.name == 'release') {
+            classpath += files(variant.javaCompile.classpath)
+        }
+    }
+    exclude '**/BuildConfig.java'
+    exclude '**/R.java'
+    exclude '**/internal/**'
+}
+
+task javadocJar(type: Jar, dependsOn: javadoc) {
+    classifier = 'javadoc'
+    from javadoc.destinationDir
+}
+
+artifacts {
+    archives javadocJar
+    archives sourcesJar
+}
+
+//endregion
+
+//region code coverage
+
+// 1. running androidTests with connectedCheck will generate an .ec file
+// in build/outputs/code-coverage/connected, plus the XML result in
+// in build/reports/coverage/debug/report.xml .
+
+// 2. running unit tests with testDebugUnitTest will just generate the .exec file.
+// The JacocoReport task from the jacoco plugin can create the XML report out of it.
+
+// to have a unified report, we just pass both the .exec and the .ec file
+// to the jacoco task, so we get a unified XML report with total coverage.
+// Reference: https://medium.com/@rafael_toledo/setting-up-an-unified-coverage-report-in-android-with-jacoco-robolectric-and-espresso-ffe239aaf3fa
+
+apply plugin: 'jacoco'
+
+def reportsDirectory = "$buildDir/reports/"
+jacoco {
+    toolVersion = "0.8.1"
+    reportsDir = file(reportsDirectory)
+}
+
+task mergedCoverageReport(type: JacocoReport) {
+    dependsOn "testDebugUnitTest"
+    dependsOn "connectedCheck"
+
+    def testData = "jacoco/testDebugUnitTest.exec"
+    def androidTestData = "outputs/code-coverage/connected/*coverage.ec"
+    executionData = fileTree(dir: "$buildDir", includes: [testData, androidTestData])
+
+    // Sources.
+    sourceDirectories = android.sourceSets.main.java.sourceFiles
+    // Add BuildConfig and R.
+    additionalSourceDirs = files([
+            "$buildDir/generated/source/buildConfig/debug",
+            "$buildDir/generated/source/r/debug"
+    ])
+
+    // Classes.
+    def debugDir = "$buildDir/intermediates/classes/debug"
+    def filter = ['**/R.class', '**/R$*.class', '**/*$ViewInjector*.*',
+                  '**/BuildConfig.*', '**/Manifest*.*']
+    classDirectories = fileTree(dir: debugDir, excludes: filter);
+
+    reports.xml.enabled = true
+    reports.html.enabled = true
+    reports.xml.destination = "$reportsDirectory/mergedCoverageReport/report.xml"
+}
+
+//endregion
+
+// export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_101.jdk/Contents/Home
+// To deploy ./gradlew bintrayUpload
+

cameraview/build.gradle.kts

@@ -1,137 +0,0 @@
-import io.deepmedia.tools.publisher.common.License
-import io.deepmedia.tools.publisher.common.Release
-import io.deepmedia.tools.publisher.common.GithubScm
-
-plugins {
-    id("com.android.library")
-    id("kotlin-android")
-    id("io.deepmedia.tools.publisher")
-    id("jacoco")
-}
-
-android {
-    compileSdk = property("compileSdkVersion") as Int
-    defaultConfig {
-        minSdk = property("minSdkVersion") as Int
-        targetSdk = property("targetSdkVersion") as Int
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-        testInstrumentationRunnerArguments["filter"] = "" +
-                "com.otaliastudios.cameraview.tools.SdkExcludeFilter," +
-                "com.otaliastudios.cameraview.tools.SdkIncludeFilter"
-    }
-    buildTypes["debug"].isTestCoverageEnabled = true
-    buildTypes["release"].isMinifyEnabled = false
-}
-
-dependencies {
-    testImplementation("junit:junit:4.13.1")
-    testImplementation("org.mockito:mockito-inline:2.28.2")
-
-    androidTestImplementation("androidx.test:runner:1.4.0")
-    androidTestImplementation("androidx.test:rules:1.4.0")
-    androidTestImplementation("androidx.test.ext:junit:1.1.3")
-    androidTestImplementation("org.mockito:mockito-android:2.28.2")
-    androidTestImplementation("androidx.test.espresso:espresso-core:3.4.0")
-
-    api("androidx.exifinterface:exifinterface:1.3.3")
-    api("androidx.lifecycle:lifecycle-common:2.3.1")
-    api("com.google.android.gms:play-services-tasks:17.2.1")
-    implementation("androidx.annotation:annotation:1.2.0")
-    implementation("com.otaliastudios.opengl:egloo:0.6.1")
-}
-
-// Publishing
-
-publisher {
-    project.description = "A well documented, high-level Android interface that makes capturing " +
-            "pictures and videos easy, addressing all of the common issues and needs. " +
-            "Real-time filters, gestures, watermarks, frame processing, RAW, output of any size."
-    project.artifact = "cameraview"
-    project.group = "com.otaliastudios"
-    project.url = "https://github.com/natario1/CameraView"
-    project.scm = GithubScm("natario1", "CameraView")
-    project.addLicense(License.APACHE_2_0)
-    project.addDeveloper("natario1", "mat.iavarone@gmail.com")
-    release.sources = Release.SOURCES_AUTO
-    release.docs = Release.DOCS_AUTO
-    release.version = "2.7.2"
-
-    directory()
-
-    sonatype {
-        auth.user = "SONATYPE_USER"
-        auth.password = "SONATYPE_PASSWORD"
-        signing.key = "SIGNING_KEY"
-        signing.password = "SIGNING_PASSWORD"
-    }
-
-    sonatype("snapshot") {
-        repository = io.deepmedia.tools.publisher.sonatype.Sonatype.OSSRH_SNAPSHOT_1
-        release.version = "latest-SNAPSHOT"
-        auth.user = "SONATYPE_USER"
-        auth.password = "SONATYPE_PASSWORD"
-        signing.key = "SIGNING_KEY"
-        signing.password = "SIGNING_PASSWORD"
-    }
-}
-
-// Code Coverage
-val buildDir = project.buildDir.absolutePath
-val coverageInputDir = "$buildDir/coverage_input" // changing? change github workflow
-val coverageOutputDir = "$buildDir/coverage_output" // changing? change github workflow
-
-// Run unit tests, with coverage enabled in the android { } configuration.
-// Output will be an .exec file in build/jacoco.
-tasks.register("runUnitTests") { // changing name? change github workflow
-    dependsOn("testDebugUnitTest")
-    doLast {
-        copy {
-            from("$buildDir/outputs/unit_test_code_coverage/debugUnitTest/testDebugUnitTest.exec")
-            into("$coverageInputDir/unit_tests") // changing? change github workflow
-        }
-    }
-}
-
-// Run android tests with coverage.
-tasks.register("runAndroidTests") { // changing name? change github workflow
-    dependsOn("connectedDebugAndroidTest")
-    doLast {
-        copy {
-            from("$buildDir/outputs/code_coverage/debugAndroidTest/connected")
-            include("*coverage.ec")
-            into("$coverageInputDir/android_tests") // changing? change github workflow
-        }
-    }
-}
-
-// Merge the two with a jacoco task.
-jacoco { toolVersion = "0.8.5" }
-tasks.register("computeCoverage", JacocoReport::class) {
-    dependsOn("compileDebugSources") // Compile sources, needed below
-    executionData.from(fileTree(coverageInputDir))
-    sourceDirectories.from(android.sourceSets["main"].java.srcDirs)
-    additionalSourceDirs.from("$buildDir/generated/source/buildConfig/debug")
-    additionalSourceDirs.from("$buildDir/generated/source/r/debug")
-    classDirectories.from(fileTree("$buildDir/intermediates/javac/debug") {
-        // Not everything here is relevant for CameraView, but let's keep it generic
-        exclude(
-                "**/R.class",
-                "**/R$*.class",
-                "**/BuildConfig.*",
-                "**/Manifest*.*",
-                "android/**",
-                "androidx/**",
-                "com/google/**",
-                "**/*\$ViewInjector*.*",
-                "**/Dagger*Component.class",
-                "**/Dagger*Component\$Builder.class",
-                "**/*Module_*Factory.class",
-                // We don"t test OpenGL filters.
-                "**/com/otaliastudios/cameraview/filters/**.*"
-        )
-    })
-    reports.html.required.set(true)
-    reports.xml.required.set(true)
-    reports.html.outputLocation.set(file("$coverageOutputDir/html"))
-    reports.xml.outputLocation.set(file("$coverageOutputDir/xml/report.xml"))
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/BaseEglTest.java

@@ -1,36 +0,0 @@
-package com.otaliastudios.cameraview;
-
-import android.opengl.EGL14;
-
-import com.otaliastudios.opengl.core.EglCore;
-import com.otaliastudios.opengl.surface.EglOffscreenSurface;
-import com.otaliastudios.opengl.surface.EglSurface;
-
-import org.junit.After;
-import org.junit.Before;
-
-
-@SuppressWarnings("WeakerAccess")
-public abstract class BaseEglTest extends BaseTest {
-
-    protected final static int WIDTH = 100;
-    protected final static int HEIGHT = 100;
-
-    protected EglCore eglCore;
-    protected EglSurface eglSurface;
-
-    @Before
-    public void setUp() {
-        eglCore = new EglCore(EGL14.EGL_NO_CONTEXT, EglCore.FLAG_RECORDABLE);
-        eglSurface = new EglOffscreenSurface(eglCore, WIDTH, HEIGHT);
-        eglSurface.makeCurrent();
-    }
-
-    @After
-    public void tearDown() {
-        eglSurface.release();
-        eglSurface = null;
-        eglCore.release();
-        eglCore = null;
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/BaseTest.java

@@ -1,50 +1,63 @@
 package com.otaliastudios.cameraview;
 
 
+import android.annotation.SuppressLint;
 import android.app.KeyguardManager;
 import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.graphics.YuvImage;
 import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.PowerManager;
-
+import android.support.test.InstrumentationRegistry;
-import androidx.annotation.NonNull;
+import android.support.test.annotation.UiThreadTest;
-import androidx.test.platform.app.InstrumentationRegistry;
+import android.support.test.espresso.core.internal.deps.guava.collect.ObjectArrays;
-import androidx.test.rule.GrantPermissionRule;
+import android.support.test.rule.ActivityTestRule;
-
+import android.view.View;
-import com.otaliastudios.cameraview.tools.Op;
 
 import org.junit.After;
 import org.junit.AfterClass;
+import org.junit.Before;
 import org.junit.BeforeClass;
-import org.mockito.Mockito;
+import org.junit.Rule;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.mockito.stubbing.Stubber;
 
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
 import java.util.concurrent.CountDownLatch;
 
 import static android.content.Context.KEYGUARD_SERVICE;
 import static android.content.Context.POWER_SERVICE;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
 import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public class BaseTest {
 
+    public static CameraLogger LOG = CameraLogger.create("Test");
+
     private static KeyguardManager.KeyguardLock keyguardLock;
     private static PowerManager.WakeLock wakeLock;
 
     // https://github.com/linkedin/test-butler/blob/bc2bb4df13d0a554d2e2b0ea710795017717e710/test-butler-app/src/main/java/com/linkedin/android/testbutler/ButlerService.java#L121
     @BeforeClass
-    public static void beforeClass_wakeUp() {
+    @SuppressWarnings("MissingPermission")
+    public static void wakeUp() {
         CameraLogger.setLogLevel(CameraLogger.LEVEL_VERBOSE);
 
         // Acquire a keyguard lock to prevent the lock screen from randomly appearing and breaking tests
-        KeyguardManager keyguardManager = (KeyguardManager) getContext().getSystemService(KEYGUARD_SERVICE);
+        KeyguardManager keyguardManager = (KeyguardManager) context().getSystemService(KEYGUARD_SERVICE);
         keyguardLock = keyguardManager.newKeyguardLock("CameraViewLock");
         keyguardLock.disableKeyguard();
 
         // Acquire a wake lock to prevent the cpu from going to sleep and breaking tests
-        PowerManager powerManager = (PowerManager) getContext().getSystemService(POWER_SERVICE);
+        PowerManager powerManager = (PowerManager) context().getSystemService(POWER_SERVICE);
         wakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK
                 | PowerManager.ACQUIRE_CAUSES_WAKEUP
                 | PowerManager.ON_AFTER_RELEASE, "CameraViewLock");
@@ -52,68 +65,109 @@ public class BaseTest {
     }
 
     @AfterClass
-    public static void afterClass_releaseWakeUp() {
+    @SuppressWarnings("MissingPermission")
-        CameraLogger.setLogLevel(CameraLogger.LEVEL_ERROR);
+    public static void releaseWakeUp() {
-
         wakeLock.release();
         keyguardLock.reenableKeyguard();
     }
 
-    /**
+    public static void ui(Runnable runnable) {
-     * This will make mockito report the error when it should.
+        InstrumentationRegistry.getInstrumentation().runOnMainSync(runnable);
-     * Mockito reports failure on the next mockito invocation, which is terrible
-     * since it might be on the next test or even never happen.
-     */
-    @After
-    public void after_checkMockito() {
-        Object object = Mockito.mock(Object.class);
-        //noinspection ResultOfMethodCallIgnored
-        object.toString();
     }
 
-    @NonNull
+    public static void uiAsync(Runnable runnable) {
-    protected static Context getContext() {
+        new Handler(Looper.getMainLooper()).post(runnable);
-        return InstrumentationRegistry.getInstrumentation().getContext();
     }
 
-    protected static void uiSync(Runnable runnable) {
+    public static Context context() {
-        InstrumentationRegistry.getInstrumentation().runOnMainSync(runnable);
+        return InstrumentationRegistry.getInstrumentation().getContext();
     }
 
-    @SuppressWarnings("unused")
+    public static void uiRequestLayout(final View view) {
-    protected static void uiAsync(Runnable runnable) {
+        ui(new Runnable() {
-        new Handler(Looper.getMainLooper()).post(runnable);
+            @Override
+            public void run() {
+                view.requestLayout();
+            }
+        });
     }
 
-    @SuppressWarnings("unused")
+    public static void idle() {
-    protected static void waitUiIdle() {
         InstrumentationRegistry.getInstrumentation().waitForIdleSync();
     }
 
-    @NonNull
+    public static void sleep(long time) {
-    protected static Stubber doCountDown(@NonNull final CountDownLatch latch) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void grantPermissions() {
+        grantPermission("android.permission.CAMERA");
+        grantPermission("android.permission.RECORD_AUDIO");
+        grantPermission("android.permission.WRITE_EXTERNAL_STORAGE");
+    }
+
+    public static void grantPermission(String permission) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return;
+        String command = "pm grant " + context().getPackageName() + " " + permission;
+        InstrumentationRegistry.getInstrumentation().getUiAutomation().executeShellCommand(command);
+    }
+
+    public static byte[] mockJpeg(int width, int height) {
+        Bitmap source = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        source.compress(Bitmap.CompressFormat.JPEG, 100, os);
+        return os.toByteArray();
+    }
+
+    public static YuvImage mockYuv(int width, int height) {
+        YuvImage y = mock(YuvImage.class);
+        when(y.getWidth()).thenReturn(width);
+        when(y.getHeight()).thenReturn(height);
+        when(y.compressToJpeg(any(Rect.class), anyInt(), any(OutputStream.class))).thenAnswer(new Answer<Boolean>() {
+            @Override
+            public Boolean answer(InvocationOnMock invocation) throws Throwable {
+                Rect rect = (Rect) invocation.getArguments()[0];
+                OutputStream stream = (OutputStream) invocation.getArguments()[2];
+                stream.write(mockJpeg(rect.width(), rect.height()));
+                return true;
+            }
+        });
+        return y;
+    }
+
+    public static Stubber doCountDown(final CountDownLatch latch) {
         return doAnswer(new Answer<Object>() {
             @Override
-            public Object answer(InvocationOnMock invocation) {
+            public Object answer(InvocationOnMock invocation) throws Throwable {
                 latch.countDown();
                 return null;
             }
         });
     }
 
-    @NonNull
+    public static <T> Stubber doEndTask(final Task<T> task, final T response) {
-    protected static <T> Stubber doEndOp(final Op<T> op, final T response) {
         return doAnswer(new Answer<Object>() {
             @Override
-            public Object answer(InvocationOnMock invocation) {
+            public Object answer(InvocationOnMock invocation) throws Throwable {
-                op.controller().end(response);
+                task.end(response);
                 return null;
             }
         });
     }
 
-    @NonNull
+    public static Stubber doEndTask(final Task task, final int withReturnArgument) {
-    protected static <T> Stubber doEndOp(final Op<T> op, final int withReturnArgument) {
+        return doAnswer(new Answer<Object>() {
-        return op.controller().from(withReturnArgument);
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                Object o = invocation.getArguments()[withReturnArgument];
+                //noinspection unchecked
+                task.end(o);
+                return null;
+            }
+        });
     }
 }

cameraview/src/androidTest/java/com/otaliastudios/cameraview/CameraLoggerTest.java

@@ -1,15 +1,15 @@
 package com.otaliastudios.cameraview;
 
 
-import com.otaliastudios.cameraview.tools.Op;
+import android.support.test.filters.SmallTest;
-
+import android.support.test.runner.AndroidJUnit4;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
 
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
@@ -24,13 +24,11 @@ public class CameraLoggerTest extends BaseTest {
     @Before
     public void setUp() {
         CameraLogger.setLogLevel(CameraLogger.LEVEL_VERBOSE);
-        CameraLogger.unregisterLogger(CameraLogger.sAndroidLogger); // Avoid writing into Logs during these tests
         logger = CameraLogger.create(loggerTag);
     }
 
     @After
     public void tearDown() {
-        CameraLogger.registerLogger(CameraLogger.sAndroidLogger);
         logger = null;
     }
 
@@ -109,21 +107,27 @@ public class CameraLoggerTest extends BaseTest {
         CameraLogger.Logger mock = mock(CameraLogger.Logger.class);
         CameraLogger.registerLogger(mock);
 
-        final Op<Throwable> op = new Op<>(false);
+        final Task<Throwable> task = new Task<>();
-        doEndOp(op, 3)
+        doAnswer(new Answer() {
-                .when(mock)
+            @Override
-                .log(anyInt(), anyString(), anyString(), any(Throwable.class));
+            public Object answer(InvocationOnMock invocation) throws Throwable {
-
+                Object[] args = invocation.getArguments();
-        op.listen();
+                Throwable throwable = (Throwable) args[3];
+                task.end(throwable);
+                return null;
+            }
+        }).when(mock).log(anyInt(), anyString(), anyString(), any(Throwable.class));
+
+        task.listen();
         logger.e("Got no error.");
-        assertNull(op.await(100));
+        assertNull(task.await(100));
 
-        op.listen();
+        task.listen();
         logger.e("Got error:", new RuntimeException(""));
-        assertNotNull(op.await(100));
+        assertNotNull(task.await(100));
 
-        op.listen();
+        task.listen();
         logger.e("Got", new RuntimeException(""), "while starting");
-        assertNotNull(op.await(100));
+        assertNotNull(task.await(100));
     }
 }

cameraview/src/androidTest/java/com/otaliastudios/cameraview/CameraOptions1Test.java

@@ -1,28 +1,9 @@
-package com.otaliastudios.cameraview.engine.options;
+package com.otaliastudios.cameraview;
 
 
-import android.graphics.ImageFormat;
 import android.hardware.Camera;
-
+import android.support.test.filters.SmallTest;
-import com.otaliastudios.cameraview.BaseTest;
+import android.support.test.runner.AndroidJUnit4;
-import com.otaliastudios.cameraview.CameraOptions;
-import com.otaliastudios.cameraview.controls.Audio;
-import com.otaliastudios.cameraview.controls.AudioCodec;
-import com.otaliastudios.cameraview.controls.Facing;
-import com.otaliastudios.cameraview.controls.Flash;
-import com.otaliastudios.cameraview.controls.PictureFormat;
-import com.otaliastudios.cameraview.engine.mappers.Camera1Mapper;
-import com.otaliastudios.cameraview.gesture.GestureAction;
-import com.otaliastudios.cameraview.controls.Grid;
-import com.otaliastudios.cameraview.controls.Hdr;
-import com.otaliastudios.cameraview.controls.Mode;
-import com.otaliastudios.cameraview.controls.VideoCodec;
-import com.otaliastudios.cameraview.controls.WhiteBalance;
-import com.otaliastudios.cameraview.size.AspectRatio;
-import com.otaliastudios.cameraview.size.Size;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -42,26 +23,22 @@ import static org.mockito.Mockito.when;
 
 @RunWith(AndroidJUnit4.class)
 @SmallTest
-public class Camera1OptionsTest extends BaseTest {
+public class CameraOptions1Test extends BaseTest {
 
     @Test
     public void testEmpty() {
-        CameraOptions o = new Camera1Options(mock(Camera.Parameters.class), 0, false);
+        CameraOptions o = new CameraOptions(mock(Camera.Parameters.class), false);
         assertTrue(o.getSupportedPictureAspectRatios().isEmpty());
         assertTrue(o.getSupportedPictureSizes().isEmpty());
         assertTrue(o.getSupportedWhiteBalance().isEmpty());
-        assertEquals(1, o.getSupportedFlash().size()); // Flash.OFF is always there
+        assertTrue(o.getSupportedFlash().isEmpty());
-        assertEquals(1, o.getSupportedHdr().size()); // Hdr.OFF is always there
+        assertTrue(o.getSupportedHdr().isEmpty());
         assertFalse(o.isAutoFocusSupported());
         assertFalse(o.isExposureCorrectionSupported());
+        assertFalse(o.isVideoSnapshotSupported());
         assertFalse(o.isZoomSupported());
         assertEquals(o.getExposureCorrectionMaxValue(), 0f, 0);
         assertEquals(o.getExposureCorrectionMinValue(), 0f, 0);
-        // Static
-        assertEquals(1, o.getSupportedPictureFormats().size());
-        assertTrue(o.getSupportedPictureFormats().contains(PictureFormat.JPEG));
-        assertEquals(1, o.getSupportedFrameProcessingFormats().size());
-        assertTrue(o.getSupportedFrameProcessingFormats().contains(ImageFormat.NV21));
     }
 
     private Camera.Size mockCameraSize(int width, int height) {
@@ -81,8 +58,8 @@ public class Camera1OptionsTest extends BaseTest {
         );
         Camera.Parameters params = mock(Camera.Parameters.class);
         when(params.getSupportedPictureSizes()).thenReturn(sizes);
-        CameraOptions o = new Camera1Options(params, 0, false);
+        CameraOptions o = new CameraOptions(params, false);
-        Collection<Size> supportedSizes = o.getSupportedPictureSizes();
+        Set<Size> supportedSizes = o.getSupportedPictureSizes();
         assertEquals(supportedSizes.size(), sizes.size());
         for (Camera.Size size : sizes) {
             Size internalSize = new Size(size.width, size.height);
@@ -100,8 +77,8 @@ public class Camera1OptionsTest extends BaseTest {
         );
         Camera.Parameters params = mock(Camera.Parameters.class);
         when(params.getSupportedPictureSizes()).thenReturn(sizes);
-        CameraOptions o = new Camera1Options(params, 0, true);
+        CameraOptions o = new CameraOptions(params, true);
-        Collection<Size> supportedSizes = o.getSupportedPictureSizes();
+        Set<Size> supportedSizes = o.getSupportedPictureSizes();
         assertEquals(supportedSizes.size(), sizes.size());
         for (Camera.Size size : sizes) {
             Size internalSize = new Size(size.width, size.height).flip();
@@ -125,94 +102,8 @@ public class Camera1OptionsTest extends BaseTest {
 
         Camera.Parameters params = mock(Camera.Parameters.class);
         when(params.getSupportedPictureSizes()).thenReturn(sizes);
-        CameraOptions o = new Camera1Options(params, 0, false);
+        CameraOptions o = new CameraOptions(params, false);
-        Collection<AspectRatio> supportedRatios = o.getSupportedPictureAspectRatios();
+        Set<AspectRatio> supportedRatios = o.getSupportedPictureAspectRatios();
-        assertEquals(supportedRatios.size(), expected.size());
-        for (AspectRatio ratio : expected) {
-            assertTrue(supportedRatios.contains(ratio));
-        }
-    }
-
-
-    @Test
-    public void testVideoSizes() {
-        // VideoSize are capped by CamcorderProfile.QUALITY_HIGH max size.
-        // This can be very small on an emulator, so use very small sizes to not hit that value.
-        List<Camera.Size> sizes = Arrays.asList(
-                mockCameraSize(10, 20),
-                mockCameraSize(5, 5),
-                mockCameraSize(16, 9),
-                mockCameraSize(20, 40)
-        );
-        Camera.Parameters params = mock(Camera.Parameters.class);
-        when(params.getSupportedVideoSizes()).thenReturn(sizes);
-        CameraOptions o = new Camera1Options(params, 0, false);
-        Collection<Size> supportedSizes = o.getSupportedVideoSizes();
-        assertEquals(supportedSizes.size(), sizes.size());
-        for (Camera.Size size : sizes) {
-            Size internalSize = new Size(size.width, size.height);
-            assertTrue(supportedSizes.contains(internalSize));
-        }
-    }
-
-    @Test
-    public void testVideoSizesNull() {
-        // When videoSizes is null, we take the preview sizes.
-        List<Camera.Size> sizes = Arrays.asList(
-                mockCameraSize(10, 20),
-                mockCameraSize(5, 5),
-                mockCameraSize(16, 9),
-                mockCameraSize(20, 40)
-        );
-        Camera.Parameters params = mock(Camera.Parameters.class);
-        when(params.getSupportedVideoSizes()).thenReturn(null);
-        when(params.getSupportedPreviewSizes()).thenReturn(sizes);
-        CameraOptions o = new Camera1Options(params, 0, false);
-        Collection<Size> supportedSizes = o.getSupportedVideoSizes();
-        assertEquals(supportedSizes.size(), sizes.size());
-        for (Camera.Size size : sizes) {
-            Size internalSize = new Size(size.width, size.height);
-            assertTrue(supportedSizes.contains(internalSize));
-        }
-    }
-
-    @Test
-    public void testVideoSizesFlip() {
-        List<Camera.Size> sizes = Arrays.asList(
-                mockCameraSize(10, 20),
-                mockCameraSize(5, 5),
-                mockCameraSize(16, 9),
-                mockCameraSize(20, 40)
-        );
-        Camera.Parameters params = mock(Camera.Parameters.class);
-        when(params.getSupportedVideoSizes()).thenReturn(sizes);
-        CameraOptions o = new Camera1Options(params, 0, true);
-        Collection<Size> supportedSizes = o.getSupportedVideoSizes();
-        assertEquals(supportedSizes.size(), sizes.size());
-        for (Camera.Size size : sizes) {
-            Size internalSize = new Size(size.width, size.height).flip();
-            assertTrue(supportedSizes.contains(internalSize));
-        }
-    }
-
-    @Test
-    public void testVideoAspectRatio() {
-        List<Camera.Size> sizes = Arrays.asList(
-                mockCameraSize(10, 20),
-                mockCameraSize(5, 5),
-                mockCameraSize(16, 9),
-                mockCameraSize(20, 40)
-        );
-
-        Set<AspectRatio> expected = new HashSet<>();
-        expected.add(AspectRatio.of(1, 2));
-        expected.add(AspectRatio.of(1, 1));
-        expected.add(AspectRatio.of(16, 9));
-
-        Camera.Parameters params = mock(Camera.Parameters.class);
-        when(params.getSupportedVideoSizes()).thenReturn(sizes);
-        CameraOptions o = new Camera1Options(params, 0, false);
-        Collection<AspectRatio> supportedRatios = o.getSupportedVideoAspectRatios();
         assertEquals(supportedRatios.size(), expected.size());
         for (AspectRatio ratio : expected) {
             assertTrue(supportedRatios.contains(ratio));
@@ -227,13 +118,12 @@ public class Camera1OptionsTest extends BaseTest {
         when(params.getMaxExposureCompensation()).thenReturn(0);
         when(params.getMinExposureCompensation()).thenReturn(0);
 
-        CameraOptions o = new Camera1Options(params, 0, false);
+        CameraOptions o = new CameraOptions(params, false);
-        assertFalse(o.supports(GestureAction.AUTO_FOCUS));
+        assertFalse(o.supports(GestureAction.FOCUS));
-        assertTrue(o.supports(GestureAction.TAKE_PICTURE));
+        assertFalse(o.supports(GestureAction.FOCUS_WITH_MARKER));
+        assertTrue(o.supports(GestureAction.CAPTURE));
         assertTrue(o.supports(GestureAction.NONE));
         assertTrue(o.supports(GestureAction.ZOOM));
-        assertTrue(o.supports(GestureAction.FILTER_CONTROL_1));
-        assertTrue(o.supports(GestureAction.FILTER_CONTROL_2));
         assertFalse(o.supports(GestureAction.EXPOSURE_CORRECTION));
     }
 
@@ -241,17 +131,15 @@ public class Camera1OptionsTest extends BaseTest {
     public void testAlwaysSupportedControls() {
         // Grid, VideoQuality, SessionType and Audio are always supported.
         Camera.Parameters params = mock(Camera.Parameters.class);
-        CameraOptions o = new Camera1Options(params, 0, false);
+        CameraOptions o = new CameraOptions(params, false);
 
         Collection<Grid> grids = o.getSupportedControls(Grid.class);
-        Collection<VideoCodec> video = o.getSupportedControls(VideoCodec.class);
+        Collection<VideoQuality> video = o.getSupportedControls(VideoQuality.class);
-        Collection<AudioCodec> audioCodecs = o.getSupportedControls(AudioCodec.class);
+        Collection<SessionType> sessions = o.getSupportedControls(SessionType.class);
-        Collection<Mode> sessions = o.getSupportedControls(Mode.class);
         Collection<Audio> audio = o.getSupportedControls(Audio.class);
         assertEquals(grids.size(), Grid.values().length);
-        assertEquals(video.size(), VideoCodec.values().length);
+        assertEquals(video.size(), VideoQuality.values().length);
-        assertEquals(audioCodecs.size(), AudioCodec.values().length);
+        assertEquals(sessions.size(), SessionType.values().length);
-        assertEquals(sessions.size(), Mode.values().length);
         assertEquals(audio.size(), Audio.values().length);
     }
 
@@ -264,12 +152,12 @@ public class Camera1OptionsTest extends BaseTest {
             supported.add(cameraInfo.facing);
         }
 
-        CameraOptions o = new Camera1Options(mock(Camera.Parameters.class), 0, false);
+        CameraOptions o = new CameraOptions(mock(Camera.Parameters.class), false);
-        Camera1Mapper m = Camera1Mapper.get();
+        Mapper m = new Mapper.Mapper1();
         Collection<Facing> s = o.getSupportedControls(Facing.class);
         assertEquals(s.size(), supported.size());
         for (Facing facing : s) {
-            assertTrue(supported.contains(m.mapFacing(facing)));
+            assertTrue(supported.contains(m.<Integer>map(facing)));
             assertTrue(o.supports(facing));
         }
     }
@@ -283,7 +171,7 @@ public class Camera1OptionsTest extends BaseTest {
                 Camera.Parameters.WHITE_BALANCE_SHADE // Not supported
         ));
 
-        CameraOptions o = new Camera1Options(params, 0, false);
+        CameraOptions o = new CameraOptions(params, false);
         Collection<WhiteBalance> w = o.getSupportedControls(WhiteBalance.class);
         assertEquals(w.size(), 2);
         assertTrue(w.contains(WhiteBalance.AUTO));
@@ -296,20 +184,16 @@ public class Camera1OptionsTest extends BaseTest {
     public void testFlash() {
         Camera.Parameters params = mock(Camera.Parameters.class);
         when(params.getSupportedFlashModes()).thenReturn(Arrays.asList(
-                Camera.Parameters.FLASH_MODE_OFF, // Supported
                 Camera.Parameters.FLASH_MODE_AUTO, // Supported
                 Camera.Parameters.FLASH_MODE_TORCH, // Supported
                 Camera.Parameters.FLASH_MODE_RED_EYE // Not supported
         ));
 
-        CameraOptions o = new Camera1Options(params, 0, false);
+        CameraOptions o = new CameraOptions(params, false);
         Collection<Flash> f = o.getSupportedControls(Flash.class);
-        assertEquals(f.size(), 3);
+        assertEquals(f.size(), 2);
-        assertTrue(f.contains(Flash.OFF));
         assertTrue(f.contains(Flash.AUTO));
         assertTrue(f.contains(Flash.TORCH));
-
-        assertTrue(o.supports(Flash.OFF));
         assertTrue(o.supports(Flash.AUTO));
         assertTrue(o.supports(Flash.TORCH));
     }
@@ -323,12 +207,11 @@ public class Camera1OptionsTest extends BaseTest {
                 Camera.Parameters.SCENE_MODE_FIREWORKS // Not supported
         ));
 
-        CameraOptions o = new Camera1Options(params, 0, false);
+        CameraOptions o = new CameraOptions(params, false);
         Collection<Hdr> h = o.getSupportedControls(Hdr.class);
         assertEquals(h.size(), 2);
         assertTrue(h.contains(Hdr.OFF));
         assertTrue(h.contains(Hdr.ON));
-
         assertTrue(o.supports(Hdr.OFF));
         assertTrue(o.supports(Hdr.ON));
     }
@@ -338,9 +221,9 @@ public class Camera1OptionsTest extends BaseTest {
         Camera.Parameters params = mock(Camera.Parameters.class);
         when(params.isVideoSnapshotSupported()).thenReturn(true);
         when(params.isZoomSupported()).thenReturn(true);
-        //noinspection ArraysAsListWithZeroOrOneArgument
         when(params.getSupportedFocusModes()).thenReturn(Arrays.asList(Camera.Parameters.FOCUS_MODE_AUTO));
-        CameraOptions o = new Camera1Options(params, 0, false);
+        CameraOptions o = new CameraOptions(params, false);
+        assertTrue(o.isVideoSnapshotSupported());
         assertTrue(o.isZoomSupported());
         assertTrue(o.isAutoFocusSupported());
     }
@@ -351,23 +234,10 @@ public class Camera1OptionsTest extends BaseTest {
         when(params.getMaxExposureCompensation()).thenReturn(10);
         when(params.getMinExposureCompensation()).thenReturn(-10);
         when(params.getExposureCompensationStep()).thenReturn(0.5f);
-        CameraOptions o = new Camera1Options(params, 0, false);
+        CameraOptions o = new CameraOptions(params, false);
         assertTrue(o.isExposureCorrectionSupported());
         assertEquals(o.getExposureCorrectionMinValue(), -10f * 0.5f, 0f);
         assertEquals(o.getExposureCorrectionMaxValue(), 10f * 0.5f, 0f);
     }
 
-    @Test
-    public void testPreviewFrameRate() {
-        Camera.Parameters params = mock(Camera.Parameters.class);
-        List<int[]> result = Arrays.asList(
-                new int[]{20000, 30000},
-                new int[]{30000, 60000},
-                new int[]{60000, 120000}
-        );
-        when(params.getSupportedPreviewFpsRange()).thenReturn(result);
-        CameraOptions o = new Camera1Options(params, 0, false);
-        assertEquals(20F, o.getPreviewFrameRateMinValue(), 0.001F);
-        assertEquals(120F, o.getPreviewFrameRateMaxValue(), 0.001F);
-    }
 }

cameraview/src/androidTest/java/com/otaliastudios/cameraview/CameraUtilsTest.java

@@ -1,26 +1,21 @@
 package com.otaliastudios.cameraview;
 
 
+import android.annotation.TargetApi;
+import android.app.Instrumentation;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.graphics.Bitmap;
 import android.graphics.Color;
-
+import android.support.test.InstrumentationRegistry;
-import com.otaliastudios.cameraview.tools.Op;
+import android.support.test.filters.SmallTest;
-
+import android.support.test.internal.runner.InstrumentationConnection;
-import androidx.annotation.NonNull;
+import android.support.test.runner.AndroidJUnit4;
-import androidx.annotation.Nullable;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.nio.charset.Charset;
 
 import static org.mockito.Mockito.*;
 import static org.junit.Assert.*;
@@ -34,93 +29,44 @@ public class CameraUtilsTest extends BaseTest {
         Context context = mock(Context.class);
         PackageManager pm = mock(PackageManager.class);
         when(context.getPackageManager()).thenReturn(pm);
-        when(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA)).thenReturn(true);
+        when(pm.hasSystemFeature(anyString())).thenReturn(true);
-        when(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA_FRONT)).thenReturn(true);
-        assertTrue(CameraUtils.hasCameras(context));
-        when(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA)).thenReturn(false);
-        when(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA_FRONT)).thenReturn(true);
         assertTrue(CameraUtils.hasCameras(context));
-        when(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA)).thenReturn(false);
-        when(pm.hasSystemFeature(PackageManager.FEATURE_CAMERA_FRONT)).thenReturn(false);
-        assertFalse(CameraUtils.hasCameras(context));
-    }
 
-    @NonNull
+        when(pm.hasSystemFeature(anyString())).thenReturn(false);
-    private Op<String> writeAndReadString(@NonNull String data) {
+        assertFalse(CameraUtils.hasCameras(context));
-        final File file = new File(getContext().getFilesDir(), "string.txt");
-        final byte[] bytes = data.getBytes(Charset.forName("UTF-8"));
-        final Op<String> result = new Op<>();
-        final FileCallback callback = new FileCallback() {
-            @Override
-            public void onFileReady(@Nullable File file) {
-                if (file == null) {
-                    result.controller().end(null);
-                } else {
-                    // Read back the file.
-                    try {
-                        FileInputStream stream = new FileInputStream(file);
-                        byte[] bytes = new byte[stream.available()];
-                        stream.read(bytes);
-                        result.controller().end(new String(bytes, Charset.forName("UTF-8")));
-                    } catch (IOException e) {
-                        result.controller().end(null);
-                    }
-                }
-            }
-        };
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                CameraUtils.writeToFile(bytes, file, callback);
-            }
-        });
-        return result;
     }
 
-    @Test
+    // Encodes bitmap and decodes again using our utility.
-    public void testWriteToFile() {
+    private Task<Bitmap> encodeDecodeTask(Bitmap source) {
-        Op<String> op = writeAndReadString("testString");
+        return encodeDecodeTask(source, 0, 0);
-        String result = op.await(2000);
-        assertEquals("testString", result);
     }
 
-
     // Encodes bitmap and decodes again using our utility.
-    private Op<Bitmap> encodeDecodeTask(@NonNull Bitmap source, final int maxWidth, final int maxHeight, boolean async) {
+    private Task<Bitmap> encodeDecodeTask(Bitmap source, final int maxWidth, final int maxHeight) {
         final ByteArrayOutputStream os = new ByteArrayOutputStream();
         // Using lossy JPG we can't have strict comparison of values after compression.
         source.compress(Bitmap.CompressFormat.PNG, 100, os);
         final byte[] data = os.toByteArray();
 
-        final Op<Bitmap> decode = new Op<>();
+        final Task<Bitmap> decode = new Task<>(true);
-        if (async) {
+        final CameraUtils.BitmapCallback callback = new CameraUtils.BitmapCallback() {
-            final BitmapCallback callback = new BitmapCallback() {
+            @Override
-                @Override
+            public void onBitmapReady(Bitmap bitmap) {
-                public void onBitmapReady(Bitmap bitmap) {
+                decode.end(bitmap);
-                    decode.controller().end(bitmap);
+            }
-                }
+        };
-            };
+
-
+        // Run on ui because it involves handlers.
-            // Run on ui because it involves handlers.
+        ui(new Runnable() {
-            uiSync(new Runnable() {
+            @Override
-                @Override
+            public void run() {
-                public void run() {
+                if (maxWidth > 0 && maxHeight > 0) {
-                    if (maxWidth > 0 && maxHeight > 0) {
+                    CameraUtils.decodeBitmap(data, maxWidth, maxHeight, callback);
-                        CameraUtils.decodeBitmap(data, maxWidth, maxHeight, callback);
+                } else {
-                    } else {
+                    CameraUtils.decodeBitmap(data, callback);
-                        CameraUtils.decodeBitmap(data, callback);
-                    }
                 }
-            });
-        } else {
-            Bitmap result;
-            if (maxWidth > 0 && maxHeight > 0) {
-                result = CameraUtils.decodeBitmap(data, maxWidth, maxHeight);
-            } else {
-                result = CameraUtils.decodeBitmap(data);
             }
-            decode.controller().end(result);
+        });
-        }
         return decode;
     }
 
@@ -130,7 +76,7 @@ public class CameraUtilsTest extends BaseTest {
         Bitmap source = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
         source.setPixel(0, 0, color);
 
-        Op<Bitmap> decode = encodeDecodeTask(source, 0, 0, true);
+        Task<Bitmap> decode = encodeDecodeTask(source);
         Bitmap other = decode.await(800);
         assertNotNull(other);
         assertEquals(100, w);
@@ -139,23 +85,8 @@ public class CameraUtilsTest extends BaseTest {
         assertEquals(0, other.getPixel(0, h-1));
         assertEquals(0, other.getPixel(w-1, 0));
         assertEquals(0, other.getPixel(w-1, h-1));
-    }
-
-    @Test
-    public void testDecodeBitmapSync() {
-        int w = 100, h = 200, color = Color.WHITE;
-        Bitmap source = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
-        source.setPixel(0, 0, color);
 
-        Op<Bitmap> decode = encodeDecodeTask(source, 0, 0, false);
+        // TODO: improve when we add EXIF writing to byte arrays
-        Bitmap other = decode.await(800);
-        assertNotNull(other);
-        assertEquals(100, w);
-        assertEquals(200, h);
-        assertEquals(color, other.getPixel(0, 0));
-        assertEquals(0, other.getPixel(0, h-1));
-        assertEquals(0, other.getPixel(w-1, 0));
-        assertEquals(0, other.getPixel(w-1, h-1));
     }
 
 
@@ -163,25 +94,25 @@ public class CameraUtilsTest extends BaseTest {
     public void testDecodeDownscaledBitmap() {
         int width = 1000, height = 2000;
         Bitmap source = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
-        Op<Bitmap> op;
+        Task<Bitmap> task;
         Bitmap other;
 
-        op = encodeDecodeTask(source, 100, 100, true);
+        task = encodeDecodeTask(source, 100, 100);
-        other = op.await(800);
+        other = task.await(800);
         assertNotNull(other);
         assertTrue(other.getWidth() <= 100);
         assertTrue(other.getHeight() <= 100);
 
-        op = encodeDecodeTask(source, Integer.MAX_VALUE, Integer.MAX_VALUE, true);
+        task = encodeDecodeTask(source, Integer.MAX_VALUE, Integer.MAX_VALUE);
-        other = op.await(800);
+        other = task.await(800);
         assertNotNull(other);
-        assertEquals(other.getWidth(), width);
+        assertTrue(other.getWidth() == width);
-        assertEquals(other.getHeight(), height);
+        assertTrue(other.getHeight() == height);
 
-        op = encodeDecodeTask(source, 6000, 6000, true);
+        task = encodeDecodeTask(source, 6000, 6000);
-        other = op.await(800);
+        other = task.await(800);
         assertNotNull(other);
-        assertEquals(other.getWidth(), width);
+        assertTrue(other.getWidth() == width);
-        assertEquals(other.getHeight(), height);
+        assertTrue(other.getHeight() == height);
     }
 }

cameraview/src/androidTest/java/com/otaliastudios/cameraview/CameraViewCallbacksTest.java

@@ -2,95 +2,75 @@ package com.otaliastudios.cameraview;
 
 
 import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
 import android.graphics.PointF;
-
+import android.support.test.filters.MediumTest;
-import androidx.annotation.NonNull;
+import android.support.test.runner.AndroidJUnit4;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.MediumTest;
 import android.view.ViewGroup;
 
-import com.otaliastudios.cameraview.controls.Audio;
-import com.otaliastudios.cameraview.controls.Engine;
-import com.otaliastudios.cameraview.controls.Preview;
-import com.otaliastudios.cameraview.engine.CameraEngine;
-import com.otaliastudios.cameraview.frame.Frame;
-import com.otaliastudios.cameraview.frame.FrameProcessor;
-import com.otaliastudios.cameraview.gesture.Gesture;
-import com.otaliastudios.cameraview.gesture.GestureAction;
-import com.otaliastudios.cameraview.tools.Op;
-import com.otaliastudios.cameraview.engine.MockCameraEngine;
-import com.otaliastudios.cameraview.markers.AutoFocusMarker;
-import com.otaliastudios.cameraview.markers.AutoFocusTrigger;
-import com.otaliastudios.cameraview.markers.MarkerLayout;
-import com.otaliastudios.cameraview.preview.MockCameraPreview;
-import com.otaliastudios.cameraview.preview.CameraPreview;
-
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.Stubber;
 
 import static junit.framework.Assert.assertNotNull;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
-import static org.mockito.ArgumentMatchers.nullable;
 import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyFloat;
 import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
-/**
- * Tests {@link CameraView#mCameraCallbacks} dispatch functions.
- */
 @RunWith(AndroidJUnit4.class)
 @MediumTest
 public class CameraViewCallbacksTest extends BaseTest {
 
-    private final static long DELAY = 500;
-
     private CameraView camera;
     private CameraListener listener;
     private FrameProcessor processor;
-    private MockCameraEngine mockController;
+    private MockCameraController mockController;
     private MockCameraPreview mockPreview;
-    private Op<Boolean> op;
+    private Task<Boolean> task;
+
 
     @Before
     public void setUp() {
-        uiSync(new Runnable() {
+        ui(new Runnable() {
             @Override
             public void run() {
-                Context context = getContext();
+                Context context = context();
                 listener = mock(CameraListener.class);
                 processor = mock(FrameProcessor.class);
                 camera = new CameraView(context) {
-
-                    @NonNull
                     @Override
-                    protected CameraEngine instantiateCameraEngine(@NonNull Engine engine, @NonNull CameraEngine.Callback callback) {
+                    protected CameraController instantiateCameraController(CameraCallbacks callbacks) {
-                        mockController = new MockCameraEngine(callback);
+                        mockController = new MockCameraController(callbacks);
                         return mockController;
                     }
 
-                    @NonNull
                     @Override
-                    protected CameraPreview instantiatePreview(@NonNull Preview preview, @NonNull Context context, @NonNull ViewGroup container) {
+                    protected CameraPreview instantiatePreview(Context context, ViewGroup container) {
                         mockPreview = new MockCameraPreview(context, container);
                         return mockPreview;
                     }
 
                     @Override
-                    protected boolean checkPermissions(@NonNull Audio audio) {
+                    protected boolean checkPermissions(SessionType sessionType, Audio audio) {
                         return true;
                     }
                 };
-                camera.doInstantiatePreview();
+                camera.instantiatePreview();
                 camera.addCameraListener(listener);
                 camera.addFrameProcessor(processor);
-                op = new Op<>();
+                task = new Task<>(true);
             }
         });
     }
@@ -103,176 +83,211 @@ public class CameraViewCallbacksTest extends BaseTest {
         listener = null;
     }
 
+    // Completes our task.
+    private Stubber completeTask() {
+        return doAnswer(new Answer() {
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                task.end(true);
+                return null;
+            }
+        });
+    }
+
     @Test
     public void testDontDispatchIfRemoved() {
         camera.removeCameraListener(listener);
-        CameraOptions options = mock(CameraOptions.class);
+        completeTask().when(listener).onCameraOpened(null);
-        doEndOp(op, true).when(listener).onCameraOpened(options);
+        camera.mCameraCallbacks.dispatchOnCameraOpened(null);
-        camera.mCameraCallbacks.dispatchOnCameraOpened(options);
 
-        assertNull(op.await(DELAY));
+        assertNull(task.await(200));
-        verify(listener, never()).onCameraOpened(options);
+        verify(listener, never()).onCameraOpened(null);
     }
 
     @Test
     public void testDontDispatchIfCleared() {
         camera.clearCameraListeners();
-        CameraOptions options = mock(CameraOptions.class);
+        completeTask().when(listener).onCameraOpened(null);
-        doEndOp(op, true).when(listener).onCameraOpened(options);
+        camera.mCameraCallbacks.dispatchOnCameraOpened(null);
-        camera.mCameraCallbacks.dispatchOnCameraOpened(options);
 
-        assertNull(op.await(DELAY));
+        assertNull(task.await(200));
-        verify(listener, never()).onCameraOpened(options);
+        verify(listener, never()).onCameraOpened(null);
     }
 
     @Test
     public void testDispatchOnCameraOpened() {
-        CameraOptions options = mock(CameraOptions.class);
+        completeTask().when(listener).onCameraOpened(null);
-        doEndOp(op, true).when(listener).onCameraOpened(options);
+        camera.mCameraCallbacks.dispatchOnCameraOpened(null);
-        camera.mCameraCallbacks.dispatchOnCameraOpened(options);
 
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
-        verify(listener, times(1)).onCameraOpened(options);
+        verify(listener, times(1)).onCameraOpened(null);
     }
 
     @Test
     public void testDispatchOnCameraClosed() {
-        doEndOp(op, true).when(listener).onCameraClosed();
+        completeTask().when(listener).onCameraClosed();
         camera.mCameraCallbacks.dispatchOnCameraClosed();
 
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
         verify(listener, times(1)).onCameraClosed();
     }
 
-    @Test
-    public void testDispatchOnVideoRecordingStart() {
-        doEndOp(op, true).when(listener).onVideoRecordingStart();
-        camera.mCameraCallbacks.dispatchOnVideoRecordingStart();
-
-        assertNotNull(op.await(DELAY));
-        verify(listener, times(1)).onVideoRecordingStart();
-    }
-
-    @Test
-    public void testDispatchOnVideoRecordingEnd() {
-        doEndOp(op, true).when(listener).onVideoRecordingEnd();
-        camera.mCameraCallbacks.dispatchOnVideoRecordingEnd();
-
-        assertNotNull(op.await(DELAY));
-        verify(listener, times(1)).onVideoRecordingEnd();
-    }
-
     @Test
     public void testDispatchOnVideoTaken() {
-        VideoResult.Stub stub = new VideoResult.Stub();
+        completeTask().when(listener).onVideoTaken(null);
-        doEndOp(op, true).when(listener).onVideoTaken(any(VideoResult.class));
+        camera.mCameraCallbacks.dispatchOnVideoTaken(null);
-        camera.mCameraCallbacks.dispatchOnVideoTaken(stub);
 
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
-        verify(listener, times(1)).onVideoTaken(any(VideoResult.class));
+        verify(listener, times(1)).onVideoTaken(null);
-    }
-
-    @Test
-    public void testDispatchOnPictureTaken() {
-        PictureResult.Stub stub = new PictureResult.Stub();
-        doEndOp(op, true).when(listener).onPictureTaken(any(PictureResult.class));
-        camera.mCameraCallbacks.dispatchOnPictureTaken(stub);
-        assertNotNull(op.await(DELAY));
-        verify(listener, times(1)).onPictureTaken(any(PictureResult.class));
     }
 
     @Test
     public void testDispatchOnZoomChanged() {
-        doEndOp(op, true).when(listener).onZoomChanged(eq(0f), eq(new float[]{0, 1}), nullable(PointF[].class));
+        completeTask().when(listener).onZoomChanged(anyFloat(), any(float[].class), any(PointF[].class));
         camera.mCameraCallbacks.dispatchOnZoomChanged(0f, null);
 
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
-        verify(listener, times(1)).onZoomChanged(eq(0f), eq(new float[]{0, 1}), nullable(PointF[].class));
+        verify(listener, times(1)).onZoomChanged(anyFloat(), any(float[].class), any(PointF[].class));
     }
 
     @Test
     public void testDispatchOnExposureCorrectionChanged() {
-        float[] bounds = new float[]{};
+        completeTask().when(listener).onExposureCorrectionChanged(0f, null, null);
-        doEndOp(op, true).when(listener).onExposureCorrectionChanged(0f, bounds, null);
+        camera.mCameraCallbacks.dispatchOnExposureCorrectionChanged(0f, null, null);
-        camera.mCameraCallbacks.dispatchOnExposureCorrectionChanged(0f, bounds, null);
 
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
-        verify(listener, times(1)).onExposureCorrectionChanged(0f, bounds, null);
+        verify(listener, times(1)).onExposureCorrectionChanged(0f, null, null);
     }
 
     @Test
     public void testDispatchOnFocusStart() {
         // Enable tap gesture.
-        // Can't mock package protected. camera.mTapGestureFinder = mock(TapGestureLayout.class);
+        // Can't mock package protected. camera.mTapGestureLayout = mock(TapGestureLayout.class);
-        camera.mapGesture(Gesture.TAP, GestureAction.AUTO_FOCUS);
+        camera.mapGesture(Gesture.TAP, GestureAction.FOCUS_WITH_MARKER);
-        AutoFocusMarker marker = mock(AutoFocusMarker.class);
-        MarkerLayout markerLayout = mock(MarkerLayout.class);
-        camera.setAutoFocusMarker(marker);
-        camera.mMarkerLayout = markerLayout;
 
         PointF point = new PointF();
-        doEndOp(op, true).when(listener).onAutoFocusStart(point);
+        completeTask().when(listener).onFocusStart(point);
         camera.mCameraCallbacks.dispatchOnFocusStart(Gesture.TAP, point);
 
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
-        verify(listener, times(1)).onAutoFocusStart(point);
+        verify(listener, times(1)).onFocusStart(point);
-        verify(marker, times(1)).onAutoFocusStart(AutoFocusTrigger.GESTURE, point);
+        // Can't mock package protected. verify(camera.mTapGestureLayout, times(1)).onFocusStart(point);
-        verify(markerLayout, times(1)).onEvent(eq(MarkerLayout.TYPE_AUTOFOCUS), any(PointF[].class));
     }
 
     @Test
     public void testDispatchOnFocusEnd() {
         // Enable tap gesture.
-        // Can't mock package protected. camera.mTapGestureFinder = mock(TapGestureLayout.class);
+        // Can't mock package protected. camera.mTapGestureLayout = mock(TapGestureLayout.class);
-        camera.mapGesture(Gesture.TAP, GestureAction.AUTO_FOCUS);
+        camera.mapGesture(Gesture.TAP, GestureAction.FOCUS_WITH_MARKER);
-        AutoFocusMarker marker = mock(AutoFocusMarker.class);
-        camera.setAutoFocusMarker(marker);
 
         PointF point = new PointF();
         boolean success = true;
-        doEndOp(op, true).when(listener).onAutoFocusEnd(success, point);
+        completeTask().when(listener).onFocusEnd(success, point);
         camera.mCameraCallbacks.dispatchOnFocusEnd(Gesture.TAP, success, point);
 
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
-        verify(listener, times(1)).onAutoFocusEnd(success, point);
+        verify(listener, times(1)).onFocusEnd(success, point);
-        verify(marker, times(1)).onAutoFocusEnd(AutoFocusTrigger.GESTURE, success, point);
+        // Can't mock package protected. verify(camera.mTapGestureLayout, times(1)).onFocusEnd(success);
-
-        // Can't mock package protected. verify(camera.mTapGestureFinder, times(1)).onAutoFocusEnd(success);
     }
 
     @Test
     public void testOrientationCallbacks() {
-        doEndOp(op, true).when(listener).onOrientationChanged(anyInt());
+        completeTask().when(listener).onOrientationChanged(anyInt());
         camera.mCameraCallbacks.onDeviceOrientationChanged(90);
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
         verify(listener, times(1)).onOrientationChanged(anyInt());
     }
 
-    @Test
+    // TODO: test onShutter, here or elsewhere
-    public void testOnShutter() {
-        doEndOp(op, true).when(listener).onPictureShutter();
-        camera.mCameraCallbacks.dispatchOnPictureShutter(true);
-        assertNotNull(op.await(DELAY));
-        verify(listener, times(1)).onPictureShutter();
-    }
 
     @Test
     public void testCameraError() {
         CameraException error = new CameraException(new RuntimeException("Error"));
-        doEndOp(op, true).when(listener).onCameraError(error);
+        completeTask().when(listener).onCameraError(error);
 
         camera.mCameraCallbacks.dispatchError(error);
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
         verify(listener, times(1)).onCameraError(error);
     }
 
+    @Test
+    public void testProcessJpeg() {
+        int[] viewDim = new int[]{ 200, 200 };
+        int[] imageDim = new int[]{ 1000, 1600 };
+
+        // With crop flag: expect a 1:1 ratio.
+        int[] output = testProcessImage(true, true, viewDim, imageDim);
+        LOG.i("testProcessJpeg", output);
+        assertEquals(output[0], 1000);
+        assertEquals(output[1], 1000);
+
+        // Without crop flag: expect original ratio.
+        output = testProcessImage(true, false, viewDim, imageDim);
+        LOG.i("testProcessJpeg", output);
+        assertEquals(output[0], imageDim[0]);
+        assertEquals(output[1], imageDim[1]);
+    }
+
+    @Test
+    public void testProcessYuv() {
+        int[] viewDim = new int[]{ 200, 200 };
+        int[] imageDim = new int[]{ 1000, 1600 };
+
+        // With crop flag: expect a 1:1 ratio.
+        int[] output = testProcessImage(false, true, viewDim, imageDim);
+        LOG.i("testProcessYuv", output);
+        assertEquals(output[0], 1000);
+        assertEquals(output[1], 1000);
+
+        // Without crop flag: expect original ratio.
+        output = testProcessImage(false, false, viewDim, imageDim);
+        LOG.i("testProcessYuv", output);
+        assertEquals(output[0], imageDim[0]);
+        assertEquals(output[1], imageDim[1]);
+    }
+
+    private int[] testProcessImage(boolean jpeg, boolean crop, int[] viewDim, int[] imageDim) {
+        // End our task when onPictureTaken is called. Take note of the result.
+        final Task<byte[]> jpegTask = new Task<>(true);
+        doAnswer(new Answer() {
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                jpegTask.end((byte[]) invocation.getArguments()[0]);
+                return null;
+            }
+        }).when(listener).onPictureTaken(any(byte[].class));
+
+        // Fake our own dimensions.
+        camera.setTop(0);
+        camera.setBottom(viewDim[1]);
+        camera.setLeft(0);
+        camera.setRight(viewDim[0]);
+
+        // Ensure the image will (not) be cropped.
+        camera.setCropOutput(crop);
+        mockPreview.setIsCropping(crop);
+
+        // Create fake JPEG array and trigger the process.
+        if (jpeg) {
+            camera.mCameraCallbacks.processImage(mockJpeg(imageDim[0], imageDim[1]), true, false);
+        } else {
+            camera.mCameraCallbacks.processSnapshot(mockYuv(imageDim[0], imageDim[1]), true, false);
+        }
+
+        // Wait for result and get out dimensions.
+        byte[] result = jpegTask.await(3000);
+        assertNotNull("Image was processed", result);
+        Bitmap bitmap = BitmapFactory.decodeByteArray(result, 0, result.length);
+        return new int[]{ bitmap.getWidth(), bitmap.getHeight() };
+    }
+
     @Test
     public void testProcessFrame() {
         Frame mock = mock(Frame.class);
-        doEndOp(op, true).when(processor).process(mock);
+        completeTask().when(processor).process(mock);
         camera.mCameraCallbacks.dispatchFrame(mock);
 
-        assertNotNull(op.await(DELAY));
+        assertNotNull(task.await(200));
         verify(processor, times(1)).process(mock);
     }
 }

cameraview/src/androidTest/java/com/otaliastudios/cameraview/CropHelperTest.java

@@ -0,0 +1,76 @@
+package com.otaliastudios.cameraview;
+
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Color;
+import android.graphics.Rect;
+import android.graphics.YuvImage;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class CropHelperTest extends BaseTest {
+
+    @Test
+    public void testCropFromYuv() {
+        testCropFromYuv(1600, 1600, AspectRatio.of(16, 9));
+        testCropFromYuv(1600, 1600, AspectRatio.of(9, 16));
+    }
+
+    @Test
+    public void testCropFromJpeg() {
+        testCropFromJpeg(1600, 1600, AspectRatio.of(16, 9));
+        testCropFromJpeg(1600, 1600, AspectRatio.of(9, 16));
+    }
+
+    private void testCropFromYuv(final int w, final int h, final AspectRatio target) {
+        final boolean wider = target.toFloat() > ((float) w / (float) h);
+        byte[] b = CropHelper.cropToJpeg(mockYuv(w, h), target, 100);
+        Bitmap result = BitmapFactory.decodeByteArray(b, 0, b.length);
+
+        // Assert.
+        AspectRatio ratio = AspectRatio.of(result.getWidth(), result.getHeight());
+        assertEquals(target, ratio);
+        if (wider) { // width must match.
+            assertEquals(result.getWidth(), w);
+        } else {
+            assertEquals(result.getHeight(), h);
+        }
+    }
+
+    private void testCropFromJpeg(int w, int h, AspectRatio target) {
+        final boolean wider = target.toFloat() > ((float) w / (float) h);
+        byte[] b = CropHelper.cropToJpeg(mockJpeg(w, h), target, 100);
+        Bitmap result = BitmapFactory.decodeByteArray(b, 0, b.length);
+
+        // Assert.
+        AspectRatio ratio = AspectRatio.of(result.getWidth(), result.getHeight());
+        assertEquals(target, ratio);
+        if (wider) { // width must match.
+            assertEquals(result.getWidth(), w);
+        } else {
+            assertEquals(result.getHeight(), h);
+        }
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/ExtraProperties1Test.java

@@ -0,0 +1,32 @@
+package com.otaliastudios.cameraview;
+
+
+import android.annotation.TargetApi;
+import android.hardware.Camera;
+import android.hardware.camera2.CameraCharacteristics;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+import android.util.SizeF;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+
+import static org.mockito.Mockito.*;
+import static org.junit.Assert.*;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ExtraProperties1Test extends BaseTest {
+
+    @Test
+    public void testConstructor1() {
+        Camera.Parameters params = mock(Camera.Parameters.class);
+        when(params.getVerticalViewAngle()).thenReturn(10f);
+        when(params.getHorizontalViewAngle()).thenReturn(5f);
+        ExtraProperties e = new ExtraProperties(params);
+        assertEquals(e.getVerticalViewingAngle(), 10f, 0f);
+        assertEquals(e.getHorizontalViewingAngle(), 5f, 0f);
+    }
+
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/GestureLayoutTest.java

@@ -0,0 +1,65 @@
+package com.otaliastudios.cameraview;
+
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.support.test.espresso.Espresso;
+import android.support.test.espresso.Root;
+import android.support.test.espresso.ViewAssertion;
+import android.support.test.espresso.ViewInteraction;
+import android.support.test.espresso.assertion.ViewAssertions;
+import android.support.test.espresso.matcher.RootMatchers;
+import android.support.test.espresso.matcher.ViewMatchers;
+import android.support.test.rule.ActivityTestRule;
+import android.view.MotionEvent;
+import android.view.View;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matchers;
+import org.junit.Before;
+import org.junit.Rule;
+
+import static android.support.test.espresso.Espresso.onView;
+import static org.hamcrest.Matchers.any;
+
+@TargetApi(17)
+public abstract class GestureLayoutTest<T extends GestureLayout> extends BaseTest {
+
+    protected abstract T create(Context context);
+
+    @Rule
+    public ActivityTestRule<TestActivity> rule = new ActivityTestRule<>(TestActivity.class);
+
+    protected T layout;
+    protected Task<Gesture> touch;
+
+    @Before
+    public void setUp() {
+        ui(new Runnable() {
+            @Override
+            public void run() {
+                TestActivity a = rule.getActivity();
+                layout = create(a);
+                layout.enable(true);
+                a.inflate(layout);
+
+                touch = new Task<>();
+                layout.setOnTouchListener(new View.OnTouchListener() {
+                    @Override
+                    public boolean onTouch(View view, MotionEvent motionEvent) {
+                        boolean found = layout.onTouchEvent(motionEvent);
+                        if (found) touch.end(layout.getGestureType());
+                        return true;
+                    }
+                });
+            }
+        });
+    }
+
+    protected final ViewInteraction onLayout() {
+        return onView(Matchers.<View>is(layout))
+                .inRoot(RootMatchers.withDecorView(
+                        Matchers.is(rule.getActivity().getWindow().getDecorView())));
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/GridLinesLayoutTest.java

@@ -1,25 +1,18 @@
-package com.otaliastudios.cameraview.internal;
+package com.otaliastudios.cameraview;
 
 
-import com.otaliastudios.cameraview.BaseTest;
+import android.graphics.Canvas;
-import com.otaliastudios.cameraview.TestActivity;
+import android.support.test.filters.MediumTest;
-import com.otaliastudios.cameraview.controls.Grid;
+import android.support.test.rule.ActivityTestRule;
-import com.otaliastudios.cameraview.tools.Op;
+import android.support.test.runner.AndroidJUnit4;
-import com.otaliastudios.cameraview.tools.Retry;
-import com.otaliastudios.cameraview.tools.RetryRule;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.MediumTest;
-import androidx.test.rule.ActivityTestRule;
 
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
+import static org.junit.Assert.*;
 
 @RunWith(AndroidJUnit4.class)
 @MediumTest
@@ -28,68 +21,54 @@ public class GridLinesLayoutTest extends BaseTest {
     @Rule
     public ActivityTestRule<TestActivity> rule = new ActivityTestRule<>(TestActivity.class);
 
-    @Rule
-    public RetryRule retryRule = new RetryRule(3);
-
     private GridLinesLayout layout;
 
-    @NonNull
-    private Op<Integer> getDrawOp() {
-        final Op<Integer> op = new Op<>();
-        layout.callback = mock(GridLinesLayout.DrawCallback.class);
-        doEndOp(op, 0).when(layout.callback).onDraw(anyInt());
-        return op;
-    }
-
     @Before
     public void setUp() {
-        uiSync(new Runnable() {
+        ui(new Runnable() {
             @Override
             public void run() {
                 TestActivity a = rule.getActivity();
                 layout = new GridLinesLayout(a);
                 layout.setGridMode(Grid.OFF);
-                Op<Integer> op = getDrawOp();
+                layout.drawTask.listen();
                 a.getContentView().addView(layout);
-                op.await(1000);
             }
         });
+        // Wait for first draw.
+        layout.drawTask.await(1000);
     }
 
     private int setGridAndWait(Grid value) {
+        layout.drawTask.listen();
         layout.setGridMode(value);
-        Op<Integer> op = getDrawOp();
+        Integer result = layout.drawTask.await(1000);
-        Integer result = op.await(1000);
         assertNotNull(result);
         return result;
     }
 
-    @Retry
     @Test
     public void testOff() {
         int linesDrawn = setGridAndWait(Grid.OFF);
-        assertEquals(0, linesDrawn);
+        assertEquals(linesDrawn, 0);
     }
 
-    @Retry
     @Test
     public void test3x3() {
         int linesDrawn = setGridAndWait(Grid.DRAW_3X3);
-        assertEquals(2, linesDrawn);
+        assertEquals(linesDrawn, 2);
     }
 
-    @Retry
     @Test
     public void testPhi() {
         int linesDrawn = setGridAndWait(Grid.DRAW_PHI);
-        assertEquals(2, linesDrawn);
+        assertEquals(linesDrawn, 2);
     }
 
-    @Retry
     @Test
     public void test4x4() {
         int linesDrawn = setGridAndWait(Grid.DRAW_4X4);
-        assertEquals(3, linesDrawn);
+        assertEquals(linesDrawn, 3);
     }
 
 }

cameraview/src/androidTest/java/com/otaliastudios/cameraview/IntegrationTest.java

@@ -0,0 +1,644 @@
+package com.otaliastudios.cameraview;
+
+
+import android.graphics.Bitmap;
+import android.graphics.PointF;
+import android.hardware.Camera;
+import android.os.Build;
+import android.os.Handler;
+import android.support.test.filters.MediumTest;
+import android.support.test.rule.ActivityTestRule;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+
+
+/**
+ * These tests work great on real devices, and are the only way to test actual CameraController
+ * implementation - we really need to open the camera device.
+ * Unfortunately they fail unreliably on emulated devices, due to some bug with the
+ * emulated camera controller. Waiting for it to be fixed.
+ */
+@RunWith(AndroidJUnit4.class)
+@MediumTest
+@Ignore
+public class IntegrationTest extends BaseTest {
+
+    @Rule
+    public ActivityTestRule<TestActivity> rule = new ActivityTestRule<>(TestActivity.class);
+
+    private CameraView camera;
+    private Camera1 controller;
+    private CameraListener listener;
+    private Task<Throwable> uiExceptionTask;
+
+    @BeforeClass
+    public static void grant() {
+        grantPermissions();
+    }
+
+    @Before
+    public void setUp() {
+        WorkerHandler.destroy();
+
+        ui(new Runnable() {
+            @Override
+            public void run() {
+                camera = new CameraView(rule.getActivity()) {
+                    @Override
+                    protected CameraController instantiateCameraController(CameraCallbacks callbacks) {
+                        controller = new Camera1(callbacks);
+                        return controller;
+                    }
+                };
+
+                listener = mock(CameraListener.class);
+                camera.addCameraListener(listener);
+                rule.getActivity().inflate(camera);
+            }
+        });
+
+        // Ensure that controller exceptions are thrown on this thread (not on the UI thread).
+        uiExceptionTask = new Task<>(true);
+        WorkerHandler crashThread = WorkerHandler.get("CrashThread");
+        crashThread.getThread().setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+                uiExceptionTask.end(e);
+            }
+        });
+        controller.mCrashHandler = crashThread.get();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        camera.stopCapturingVideo();
+        camera.destroy();
+        WorkerHandler.destroy();
+    }
+
+    private void waitForUiException() throws Throwable {
+        Throwable throwable = uiExceptionTask.await(2500);
+        if (throwable != null) throw throwable;
+    }
+
+    private CameraOptions waitForOpen(boolean expectSuccess) {
+        camera.start();
+        final Task<CameraOptions> open = new Task<>(true);
+        doEndTask(open, 0).when(listener).onCameraOpened(any(CameraOptions.class));
+        CameraOptions result = open.await(4000);
+        if (expectSuccess) {
+            assertNotNull("Can open", result);
+        } else {
+            assertNull("Should not open", result);
+        }
+        return result;
+    }
+
+    private void waitForClose(boolean expectSuccess) {
+        camera.stop();
+        final Task<Boolean> close = new Task<>(true);
+        doEndTask(close, true).when(listener).onCameraClosed();
+        Boolean result = close.await(4000);
+        if (expectSuccess) {
+            assertNotNull("Can close", result);
+        } else {
+            assertNull("Should not close", result);
+        }
+    }
+
+    private void waitForVideoEnd(boolean expectSuccess) {
+        final Task<Boolean> video = new Task<>(true);
+        doEndTask(video, true).when(listener).onVideoTaken(any(File.class));
+        Boolean result = video.await(8000);
+        if (expectSuccess) {
+            assertNotNull("Should end video", result);
+        } else {
+            assertNull("Should not end video", result);
+        }
+    }
+
+    private byte[] waitForPicture(boolean expectSuccess) {
+        final Task<byte[]> pic = new Task<>(true);
+        doEndTask(pic, 0).when(listener).onPictureTaken(any(byte[].class));
+        byte[] result = pic.await(5000);
+        if (expectSuccess) {
+            assertNotNull("Can take picture", result);
+        } else {
+            assertNull("Should not take picture", result);
+        }
+        return result;
+    }
+
+    private void waitForVideoStart() {
+        controller.mStartVideoTask.listen();
+        camera.startCapturingVideo(null);
+        controller.mStartVideoTask.await(400);
+    }
+
+    private void waitForVideoQuality(VideoQuality quality) {
+        controller.mVideoQualityTask.listen();
+        camera.setVideoQuality(quality);
+        controller.mVideoQualityTask.await(400);
+    }
+
+    //region test open/close
+
+    @Test
+    public void testOpenClose() throws Exception {
+        // Starting and stopping are hard to get since they happen on another thread.
+        assertEquals(controller.getState(), CameraController.STATE_STOPPED);
+
+        waitForOpen(true);
+        assertEquals(controller.getState(), CameraController.STATE_STARTED);
+
+        waitForClose(true);
+        assertEquals(controller.getState(), CameraController.STATE_STOPPED);
+    }
+
+    @Test
+    public void testOpenTwice() {
+        waitForOpen(true);
+        waitForOpen(false);
+    }
+
+    @Test
+    public void testCloseTwice() {
+        waitForClose(false);
+    }
+
+    @Test
+    // This works great on the device but crashes often on the emulator.
+    // There must be something wrong with the emulated camera...
+    // Like stopPreview() and release() are not really sync calls?
+    public void testConcurrentCalls() throws Exception {
+        final CountDownLatch latch = new CountDownLatch(4);
+        doCountDown(latch).when(listener).onCameraOpened(any(CameraOptions.class));
+        doCountDown(latch).when(listener).onCameraClosed();
+
+        camera.start();
+        camera.stop();
+        camera.start();
+        camera.stop();
+
+        boolean did = latch.await(10, TimeUnit.SECONDS);
+        assertTrue("Handles concurrent calls to start & stop, " + latch.getCount(), did);
+    }
+
+    @Test
+    public void testStartInitializesOptions() {
+        assertNull(camera.getCameraOptions());
+        assertNull(camera.getExtraProperties());
+        waitForOpen(true);
+        assertNotNull(camera.getCameraOptions());
+        assertNotNull(camera.getExtraProperties());
+    }
+
+    //endregion
+
+    //region test Facing/SessionType
+    // Test things that should reset the camera.
+
+    @Test
+    public void testSetFacing() throws Exception {
+        CameraOptions o = waitForOpen(true);
+        int size = o.getSupportedFacing().size();
+        if (size > 1) {
+            // set facing should call stop and start again.
+            final CountDownLatch latch = new CountDownLatch(2);
+            doCountDown(latch).when(listener).onCameraOpened(any(CameraOptions.class));
+            doCountDown(latch).when(listener).onCameraClosed();
+
+            camera.toggleFacing();
+
+            boolean did = latch.await(2, TimeUnit.SECONDS);
+            assertTrue("Handles setFacing while active", did);
+        }
+    }
+
+    @Test
+    public void testSetSessionType() throws Exception {
+        camera.setSessionType(SessionType.PICTURE);
+        waitForOpen(true);
+
+        // set session type should call stop and start again.
+        final CountDownLatch latch = new CountDownLatch(2);
+        doCountDown(latch).when(listener).onCameraOpened(any(CameraOptions.class));
+        doCountDown(latch).when(listener).onCameraClosed();
+
+        camera.setSessionType(SessionType.VIDEO);
+
+        boolean did = latch.await(2, TimeUnit.SECONDS);
+        assertTrue("Handles setSessionType while active", did);
+        assertEquals(camera.getSessionType(), SessionType.VIDEO);
+    }
+
+    //endregion
+
+    //region test Set Parameters
+    // When camera is open, parameters will be set only if supported.
+
+    @Test
+    public void testSetZoom() {
+        CameraOptions options = waitForOpen(true);
+
+        controller.mZoomTask.listen();
+        float oldValue = camera.getZoom();
+        float newValue = 0.65f;
+        camera.setZoom(newValue);
+        controller.mZoomTask.await(500);
+
+        if (options.isZoomSupported()) {
+            assertEquals(newValue, camera.getZoom(), 0f);
+        } else {
+            assertEquals(oldValue, camera.getZoom(), 0f);
+        }
+    }
+
+    @Test
+    public void testSetExposureCorrection() {
+        CameraOptions options = waitForOpen(true);
+
+        controller.mExposureCorrectionTask.listen();
+        float oldValue = camera.getExposureCorrection();
+        float newValue = options.getExposureCorrectionMaxValue();
+        camera.setExposureCorrection(newValue);
+        controller.mExposureCorrectionTask.await(300);
+
+        if (options.isExposureCorrectionSupported()) {
+            assertEquals(newValue, camera.getExposureCorrection(), 0f);
+        } else {
+            assertEquals(oldValue, camera.getExposureCorrection(), 0f);
+        }
+    }
+
+    @Test
+    public void testSetFlash() {
+        CameraOptions options = waitForOpen(true);
+        Flash[] values = Flash.values();
+        Flash oldValue = camera.getFlash();
+        for (Flash value : values) {
+            controller.mFlashTask.listen();
+            camera.setFlash(value);
+            controller.mFlashTask.await(300);
+            if (options.supports(value)) {
+                assertEquals(camera.getFlash(), value);
+                oldValue = value;
+            } else {
+                assertEquals(camera.getFlash(), oldValue);
+            }
+        }
+    }
+
+    @Test
+    public void testSetWhiteBalance() {
+        CameraOptions options = waitForOpen(true);
+        WhiteBalance[] values = WhiteBalance.values();
+        WhiteBalance oldValue = camera.getWhiteBalance();
+        for (WhiteBalance value : values) {
+            controller.mWhiteBalanceTask.listen();
+            camera.setWhiteBalance(value);
+            controller.mWhiteBalanceTask.await(300);
+            if (options.supports(value)) {
+                assertEquals(camera.getWhiteBalance(), value);
+                oldValue = value;
+            } else {
+                assertEquals(camera.getWhiteBalance(), oldValue);
+            }
+        }
+    }
+
+    @Test
+    public void testSetHdr() {
+        CameraOptions options = waitForOpen(true);
+        Hdr[] values = Hdr.values();
+        Hdr oldValue = camera.getHdr();
+        for (Hdr value : values) {
+            controller.mHdrTask.listen();
+            camera.setHdr(value);
+            controller.mHdrTask.await(300);
+            if (options.supports(value)) {
+                assertEquals(camera.getHdr(), value);
+                oldValue = value;
+            } else {
+                assertEquals(camera.getHdr(), oldValue);
+            }
+        }
+    }
+
+    @Test
+    public void testSetAudio() {
+        // TODO: when permissions are managed, check that Audio.ON triggers the audio permission
+        waitForOpen(true);
+        Audio[] values = Audio.values();
+        for (Audio value : values) {
+            camera.setAudio(value);
+            assertEquals(camera.getAudio(), value);
+        }
+    }
+
+    @Test
+    public void testSetLocation() {
+        waitForOpen(true);
+        controller.mLocationTask.listen();
+        camera.setLocation(10d, 2d);
+        controller.mLocationTask.await(300);
+        assertNotNull(camera.getLocation());
+        assertEquals(camera.getLocation().getLatitude(), 10d, 0d);
+        assertEquals(camera.getLocation().getLongitude(), 2d, 0d);
+        // This also ensures there are no crashes when attaching it to camera parameters.
+    }
+
+    @Test
+    public void testSetPlaySounds() {
+        controller.mPlaySoundsTask.listen();
+        boolean oldValue = camera.getPlaySounds();
+        boolean newValue = !oldValue;
+        camera.setPlaySounds(newValue);
+        controller.mPlaySoundsTask.await(300);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            Camera.CameraInfo info = new Camera.CameraInfo();
+            Camera.getCameraInfo(camera.getCameraId(), info);
+            if (info.canDisableShutterSound) {
+                assertEquals(newValue, camera.getPlaySounds());
+            }
+        } else {
+            assertEquals(oldValue, camera.getPlaySounds());
+        }
+    }
+
+    //endregion
+
+    //region testSetVideoQuality
+    // This can be tricky because can trigger layout changes.
+
+    @Test(expected = RuntimeException.class)
+    public void testSetVideoQuality_whileRecording() throws Throwable {
+        // Can't run on Travis, MediaRecorder not supported.
+        // Error while starting MediaRecorder. java.lang.RuntimeException: start failed.
+        camera.setSessionType(SessionType.VIDEO);
+        waitForVideoQuality(VideoQuality.HIGHEST);
+        waitForOpen(true);
+        waitForVideoStart();
+        waitForVideoQuality(VideoQuality.LOWEST);
+        waitForUiException();
+    }
+
+    @Test
+    public void testSetVideoQuality_whileInPictureSessionType() {
+        camera.setSessionType(SessionType.PICTURE);
+        waitForVideoQuality(VideoQuality.HIGHEST);
+        waitForOpen(true);
+        waitForVideoQuality(VideoQuality.LOWEST);
+        assertEquals(camera.getVideoQuality(), VideoQuality.LOWEST);
+    }
+
+    @Test
+    public void testSetVideoQuality_whileNotStarted() {
+        waitForVideoQuality(VideoQuality.HIGHEST);
+        assertEquals(camera.getVideoQuality(), VideoQuality.HIGHEST);
+
+        waitForVideoQuality(VideoQuality.LOWEST);
+        assertEquals(camera.getVideoQuality(), VideoQuality.LOWEST);
+    }
+
+    @Test
+    public void testSetVideoQuality_shouldRecompute() {
+        // TODO:
+        // If video quality changes bring to a new capture size,
+        // this might bring to a new aspect ratio,
+        // which might bring to a new preview size. No idea how to test.
+        assertTrue(true);
+    }
+
+    //endregion
+
+    //region test startVideo
+
+    @Test(expected = RuntimeException.class)
+    public void testStartVideo_whileInPictureMode() throws Throwable {
+        // Fails on Travis. Some emulators can't deal with MediaRecorder
+        // Error while starting MediaRecorder. java.lang.RuntimeException: start failed.
+        // as documented. This works locally though.
+        camera.setSessionType(SessionType.PICTURE);
+        waitForOpen(true);
+        waitForVideoStart();
+        waitForUiException();
+    }
+
+    @Test
+    public void testStartEndVideo() {
+        // Fails on Travis. Some emulators can't deal with MediaRecorder,
+        // Error while starting MediaRecorder. java.lang.RuntimeException: start failed.
+        // as documented. This works locally though.
+        camera.setSessionType(SessionType.VIDEO);
+        waitForOpen(true);
+        camera.startCapturingVideo(null, 4000);
+        waitForVideoEnd(true);
+    }
+
+    @Test
+    public void testEndVideo_withoutStarting() {
+        camera.setSessionType(SessionType.VIDEO);
+        waitForOpen(true);
+        camera.stopCapturingVideo();
+        waitForVideoEnd(false);
+    }
+
+    @Test
+    public void testEndVideo_withMaxSize() {
+        camera.setSessionType(SessionType.VIDEO);
+        camera.setVideoMaxSize(500*1000); // 0.5 mb
+        waitForOpen(true);
+        waitForVideoStart();
+        waitForVideoEnd(true);
+    }
+
+    @Test
+    public void testEndVideo_withMaxDuration() {
+        camera.setSessionType(SessionType.VIDEO);
+        camera.setVideoMaxDuration(4000);
+        waitForOpen(true);
+        waitForVideoStart();
+        waitForVideoEnd(true);
+    }
+
+    //endregion
+
+    //region startAutoFocus
+    // TODO: won't test onStopAutoFocus because that is not guaranteed to be called
+
+    @Test
+    public void testStartAutoFocus() {
+        CameraOptions o = waitForOpen(true);
+
+        final Task<PointF> focus = new Task<>(true);
+        doEndTask(focus, 0).when(listener).onFocusStart(any(PointF.class));
+
+        camera.startAutoFocus(1, 1);
+        PointF point = focus.await(300);
+        if (o.isAutoFocusSupported()) {
+            assertNotNull(point);
+            assertEquals(point, new PointF(1, 1));
+        } else {
+            assertNull(point);
+        }
+    }
+
+    //endregion
+
+    //region capture
+
+    @Test
+    public void testCapturePicture_beforeStarted() {
+        camera.capturePicture();
+        waitForPicture(false);
+    }
+
+    @Test
+    public void testCapturePicture_concurrentCalls() throws Exception {
+        // Second take should fail.
+        waitForOpen(true);
+
+        CountDownLatch latch = new CountDownLatch(2);
+        doCountDown(latch).when(listener).onPictureTaken(any(byte[].class));
+
+        camera.capturePicture();
+        camera.capturePicture();
+        boolean did = latch.await(4, TimeUnit.SECONDS);
+        assertFalse(did);
+        assertEquals(latch.getCount(), 1);
+    }
+
+    @Test
+    public void testCapturePicture_size() throws Exception {
+        camera.setCropOutput(false);
+        waitForOpen(true);
+
+        Size size = camera.getPictureSize();
+        camera.capturePicture();
+        byte[] jpeg = waitForPicture(true);
+        Bitmap b = CameraUtils.decodeBitmap(jpeg, Integer.MAX_VALUE, Integer.MAX_VALUE);
+        // Result can actually have swapped dimensions
+        // Which one, depends on factors including device physical orientation
+        assertTrue(b.getWidth() == size.getHeight() || b.getWidth() == size.getWidth());
+        assertTrue(b.getHeight() == size.getHeight() || b.getHeight() == size.getWidth());
+    }
+
+    @Test
+    public void testCaptureSnapshot_beforeStarted() {
+        camera.captureSnapshot();
+        waitForPicture(false);
+    }
+
+    @Test
+    public void testCaptureSnapshot_concurrentCalls() throws Exception {
+        // Second take should fail.
+        waitForOpen(true);
+
+        CountDownLatch latch = new CountDownLatch(2);
+        doCountDown(latch).when(listener).onPictureTaken(any(byte[].class));
+
+        camera.captureSnapshot();
+        camera.captureSnapshot();
+        boolean did = latch.await(6, TimeUnit.SECONDS);
+        assertFalse(did);
+        assertEquals(1, latch.getCount());
+    }
+
+    @Test
+    public void testCaptureSnapshot_size() throws Exception {
+        camera.setCropOutput(false);
+        waitForOpen(true);
+
+        Size size = camera.getPreviewSize();
+        camera.captureSnapshot();
+        byte[] jpeg = waitForPicture(true);
+        Bitmap b = CameraUtils.decodeBitmap(jpeg, Integer.MAX_VALUE, Integer.MAX_VALUE);
+        // Result can actually have swapped dimensions
+        // Which one, depends on factors including device physical orientation
+        assertTrue(b.getWidth() == size.getHeight() || b.getWidth() == size.getWidth());
+        assertTrue(b.getHeight() == size.getHeight() || b.getHeight() == size.getWidth());
+    }
+
+    //endregion
+
+    //region Frame Processing
+
+    private void assert30Frames(FrameProcessor mock) throws Exception {
+        // Expect 30 frames
+        CountDownLatch latch = new CountDownLatch(30);
+        doCountDown(latch).when(mock).process(any(Frame.class));
+        boolean did = latch.await(4, TimeUnit.SECONDS);
+        assertTrue(did);
+    }
+
+    @Test
+    public void testFrameProcessing_simple() throws Exception {
+        FrameProcessor processor = mock(FrameProcessor.class);
+        camera.addFrameProcessor(processor);
+        waitForOpen(true);
+
+        assert30Frames(processor);
+    }
+
+    @Test
+    public void testFrameProcessing_afterSnapshot() throws Exception {
+        FrameProcessor processor = mock(FrameProcessor.class);
+        camera.addFrameProcessor(processor);
+        waitForOpen(true);
+
+        // In Camera1, snapshots will clear the preview callback
+        // Ensure we restore correctly
+        camera.captureSnapshot();
+        waitForPicture(true);
+
+        assert30Frames(processor);
+    }
+
+    @Test
+    public void testFrameProcessing_afterRestart() throws Exception {
+        FrameProcessor processor = mock(FrameProcessor.class);
+        camera.addFrameProcessor(processor);
+        waitForOpen(true);
+        waitForClose(true);
+        waitForOpen(true);
+
+        assert30Frames(processor);
+    }
+
+
+    @Test
+    public void testFrameProcessing_afterVideo() throws Exception {
+        FrameProcessor processor = mock(FrameProcessor.class);
+        camera.addFrameProcessor(processor);
+        camera.setSessionType(SessionType.VIDEO);
+        waitForOpen(true);
+
+        camera.startCapturingVideo(null, 2000);
+        waitForVideoEnd(true);
+
+        assert30Frames(processor);
+    }
+
+    //endregion
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/Mapper1Test.java

@@ -0,0 +1,60 @@
+package com.otaliastudios.cameraview;
+
+
+import android.hardware.Camera;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class Mapper1Test extends BaseTest {
+
+    private Mapper mapper = new Mapper.Mapper1();
+
+    @Test
+    public void testMap() {
+        assertEquals(mapper.map(Flash.OFF), Camera.Parameters.FLASH_MODE_OFF);
+        assertEquals(mapper.map(Flash.ON), Camera.Parameters.FLASH_MODE_ON);
+        assertEquals(mapper.map(Flash.AUTO), Camera.Parameters.FLASH_MODE_AUTO);
+        assertEquals(mapper.map(Flash.TORCH), Camera.Parameters.FLASH_MODE_TORCH);
+
+        assertEquals(mapper.map(Facing.BACK), Camera.CameraInfo.CAMERA_FACING_BACK);
+        assertEquals(mapper.map(Facing.FRONT), Camera.CameraInfo.CAMERA_FACING_FRONT);
+
+        assertEquals(mapper.map(Hdr.OFF), Camera.Parameters.SCENE_MODE_AUTO);
+        assertEquals(mapper.map(Hdr.ON), Camera.Parameters.SCENE_MODE_HDR);
+
+        assertEquals(mapper.map(WhiteBalance.AUTO), Camera.Parameters.WHITE_BALANCE_AUTO);
+        assertEquals(mapper.map(WhiteBalance.DAYLIGHT), Camera.Parameters.WHITE_BALANCE_DAYLIGHT);
+        assertEquals(mapper.map(WhiteBalance.CLOUDY), Camera.Parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT);
+        assertEquals(mapper.map(WhiteBalance.INCANDESCENT), Camera.Parameters.WHITE_BALANCE_INCANDESCENT);
+        assertEquals(mapper.map(WhiteBalance.FLUORESCENT), Camera.Parameters.WHITE_BALANCE_FLUORESCENT);
+    }
+
+
+    @Test
+    public void testUnmap() {
+        assertEquals(Flash.OFF, mapper.unmapFlash(Camera.Parameters.FLASH_MODE_OFF));
+        assertEquals(Flash.ON, mapper.unmapFlash(Camera.Parameters.FLASH_MODE_ON));
+        assertEquals(Flash.AUTO, mapper.unmapFlash(Camera.Parameters.FLASH_MODE_AUTO));
+        assertEquals(Flash.TORCH, mapper.unmapFlash(Camera.Parameters.FLASH_MODE_TORCH));
+
+        assertEquals(Facing.BACK, mapper.unmapFacing(Camera.CameraInfo.CAMERA_FACING_BACK));
+        assertEquals(Facing.FRONT, mapper.unmapFacing(Camera.CameraInfo.CAMERA_FACING_FRONT));
+
+        assertEquals(Hdr.OFF, mapper.unmapHdr(Camera.Parameters.SCENE_MODE_AUTO));
+        assertEquals(Hdr.ON, mapper.unmapHdr(Camera.Parameters.SCENE_MODE_HDR));
+
+        assertEquals(WhiteBalance.AUTO, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_AUTO));
+        assertEquals(WhiteBalance.DAYLIGHT, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_DAYLIGHT));
+        assertEquals(WhiteBalance.CLOUDY, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT));
+        assertEquals(WhiteBalance.INCANDESCENT, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_INCANDESCENT));
+        assertEquals(WhiteBalance.FLUORESCENT, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_FLUORESCENT));
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/MapperTest.java

@@ -0,0 +1,36 @@
+package com.otaliastudios.cameraview;
+
+
+import android.hardware.Camera;
+import android.media.MediaRecorder;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.assertEquals;
+
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class MapperTest extends BaseTest {
+
+    private Mapper mapper = new Mapper() {
+        <T> T map(Flash flash) { return null; }
+        <T> T map(Facing facing) { return null; }
+        <T> T map(WhiteBalance whiteBalance) { return null; }
+        <T> T map(Hdr hdr) { return null; }
+        <T> Flash unmapFlash(T cameraConstant) { return null; }
+        <T> Facing unmapFacing(T cameraConstant) { return null; }
+        <T> WhiteBalance unmapWhiteBalance(T cameraConstant) { return null; }
+        <T> Hdr unmapHdr(T cameraConstant) { return null; }
+    };
+
+    @Test
+    public void testMap() {
+        assertEquals(mapper.map(VideoCodec.DEVICE_DEFAULT), MediaRecorder.VideoEncoder.DEFAULT);
+        assertEquals(mapper.map(VideoCodec.H_263), MediaRecorder.VideoEncoder.H263);
+        assertEquals(mapper.map(VideoCodec.H_264), MediaRecorder.VideoEncoder.H264);
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/MockCameraController.java

@@ -0,0 +1,132 @@
+package com.otaliastudios.cameraview;
+
+
+import android.graphics.PointF;
+import android.location.Location;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+
+import java.io.File;
+
+public class MockCameraController extends CameraController {
+
+    boolean mPictureCaptured;
+    boolean mFocusStarted;
+    boolean mZoomChanged;
+    boolean mExposureCorrectionChanged;
+
+    MockCameraController(CameraView.CameraCallbacks callback) {
+        super(callback);
+    }
+
+    void setMockCameraOptions(CameraOptions options) {
+        mCameraOptions = options;
+    }
+
+    void setMockPreviewSize(Size size) {
+        mPreviewSize = size;
+    }
+
+    void mockStarted(boolean started) {
+        mState = started ? STATE_STARTED : STATE_STOPPED;
+    }
+
+    @Override
+    void onStart() {
+    }
+
+    @Override
+    void onStop() {
+    }
+
+    @Override
+    void setZoom(float zoom, PointF[] points, boolean notify) {
+        mZoomValue = zoom;
+        mZoomChanged = true;
+    }
+
+    @Override
+    void setExposureCorrection(float EVvalue, float[] bounds, PointF[] points, boolean notify) {
+        mExposureCorrectionValue = EVvalue;
+        mExposureCorrectionChanged = true;
+    }
+
+    @Override
+    void setFacing(Facing facing) {
+        mFacing = facing;
+    }
+
+    @Override
+    void setFlash(Flash flash) {
+        mFlash = flash;
+    }
+
+    @Override
+    void setWhiteBalance(WhiteBalance whiteBalance) {
+        mWhiteBalance = whiteBalance;
+    }
+
+    @Override
+    void setVideoQuality(VideoQuality videoQuality) {
+        mVideoQuality = videoQuality;
+    }
+
+    @Override
+    void setSessionType(SessionType sessionType) {
+        mSessionType = sessionType;
+    }
+
+    @Override
+    void setHdr(Hdr hdr) {
+        mHdr = hdr;
+    }
+
+    @Override
+    void setAudio(Audio audio) {
+        mAudio = audio;
+    }
+
+    @Override
+    void setLocation(Location location) {
+        mLocation = location;
+    }
+
+    @Override
+    void capturePicture() {
+        mPictureCaptured = true;
+    }
+
+    @Override
+    void captureSnapshot() {
+    }
+
+    @Override
+    void startVideo(@NonNull File file) {
+    }
+
+    @Override
+    void endVideo() {
+    }
+
+    @Override
+    void startAutoFocus(@Nullable Gesture gesture, PointF point) {
+        mFocusStarted = true;
+    }
+
+    @Override
+    public void onSurfaceChanged() {
+    }
+
+    @Override
+    public void onSurfaceAvailable() {
+    }
+
+    @Override
+    public void onBufferAvailable(byte[] buffer) {
+    }
+
+    @Override
+    void setPlaySounds(boolean playSounds) {
+
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/MockCameraPreview.java

@@ -0,0 +1,48 @@
+package com.otaliastudios.cameraview;
+
+
+import android.content.Context;
+import android.support.annotation.NonNull;
+import android.view.Surface;
+import android.view.View;
+import android.view.ViewGroup;
+
+public class MockCameraPreview extends CameraPreview<View, Void> {
+
+    MockCameraPreview(Context context, ViewGroup parent) {
+        super(context, parent, null);
+    }
+
+    private boolean mCropping = false;
+
+    public void setIsCropping(boolean crop) {
+        mCropping = crop;
+    }
+
+    @Override
+    boolean isCropping() {
+        return mCropping;
+    }
+
+    @NonNull
+    @Override
+    protected View onCreateView(Context context, ViewGroup parent) {
+        return new View(context);
+    }
+
+    @Override
+    Surface getSurface() {
+        return null;
+    }
+
+    @Override
+    Class<Void> getOutputClass() {
+        return null;
+    }
+
+    @Override
+    Void getOutput() {
+        return null;
+    }
+
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/OrientationHelperTest.java

@@ -0,0 +1,99 @@
+package com.otaliastudios.cameraview;
+
+
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+import android.view.OrientationEventListener;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class OrientationHelperTest extends BaseTest {
+
+    private OrientationHelper helper;
+    private OrientationHelper.Callback callback;
+
+    @Before
+    public void setUp() {
+        ui(new Runnable() {
+            @Override
+            public void run() {
+                callback = mock(OrientationHelper.Callback.class);
+                helper = new OrientationHelper(context(), callback);
+            }
+        });
+    }
+
+    @After
+    public void tearDown() {
+        callback = null;
+        helper = null;
+    }
+
+    @Test
+    public void testEnable() {
+        assertNotNull(helper.mListener);
+        assertEquals(helper.getDisplayOffset(), -1);
+        assertEquals(helper.getDeviceOrientation(), -1);
+
+        helper.enable(context());
+        assertNotNull(helper.mListener);
+        assertNotEquals(helper.getDisplayOffset(), -1); // Don't know about device orientation.
+
+        // Ensure nothing bad if called twice.
+        helper.enable(context());
+        assertNotNull(helper.mListener);
+        assertNotEquals(helper.getDisplayOffset(), -1);
+
+        helper.disable();
+        assertNotNull(helper.mListener);
+        assertEquals(helper.getDisplayOffset(), -1);
+        assertEquals(helper.getDeviceOrientation(), -1);
+    }
+
+    @Test
+    public void testRotation() {
+
+        // Sometimes (on some APIs) the helper will trigger an update to 0
+        // right after enabling. But that's fine for us, times(1) will be OK either way.
+        helper.enable(context());
+        helper.mListener.onOrientationChanged(OrientationEventListener.ORIENTATION_UNKNOWN);
+        assertEquals(helper.getDeviceOrientation(), 0);
+        helper.mListener.onOrientationChanged(10);
+        assertEquals(helper.getDeviceOrientation(), 0);
+        helper.mListener.onOrientationChanged(-10);
+        assertEquals(helper.getDeviceOrientation(), 0);
+        helper.mListener.onOrientationChanged(44);
+        assertEquals(helper.getDeviceOrientation(), 0);
+        helper.mListener.onOrientationChanged(360);
+        assertEquals(helper.getDeviceOrientation(), 0);
+
+        // Callback called just once.
+        verify(callback, times(1)).onDeviceOrientationChanged(0);
+
+        helper.mListener.onOrientationChanged(90);
+        helper.mListener.onOrientationChanged(91);
+        assertEquals(helper.getDeviceOrientation(), 90);
+        verify(callback, times(1)).onDeviceOrientationChanged(90);
+
+        helper.mListener.onOrientationChanged(180);
+        assertEquals(helper.getDeviceOrientation(), 180);
+        verify(callback, times(1)).onDeviceOrientationChanged(180);
+
+        helper.mListener.onOrientationChanged(270);
+        assertEquals(helper.getDeviceOrientation(), 270);
+        verify(callback, times(1)).onDeviceOrientationChanged(270);
+
+        // It is still 270 after ORIENTATION_UNKNOWN
+        helper.mListener.onOrientationChanged(OrientationEventListener.ORIENTATION_UNKNOWN);
+        assertEquals(helper.getDeviceOrientation(), 270);
+        verify(callback, times(1)).onDeviceOrientationChanged(270);
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/PictureResultTest.java

@@ -1,55 +0,0 @@
-package com.otaliastudios.cameraview;
-
-
-import android.location.Location;
-
-import com.otaliastudios.cameraview.controls.Facing;
-import com.otaliastudios.cameraview.controls.PictureFormat;
-import com.otaliastudios.cameraview.size.Size;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mockito;
-
-import static org.junit.Assert.assertEquals;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class PictureResultTest extends BaseTest {
-
-    private PictureResult.Stub stub = new PictureResult.Stub();
-
-    @Test
-    public void testResult() {
-        PictureFormat format = PictureFormat.JPEG;
-        int rotation = 90;
-        Size size = new Size(20, 120);
-        byte[] jpeg = new byte[]{2, 4, 1, 5, 2};
-        Location location = Mockito.mock(Location.class);
-        boolean isSnapshot = true;
-        Facing facing = Facing.FRONT;
-
-        stub.format = format;
-        stub.rotation = rotation;
-        stub.size = size;
-        stub.data = jpeg;
-        stub.location = location;
-        stub.facing = facing;
-        //noinspection ConstantConditions
-        stub.isSnapshot = isSnapshot;
-
-        PictureResult result = new PictureResult(stub);
-        assertEquals(result.getFormat(), format);
-        assertEquals(result.getRotation(), rotation);
-        assertEquals(result.getSize(), size);
-        assertEquals(result.getData(), jpeg);
-        assertEquals(result.getLocation(), location);
-        //noinspection ConstantConditions
-        assertEquals(result.isSnapshot(), isSnapshot);
-        assertEquals(result.getFacing(), facing);
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/PinchGestureLayoutTest.java

@@ -0,0 +1,66 @@
+package com.otaliastudios.cameraview;
+
+
+import android.content.Context;
+import android.support.test.espresso.ViewAction;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static android.support.test.espresso.matcher.ViewMatchers.withId;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class PinchGestureLayoutTest extends GestureLayoutTest<PinchGestureLayout> {
+
+    @Override
+    protected PinchGestureLayout create(Context context) {
+        return new PinchGestureLayout(context);
+    }
+
+    @Test
+    public void testDefaults() {
+        assertEquals(layout.getGestureType(), Gesture.PINCH);
+        assertEquals(layout.getPoints().length, 2);
+        assertEquals(layout.getPoints()[0].x, 0, 0);
+        assertEquals(layout.getPoints()[0].y, 0, 0);
+        assertEquals(layout.getPoints()[1].x, 0, 0);
+        assertEquals(layout.getPoints()[1].y, 0, 0);
+    }
+
+    // TODO: test pinch open
+    // TODO: test pinch close
+    // TODO: test pinch disabled
+
+    // Possible approach: mimic pinch gesture and let espresso test.
+    // Too lazy to do this now, but it's possible.
+    // https://stackoverflow.com/questions/11523423/how-to-generate-zoom-pinch-gesture-for-testing-for-android
+
+    public abstract class PinchViewAction implements ViewAction {
+    }
+
+    private void testPinch(ViewAction action, boolean increasing) {
+        touch.listen();
+        touch.start();
+        onLayout().perform(action);
+        Gesture found = touch.await(10000);
+        assertNotNull(found);
+
+        // How will this move  our parameter?
+        float curr = 0.5f, min = 0f, max = 1f;
+        float newValue = layout.scaleValue(curr, min, max);
+        if (increasing) {
+            assertTrue(newValue > curr);
+            assertTrue(newValue <= max);
+        } else {
+            assertTrue(newValue < curr);
+            assertTrue(newValue >= min);
+        }
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/PreviewTest.java

@@ -1,16 +1,10 @@
-package com.otaliastudios.cameraview.preview;
+package com.otaliastudios.cameraview;
 
 
 import android.content.Context;
-import androidx.test.rule.ActivityTestRule;
+import android.support.test.rule.ActivityTestRule;
 import android.view.ViewGroup;
 
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.TestActivity;
-import com.otaliastudios.cameraview.tools.Op;
-import com.otaliastudios.cameraview.size.AspectRatio;
-import com.otaliastudios.cameraview.size.Size;
-
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
@@ -23,71 +17,55 @@ import static org.junit.Assert.*;
 
 import static org.mockito.Mockito.*;
 
-public abstract class CameraPreviewTest<T extends CameraPreview> extends BaseTest {
+public abstract class PreviewTest extends BaseTest {
-
-    private final static long DELAY = 4000;
 
-    protected abstract T createPreview(Context context, ViewGroup parent);
+    protected abstract CameraPreview createPreview(Context context, ViewGroup parent, CameraPreview.SurfaceCallback callback);
 
     @Rule
     public ActivityTestRule<TestActivity> rule = new ActivityTestRule<>(TestActivity.class);
 
-    protected T preview;
+    protected CameraPreview preview;
-    @SuppressWarnings("WeakerAccess")
     protected Size surfaceSize;
     private CameraPreview.SurfaceCallback callback;
-
+    private Task<Boolean> availability;
-    private Op<Boolean> available;
-    private Op<Boolean> destroyed;
 
     @Before
     public void setUp() {
-        available = new Op<>();
+        availability = new Task<>(true);
-        destroyed = new Op<>();
 
-        uiSync(new Runnable() {
+        ui(new Runnable() {
             @Override
             public void run() {
                 TestActivity a = rule.getActivity();
                 surfaceSize = a.getContentSize();
-                callback = mock(CameraPreview.SurfaceCallback.class);
 
+                callback = mock(CameraPreview.SurfaceCallback.class);
                 doAnswer(new Answer() {
                     @Override
-                    public Object answer(InvocationOnMock invocation) {
+                    public Object answer(InvocationOnMock invocation) throws Throwable {
-                        if (available != null) available.controller().end(true);
+                        if (availability != null) availability.end(true);
                         return null;
                     }
                 }).when(callback).onSurfaceAvailable();
-
+                preview = createPreview(a, a.getContentView(), callback);
-                doAnswer(new Answer() {
-                    @Override
-                    public Object answer(InvocationOnMock invocation) {
-                        if (destroyed != null) destroyed.controller().end(true);
-                        return null;
-                    }
-                }).when(callback).onSurfaceDestroyed();
-
-                preview = createPreview(a, a.getContentView());
-                preview.setSurfaceCallback(callback);
             }
         });
     }
 
     // Wait for surface to be available.
     protected void ensureAvailable() {
-        assertNotNull(available.await(DELAY));
+        assertNotNull(availability.await(2000));
     }
 
     // Trigger a destroy.
     protected void ensureDestroyed() {
-        uiSync(new Runnable() {
+        ui(new Runnable() {
             @Override
             public void run() {
-                rule.getActivity().getContentView().removeView(preview.getRootView());
+                rule.getActivity().getContentView().removeView(preview.getView());
             }
         });
-        assertNotNull(destroyed.await(DELAY));
+        idle();
     }
 
     @After
@@ -95,24 +73,22 @@ public abstract class CameraPreviewTest<T extends CameraPreview> extends BaseTes
         preview = null;
         callback = null;
         surfaceSize = null;
-        available = null;
+        availability = null;
-        destroyed = null;
     }
 
     @Test
     public void testDefaults() {
         ensureAvailable();
-        assertTrue(preview.hasSurface());
+        assertTrue(preview.isReady());
         assertNotNull(preview.getView());
-        assertNotNull(preview.getRootView());
         assertNotNull(preview.getOutputClass());
     }
 
     @Test
     public void testDesiredSize() {
-        preview.setStreamSize(160, 90);
+        preview.setDesiredSize(160, 90);
-        assertEquals(160, preview.getStreamSize().getWidth());
+        assertEquals(160, preview.getDesiredSize().getWidth());
-        assertEquals(90, preview.getStreamSize().getHeight());
+        assertEquals(90, preview.getDesiredSize().getHeight());
     }
 
     @Test
@@ -127,14 +103,12 @@ public abstract class CameraPreviewTest<T extends CameraPreview> extends BaseTes
     public void testSurfaceDestroyed() {
         ensureAvailable();
         ensureDestroyed();
-        // This might be called twice in Texture because it overrides ensureDestroyed method
-        verify(callback, atLeastOnce()).onSurfaceDestroyed();
         assertEquals(0, preview.getSurfaceSize().getWidth());
         assertEquals(0, preview.getSurfaceSize().getHeight());
     }
 
     @Test
-    public void testCropCenter() {
+    public void testCropCenter() throws Exception {
         ensureAvailable();
 
         // This is given by the activity, it's the fixed size.
@@ -153,23 +127,17 @@ public abstract class CameraPreviewTest<T extends CameraPreview> extends BaseTes
 
         // Since desired is 'desired', let's fake a new view size that is consistent with it.
         // Ensure crop is not happening anymore.
-        preview.mCropCallback = mock(CameraPreview.CropCallback.class);
+        preview.mCropTask.listen();
-        Op<Void> op = new Op<>();
+        preview.onSurfaceSizeChanged((int) (50f * desired), 50); // Wait...
-        doEndOp(op, null).when(preview.mCropCallback).onCrop();
+        preview.mCropTask.await();
-        preview.dispatchOnSurfaceSizeChanged((int) (50f * desired), 50);
-
-        op.await(); // Wait...
         assertEquals(desired, getViewAspectRatioWithScale(), 0.01f);
         assertFalse(preview.isCropping());
     }
 
     private void setDesiredAspectRatio(float desiredAspectRatio) {
-        preview.mCropCallback = mock(CameraPreview.CropCallback.class);
+        preview.mCropTask.listen();
-        Op<Void> op = new Op<>();
+        preview.setDesiredSize((int) (10f * desiredAspectRatio), 10); // Wait...
-        doEndOp(op, null).when(preview.mCropCallback).onCrop();
+        preview.mCropTask.await();
-        preview.setStreamSize((int) (10f * desiredAspectRatio), 10);
-
-        op.await(); // Wait...
         assertEquals(desiredAspectRatio, getViewAspectRatioWithScale(), 0.01f);
 
     }
@@ -181,12 +149,8 @@ public abstract class CameraPreviewTest<T extends CameraPreview> extends BaseTes
 
     private float getViewAspectRatioWithScale() {
         Size size = preview.getSurfaceSize();
-        int newWidth = (int) (((float) size.getWidth()) * getCropScaleX());
+        int newWidth = (int) (((float) size.getWidth()) * preview.getView().getScaleX());
-        int newHeight = (int) (((float) size.getHeight()) * getCropScaleY());
+        int newHeight = (int) (((float) size.getHeight()) * preview.getView().getScaleY());
         return AspectRatio.of(newWidth, newHeight).toFloat();
     }
-
-    abstract protected float getCropScaleX();
-
-    abstract protected float getCropScaleY();
 }

cameraview/src/androidTest/java/com/otaliastudios/cameraview/ScrollGestureLayoutTest.java

@@ -0,0 +1,92 @@
+package com.otaliastudios.cameraview;
+
+
+import android.content.Context;
+import android.support.test.espresso.ViewAction;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static android.support.test.espresso.action.ViewActions.click;
+import static android.support.test.espresso.action.ViewActions.swipeDown;
+import static android.support.test.espresso.action.ViewActions.swipeLeft;
+import static android.support.test.espresso.action.ViewActions.swipeRight;
+import static android.support.test.espresso.action.ViewActions.swipeUp;
+import static android.support.test.espresso.matcher.ViewMatchers.withId;
+import static junit.framework.Assert.assertNotNull;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ScrollGestureLayoutTest extends GestureLayoutTest<ScrollGestureLayout> {
+
+    @Override
+    protected ScrollGestureLayout create(Context context) {
+        return new ScrollGestureLayout(context);
+    }
+
+    @Test
+    public void testDefaults() {
+        assertNull(layout.getGestureType());
+        assertEquals(layout.getPoints().length, 2);
+        assertEquals(layout.getPoints()[0].x, 0, 0);
+        assertEquals(layout.getPoints()[0].y, 0, 0);
+        assertEquals(layout.getPoints()[1].x, 0, 0);
+        assertEquals(layout.getPoints()[1].y, 0, 0);
+    }
+
+    @Test
+    public void testScrollDisabled() {
+        layout.enable(false);
+        touch.listen();
+        touch.start();
+        onLayout().perform(swipeUp());
+        Gesture found = touch.await(500);
+        assertNull(found);
+    }
+
+    private void testScroll(ViewAction scroll, Gesture expected, boolean increasing) {
+        touch.listen();
+        touch.start();
+        onLayout().perform(scroll);
+        Gesture found = touch.await(500);
+        assertEquals(found, expected);
+
+        // How will this move our parameter?
+        float curr = 0.5f, min = 0f, max = 1f;
+        float newValue = layout.scaleValue(curr, min, max);
+        if (increasing) {
+            assertTrue(newValue > curr);
+            assertTrue(newValue <= max);
+        } else {
+            assertTrue(newValue < curr);
+            assertTrue(newValue >= min);
+        }
+    }
+
+    @Test
+    public void testScrollLeft() {
+        testScroll(swipeLeft(), Gesture.SCROLL_HORIZONTAL, false);
+    }
+
+    @Test
+    public void testScrollRight() {
+        testScroll(swipeRight(), Gesture.SCROLL_HORIZONTAL, true);
+    }
+
+    @Test
+    public void testScrollUp() {
+        testScroll(swipeUp(), Gesture.SCROLL_VERTICAL, true);
+    }
+
+    @Test
+    public void testScrollDown() {
+        testScroll(swipeDown(), Gesture.SCROLL_VERTICAL, false);
+    }
+
+
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/SurfaceCameraPreviewTest.java

@@ -0,0 +1,19 @@
+package com.otaliastudios.cameraview;
+
+
+import android.content.Context;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+import android.view.ViewGroup;
+
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class SurfaceCameraPreviewTest extends PreviewTest {
+
+    @Override
+    protected CameraPreview createPreview(Context context, ViewGroup parent, CameraPreview.SurfaceCallback callback) {
+        return new SurfaceCameraPreview(context, parent, callback);
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/TapGestureLayoutTest.java

@@ -0,0 +1,77 @@
+package com.otaliastudios.cameraview;
+
+
+import android.content.Context;
+import android.support.test.espresso.action.GeneralClickAction;
+import android.support.test.espresso.action.GeneralLocation;
+import android.support.test.espresso.action.Press;
+import android.support.test.espresso.action.Tap;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+import android.view.InputDevice;
+import android.view.MotionEvent;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static android.support.test.espresso.action.ViewActions.*;
+import static org.junit.Assert.*;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class TapGestureLayoutTest extends GestureLayoutTest<TapGestureLayout> {
+
+    @Override
+    protected TapGestureLayout create(Context context) {
+        return new TapGestureLayout(context);
+    }
+
+    @Test
+    public void testDefaults() {
+        assertNull(layout.getGestureType());
+        assertEquals(layout.getPoints().length, 1);
+        assertEquals(layout.getPoints()[0].x, 0, 0);
+        assertEquals(layout.getPoints()[0].y, 0, 0);
+    }
+
+    @Test
+    public void testTap() {
+        touch.listen();
+        touch.start();
+        GeneralClickAction a = new GeneralClickAction(
+                Tap.SINGLE, GeneralLocation.CENTER, Press.FINGER,
+                InputDevice.SOURCE_UNKNOWN, MotionEvent.BUTTON_PRIMARY);
+        onLayout().perform(a);
+        Gesture found = touch.await(500);
+
+        assertEquals(found, Gesture.TAP);
+        Size size = rule.getActivity().getContentSize();
+        assertEquals(layout.getPoints()[0].x, (size.getWidth() / 2f), 1f);
+        assertEquals(layout.getPoints()[0].y, (size.getHeight() / 2f), 1f);
+    }
+
+    @Test
+    public void testTapWhileDisabled() {
+        layout.enable(false);
+        touch.listen();
+        touch.start();
+        onLayout().perform(click());
+        Gesture found = touch.await(500);
+        assertNull(found);
+    }
+
+    @Test
+    public void testLongTap() {
+        touch.listen();
+        touch.start();
+        GeneralClickAction a = new GeneralClickAction(
+                Tap.LONG, GeneralLocation.CENTER, Press.FINGER,
+                InputDevice.SOURCE_UNKNOWN, MotionEvent.BUTTON_PRIMARY);
+        onLayout().perform(a);
+        Gesture found = touch.await(500);
+        assertEquals(found, Gesture.LONG_TAP);
+        Size size = rule.getActivity().getContentSize();
+        assertEquals(layout.getPoints()[0].x, (size.getWidth() / 2f), 1f);
+        assertEquals(layout.getPoints()[0].y, (size.getHeight() / 2f), 1f);
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/TestActivity.java

@@ -2,18 +2,18 @@ package com.otaliastudios.cameraview;
 
 
 import android.app.Activity;
+import android.app.KeyguardManager;
+import android.content.Context;
 import android.graphics.Point;
 import android.os.Bundle;
-
+import android.os.PersistableBundle;
-import androidx.annotation.Nullable;
+import android.support.annotation.Nullable;
 import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.WindowManager;
 import android.widget.FrameLayout;
 
-import com.otaliastudios.cameraview.size.Size;
-
 import static android.view.ViewGroup.LayoutParams.*;
 
 public class TestActivity extends Activity {

cameraview/src/androidTest/java/com/otaliastudios/cameraview/TextureCameraPreviewTest.java

@@ -1,21 +1,20 @@
-package com.otaliastudios.cameraview.preview;
+package com.otaliastudios.cameraview;
 
 
 import android.content.Context;
-
+import android.support.test.filters.SmallTest;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
+import android.support.test.runner.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
 import android.view.ViewGroup;
 
 import org.junit.runner.RunWith;
 
 @RunWith(AndroidJUnit4.class)
 @SmallTest
-public class TextureCameraPreviewTest extends CameraPreviewTest<TextureCameraPreview> {
+public class TextureCameraPreviewTest extends PreviewTest {
 
     @Override
-    protected TextureCameraPreview createPreview(Context context, ViewGroup parent) {
+    protected CameraPreview createPreview(Context context, ViewGroup parent, CameraPreview.SurfaceCallback callback) {
-        return new TextureCameraPreview(context, parent);
+        return new TextureCameraPreview(context, parent, callback);
     }
 
     @Override
@@ -23,7 +22,7 @@ public class TextureCameraPreviewTest extends CameraPreviewTest<TextureCameraPre
         if (isHardwareAccelerated()) {
             super.ensureAvailable();
         } else {
-            preview.dispatchOnSurfaceAvailable(
+            preview.onSurfaceAvailable(
                     surfaceSize.getWidth(),
                     surfaceSize.getHeight());
         }
@@ -34,21 +33,11 @@ public class TextureCameraPreviewTest extends CameraPreviewTest<TextureCameraPre
         super.ensureDestroyed();
         if (!isHardwareAccelerated()) {
             // Ensure it is called.
-            preview.dispatchOnSurfaceDestroyed();
+            preview.onSurfaceDestroyed();
         }
     }
 
     private boolean isHardwareAccelerated() {
         return preview.getView().isHardwareAccelerated();
     }
-
-    @Override
-    protected float getCropScaleX() {
-        return preview.getView().getScaleX();
-    }
-
-    @Override
-    protected float getCropScaleY() {
-        return preview.getView().getScaleY();
-    }
 }

cameraview/src/androidTest/java/com/otaliastudios/cameraview/VideoResultTest.java

@@ -1,146 +0,0 @@
-package com.otaliastudios.cameraview;
-
-
-import android.location.Location;
-
-import com.otaliastudios.cameraview.controls.Audio;
-import com.otaliastudios.cameraview.controls.AudioCodec;
-import com.otaliastudios.cameraview.controls.Facing;
-import com.otaliastudios.cameraview.controls.VideoCodec;
-import com.otaliastudios.cameraview.size.Size;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mockito;
-
-import java.io.File;
-import java.io.FileDescriptor;
-
-import static org.junit.Assert.assertEquals;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class VideoResultTest extends BaseTest {
-
-    private VideoResult.Stub stub = new VideoResult.Stub();
-
-    @Test
-    public void testResultWithFile() {
-        File file = Mockito.mock(File.class);
-        int rotation = 90;
-        Size size = new Size(20, 120);
-        VideoCodec videoCodec = VideoCodec.H_263;
-        AudioCodec audioCodec = AudioCodec.DEVICE_DEFAULT;
-        Location location = Mockito.mock(Location.class);
-        boolean isSnapshot = true;
-        int maxDuration = 1234;
-        long maxFileSize = 500000;
-        int reason = VideoResult.REASON_MAX_DURATION_REACHED;
-        int videoFrameRate = 30;
-        int videoBitRate = 300000;
-        int audioBitRate = 30000;
-        Audio audio = Audio.ON;
-        Facing facing = Facing.FRONT;
-
-        stub.file = file;
-        stub.rotation = rotation;
-        stub.size = size;
-        stub.videoCodec = videoCodec;
-        stub.audioCodec = audioCodec;
-        stub.location = location;
-        stub.isSnapshot = isSnapshot;
-        stub.maxDuration = maxDuration;
-        stub.maxSize = maxFileSize;
-        stub.endReason = reason;
-        stub.videoFrameRate = videoFrameRate;
-        stub.videoBitRate = videoBitRate;
-        stub.audioBitRate = audioBitRate;
-        stub.audio = audio;
-        stub.facing = facing;
-
-        VideoResult result = new VideoResult(stub);
-        assertEquals(result.getFile(), file);
-        assertEquals(result.getRotation(), rotation);
-        assertEquals(result.getSize(), size);
-        assertEquals(result.getVideoCodec(), videoCodec);
-        assertEquals(result.getAudioCodec(), audioCodec);
-        assertEquals(result.getLocation(), location);
-        assertEquals(result.isSnapshot(), isSnapshot);
-        assertEquals(result.getMaxSize(), maxFileSize);
-        assertEquals(result.getMaxDuration(), maxDuration);
-        assertEquals(result.getTerminationReason(), reason);
-        assertEquals(result.getVideoFrameRate(), videoFrameRate);
-        assertEquals(result.getVideoBitRate(), videoBitRate);
-        assertEquals(result.getAudioBitRate(), audioBitRate);
-        assertEquals(result.getAudio(), audio);
-        assertEquals(result.getFacing(), facing);
-    }
-
-    @Test
-    public void testResultWithFileDescriptor() {
-        FileDescriptor fileDescriptor = FileDescriptor.in;
-        int rotation = 90;
-        Size size = new Size(20, 120);
-        VideoCodec videoCodec = VideoCodec.H_263;
-        AudioCodec audioCodec = AudioCodec.DEVICE_DEFAULT;
-        Location location = Mockito.mock(Location.class);
-        boolean isSnapshot = true;
-        int maxDuration = 1234;
-        long maxFileSize = 500000;
-        int reason = VideoResult.REASON_MAX_DURATION_REACHED;
-        int videoFrameRate = 30;
-        int videoBitRate = 300000;
-        int audioBitRate = 30000;
-        Audio audio = Audio.ON;
-        Facing facing = Facing.FRONT;
-
-        stub.fileDescriptor = fileDescriptor;
-        stub.rotation = rotation;
-        stub.size = size;
-        stub.videoCodec = videoCodec;
-        stub.audioCodec = audioCodec;
-        stub.location = location;
-        stub.isSnapshot = isSnapshot;
-        stub.maxDuration = maxDuration;
-        stub.maxSize = maxFileSize;
-        stub.endReason = reason;
-        stub.videoFrameRate = videoFrameRate;
-        stub.videoBitRate = videoBitRate;
-        stub.audioBitRate = audioBitRate;
-        stub.audio = audio;
-        stub.facing = facing;
-
-        VideoResult result = new VideoResult(stub);
-        assertEquals(result.getFileDescriptor(), fileDescriptor);
-        assertEquals(result.getRotation(), rotation);
-        assertEquals(result.getSize(), size);
-        assertEquals(result.getVideoCodec(), videoCodec);
-        assertEquals(result.getAudioCodec(), audioCodec);
-        assertEquals(result.getLocation(), location);
-        assertEquals(result.isSnapshot(), isSnapshot);
-        assertEquals(result.getMaxSize(), maxFileSize);
-        assertEquals(result.getMaxDuration(), maxDuration);
-        assertEquals(result.getTerminationReason(), reason);
-        assertEquals(result.getVideoFrameRate(), videoFrameRate);
-        assertEquals(result.getVideoBitRate(), videoBitRate);
-        assertEquals(result.getAudioBitRate(), audioBitRate);
-        assertEquals(result.getAudio(), audio);
-        assertEquals(result.getFacing(), facing);
-    }
-
-    @Test(expected = RuntimeException.class)
-    public void testResultWithNoFile() {
-        VideoResult result = new VideoResult(stub);
-        result.getFile();
-    }
-
-    @Test(expected = RuntimeException.class)
-    public void testResultWithNoFileDescriptor() {
-        VideoResult result = new VideoResult(stub);
-        result.getFileDescriptor();
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/WorkerHandlerTest.java

@@ -0,0 +1,39 @@
+package com.otaliastudios.cameraview;
+
+
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class WorkerHandlerTest extends BaseTest {
+
+    @Test
+    public void testCache() {
+        WorkerHandler w1 = WorkerHandler.get("handler1");
+        WorkerHandler w1a = WorkerHandler.get("handler1");
+        WorkerHandler w2 = WorkerHandler.get("handler2");
+        assertTrue(w1 == w1a);
+        assertFalse(w1 == w2);
+    }
+
+    @Test
+    public void testStaticRun() {
+        final Task<Boolean> task = new Task<>(true);
+        Runnable action = new Runnable() {
+            @Override
+            public void run() {
+                task.end(true);
+            }
+        };
+        WorkerHandler.run(action);
+        Boolean result = task.await(500);
+        assertNotNull(result);
+        assertTrue(result);
+    }
+}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/engine/Camera1IntegrationTest.java

@@ -1,51 +0,0 @@
-package com.otaliastudios.cameraview.engine;
-
-import com.otaliastudios.cameraview.CameraLogger;
-import com.otaliastudios.cameraview.CameraOptions;
-import com.otaliastudios.cameraview.controls.Engine;
-import com.otaliastudios.cameraview.frame.Frame;
-import com.otaliastudios.cameraview.frame.FrameProcessor;
-import com.otaliastudios.cameraview.tools.Op;
-import com.otaliastudios.cameraview.tools.Retry;
-import com.otaliastudios.cameraview.tools.SdkExclude;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.LargeTest;
-import androidx.test.filters.RequiresDevice;
-
-import java.util.Collection;
-
-import static org.junit.Assert.assertNotNull;
-
-/**
- * These tests work great on real devices, and are the only way to test actual CameraEngine
- * implementation - we really need to open the camera device.
- * Unfortunately they fail unreliably on emulated devices, due to some bug with the
- * emulated camera controller.
- */
-@RunWith(AndroidJUnit4.class)
-@LargeTest
-// @RequiresDevice
-public class Camera1IntegrationTest extends CameraIntegrationTest<Camera1Engine> {
-
-    @NonNull
-    @Override
-    protected Engine getEngine() {
-        return Engine.CAMERA1;
-    }
-
-    @Override
-    protected long getMeteringTimeoutMillis() {
-        return Camera1Engine.AUTOFOCUS_END_DELAY_MILLIS;
-    }
-
-    @Override
-    public void testFrameProcessing_maxSize() {
-        // Camera1Engine does not support different sizes.
-        // super.testFrameProcessing_maxSize();
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/engine/Camera2IntegrationTest.java

@@ -1,86 +0,0 @@
-package com.otaliastudios.cameraview.engine;
-
-import android.hardware.camera2.CameraCharacteristics;
-import android.hardware.camera2.CaptureRequest;
-import android.hardware.camera2.TotalCaptureResult;
-import android.os.Handler;
-
-import com.otaliastudios.cameraview.controls.Engine;
-import com.otaliastudios.cameraview.engine.action.ActionHolder;
-import com.otaliastudios.cameraview.engine.action.BaseAction;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.LargeTest;
-import androidx.test.filters.RequiresDevice;
-
-import java.util.concurrent.CountDownLatch;
-
-/**
- * These tests work great on real devices, and are the only way to test actual CameraEngine
- * implementation - we really need to open the camera device.
- * Unfortunately they fail unreliably on emulated devices, due to some bug with the
- * emulated camera controller.
- */
-@RunWith(AndroidJUnit4.class)
-@LargeTest
-// @RequiresDevice
-public class Camera2IntegrationTest extends CameraIntegrationTest<Camera2Engine> {
-
-    @NonNull
-    @Override
-    protected Engine getEngine() {
-        return Engine.CAMERA2;
-    }
-
-    /* @Override
-    protected void onOpenSync() {
-        super.onOpenSync();
-        // Extra wait for the first frame to be dispatched.
-        // This is because various classes require getLastResult to be non-null
-        // and that's typically the case in a real app.
-        final CountDownLatch latch = new CountDownLatch(1);
-        new BaseAction() {
-            @Override
-            public void onCaptureCompleted(@NonNull ActionHolder holder,
-                                           @NonNull CaptureRequest request,
-                                           @NonNull TotalCaptureResult result) {
-                super.onCaptureCompleted(holder, request, result);
-                latch.countDown();
-                setState(STATE_COMPLETED);
-            }
-        }.start(controller);
-        try { latch.await(); } catch (InterruptedException ignore) {}
-    } */
-
-    @Override
-    protected long getMeteringTimeoutMillis() {
-        return Camera2Engine.METER_TIMEOUT;
-    }
-
-    /**
-     * setMaxDuration can crash on legacy devices (most emulator are), and I don't see
-     * any way to fix this in code. They shouldn't use Camera2 at all.
-     * @return true if possible.
-     */
-    @Override
-    protected boolean canSetVideoMaxDuration() {
-        if (!super.canSetVideoMaxDuration()) return false;
-        boolean shouldOpen = !camera.isOpened();
-        if (shouldOpen) openSync(true);
-        boolean result = controller.readCharacteristic(
-                CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL, -1)
-                != CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY;
-        if (shouldOpen) closeSync(true);
-        return result;
-    }
-
-    @Override
-    public void testFrameProcessing_freezeRelease() {
-        // Camera2 Frames are not freezable.
-        // super.testFrameProcessing_freezeRelease();
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/engine/MockCameraEngine.java

@@ -1,215 +0,0 @@
-package com.otaliastudios.cameraview.engine;
-
-
-import android.graphics.PointF;
-import android.graphics.RectF;
-import android.location.Location;
-
-import com.google.android.gms.tasks.Task;
-import com.google.android.gms.tasks.Tasks;
-import com.otaliastudios.cameraview.CameraOptions;
-import com.otaliastudios.cameraview.PictureResult;
-import com.otaliastudios.cameraview.VideoResult;
-import com.otaliastudios.cameraview.controls.Facing;
-import com.otaliastudios.cameraview.controls.Flash;
-import com.otaliastudios.cameraview.controls.PictureFormat;
-import com.otaliastudios.cameraview.engine.orchestrator.CameraState;
-import com.otaliastudios.cameraview.frame.ByteBufferFrameManager;
-import com.otaliastudios.cameraview.frame.FrameManager;
-import com.otaliastudios.cameraview.gesture.Gesture;
-import com.otaliastudios.cameraview.controls.Hdr;
-import com.otaliastudios.cameraview.controls.WhiteBalance;
-import com.otaliastudios.cameraview.metering.MeteringRegions;
-import com.otaliastudios.cameraview.size.AspectRatio;
-import com.otaliastudios.cameraview.size.Size;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Callable;
-
-public class MockCameraEngine extends CameraBaseEngine {
-
-    public boolean mPictureCaptured;
-    public boolean mFocusStarted;
-    public boolean mZoomChanged;
-    public boolean mExposureCorrectionChanged;
-
-    public MockCameraEngine(CameraEngine.Callback callback) {
-        super(callback);
-    }
-
-    @NonNull
-    @Override
-    protected Task<CameraOptions> onStartEngine() {
-        return Tasks.forResult(mCameraOptions);
-    }
-
-    @NonNull
-    @Override
-    protected Task<Void> onStopEngine() {
-        return Tasks.forResult(null);
-    }
-
-    @NonNull
-    @Override
-    protected Task<Void> onStartBind() {
-        return Tasks.forResult(null);
-    }
-
-    @NonNull
-    @Override
-    protected Task<Void> onStopBind() {
-        return Tasks.forResult(null);
-    }
-
-    @NonNull
-    @Override
-    protected Task<Void> onStartPreview() {
-        return Tasks.forResult(null);
-    }
-
-    @NonNull
-    @Override
-    protected Task<Void> onStopPreview() {
-        return Tasks.forResult(null);
-    }
-
-    public void setMockCameraOptions(CameraOptions options) {
-        mCameraOptions = options;
-    }
-
-    public void setMockPreviewStreamSize(Size size) {
-        mPreviewStreamSize = size;
-    }
-
-    public void setMockState(@NonNull CameraState state) {
-        Task<Void> change = getOrchestrator().scheduleStateChange(getState(),
-                state,
-                false,
-                new Callable<Task<Void>>() {
-            @Override
-            public Task<Void> call() {
-                return Tasks.forResult(null);
-            }
-        });
-        try {
-            Tasks.await(change);
-        } catch (Exception ignore) {}
-    }
-
-    @Override
-    public void setZoom(float zoom, @Nullable PointF[] points, boolean notify) {
-        mZoomValue = zoom;
-        mZoomChanged = true;
-    }
-
-    @Override
-    public void setExposureCorrection(float EVvalue, @NonNull float[] bounds, @Nullable PointF[] points, boolean notify) {
-        mExposureCorrectionValue = EVvalue;
-        mExposureCorrectionChanged = true;
-    }
-
-    @Override
-    public void setFlash(@NonNull Flash flash) {
-        mFlash = flash;
-    }
-
-    @Override
-    public void setWhiteBalance(@NonNull WhiteBalance whiteBalance) {
-        mWhiteBalance = whiteBalance;
-    }
-
-    @Override
-    public void setHdr(@NonNull Hdr hdr) {
-        mHdr = hdr;
-    }
-
-    @Override
-    public void setLocation(@Nullable Location location) {
-        mLocation = location;
-    }
-
-    @Override
-    public void setPictureFormat(@NonNull PictureFormat pictureFormat) {
-        mPictureFormat = pictureFormat;
-    }
-
-    @Override
-    public void setHasFrameProcessors(boolean hasFrameProcessors) {
-        mHasFrameProcessors = hasFrameProcessors;
-    }
-
-    @Override
-    public void setFrameProcessingFormat(int format) {
-        mFrameProcessingFormat = format;
-    }
-
-    @Override
-    public void takePicture(@NonNull PictureResult.Stub stub) {
-        super.takePicture(stub);
-        mPictureCaptured = true;
-    }
-
-    @Override
-    protected void onTakePicture(@NonNull PictureResult.Stub stub, boolean doMetering) {
-
-    }
-
-    @Override
-    protected void onTakePictureSnapshot(@NonNull PictureResult.Stub stub, @NonNull AspectRatio outputRatio, boolean doMetering) {
-
-    }
-
-    @Override
-    protected void onTakeVideo(@NonNull VideoResult.Stub stub) {
-
-    }
-
-    @Override
-    protected void onTakeVideoSnapshot(@NonNull VideoResult.Stub stub, @NonNull AspectRatio outputRatio) {
-
-    }
-
-    @Override
-    protected void onPreviewStreamSizeChanged() {
-
-    }
-
-    @NonNull
-    @Override
-    protected List<Size> getPreviewStreamAvailableSizes() {
-        return new ArrayList<>();
-    }
-
-    @NonNull
-    @Override
-    protected List<Size> getFrameProcessingAvailableSizes() {
-        return new ArrayList<>();
-    }
-
-    @Override
-    public void startAutoFocus(@Nullable Gesture gesture, @NonNull MeteringRegions regions, @NonNull PointF legacyPoint) {
-        mFocusStarted = true;
-    }
-
-    @NonNull
-    @Override
-    protected FrameManager instantiateFrameManager(int poolSize) {
-        return new ByteBufferFrameManager(poolSize, null);
-    }
-
-    @Override
-    public void setPlaySounds(boolean playSounds) { }
-
-    @Override
-    protected boolean collectCameraInfo(@NonNull Facing facing) {
-        return true;
-    }
-
-    @Override public void setPreviewFrameRate(float previewFrameRate) {
-        mPreviewFrameRate = previewFrameRate;
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/engine/mappers/Camera1MapperTest.java

@@ -1,68 +0,0 @@
-package com.otaliastudios.cameraview.engine.mappers;
-
-
-import android.hardware.Camera;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.controls.Facing;
-import com.otaliastudios.cameraview.controls.Flash;
-import com.otaliastudios.cameraview.controls.Hdr;
-import com.otaliastudios.cameraview.controls.WhiteBalance;
-import com.otaliastudios.cameraview.engine.mappers.Camera1Mapper;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.*;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class Camera1MapperTest extends BaseTest {
-
-    private Camera1Mapper mapper = Camera1Mapper.get();
-
-    @Test
-    public void testMap() {
-        assertEquals(mapper.mapFlash(Flash.OFF), Camera.Parameters.FLASH_MODE_OFF);
-        assertEquals(mapper.mapFlash(Flash.ON), Camera.Parameters.FLASH_MODE_ON);
-        assertEquals(mapper.mapFlash(Flash.AUTO), Camera.Parameters.FLASH_MODE_AUTO);
-        assertEquals(mapper.mapFlash(Flash.TORCH), Camera.Parameters.FLASH_MODE_TORCH);
-
-        assertEquals(mapper.mapFacing(Facing.BACK), Camera.CameraInfo.CAMERA_FACING_BACK);
-        assertEquals(mapper.mapFacing(Facing.FRONT), Camera.CameraInfo.CAMERA_FACING_FRONT);
-
-        assertEquals(mapper.mapHdr(Hdr.OFF), Camera.Parameters.SCENE_MODE_AUTO);
-        assertEquals(mapper.mapHdr(Hdr.ON), Camera.Parameters.SCENE_MODE_HDR);
-
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.AUTO), Camera.Parameters.WHITE_BALANCE_AUTO);
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.DAYLIGHT), Camera.Parameters.WHITE_BALANCE_DAYLIGHT);
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.CLOUDY), Camera.Parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT);
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.INCANDESCENT), Camera.Parameters.WHITE_BALANCE_INCANDESCENT);
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.FLUORESCENT), Camera.Parameters.WHITE_BALANCE_FLUORESCENT);
-    }
-
-
-    @Test
-    public void testUnmap() {
-        assertEquals(Flash.OFF, mapper.unmapFlash(Camera.Parameters.FLASH_MODE_OFF));
-        assertEquals(Flash.ON, mapper.unmapFlash(Camera.Parameters.FLASH_MODE_ON));
-        assertEquals(Flash.AUTO, mapper.unmapFlash(Camera.Parameters.FLASH_MODE_AUTO));
-        assertEquals(Flash.TORCH, mapper.unmapFlash(Camera.Parameters.FLASH_MODE_TORCH));
-
-        assertEquals(Facing.BACK, mapper.unmapFacing(Camera.CameraInfo.CAMERA_FACING_BACK));
-        assertEquals(Facing.FRONT, mapper.unmapFacing(Camera.CameraInfo.CAMERA_FACING_FRONT));
-
-        assertEquals(Hdr.OFF, mapper.unmapHdr(Camera.Parameters.SCENE_MODE_AUTO));
-        assertEquals(Hdr.ON, mapper.unmapHdr(Camera.Parameters.SCENE_MODE_HDR));
-
-        assertEquals(WhiteBalance.AUTO, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_AUTO));
-        assertEquals(WhiteBalance.DAYLIGHT, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_DAYLIGHT));
-        assertEquals(WhiteBalance.CLOUDY, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT));
-        assertEquals(WhiteBalance.INCANDESCENT, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_INCANDESCENT));
-        assertEquals(WhiteBalance.FLUORESCENT, mapper.unmapWhiteBalance(Camera.Parameters.WHITE_BALANCE_FLUORESCENT));
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/engine/mappers/Camera2MapperTest.java

@@ -1,101 +0,0 @@
-package com.otaliastudios.cameraview.engine.mappers;
-
-
-import android.hardware.Camera;
-import android.util.Pair;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.controls.Facing;
-import com.otaliastudios.cameraview.controls.Flash;
-import com.otaliastudios.cameraview.controls.Hdr;
-import com.otaliastudios.cameraview.controls.WhiteBalance;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.util.List;
-import java.util.Set;
-
-import static android.hardware.camera2.CameraMetadata.*;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class Camera2MapperTest extends BaseTest {
-
-    private Camera2Mapper mapper = Camera2Mapper.get();
-
-    @Test
-    public void testMap() {
-        List<Pair<Integer, Integer>> values = mapper.mapFlash(Flash.OFF);
-        assertEquals(2, values.size());
-        assertTrue(values.contains(new Pair<>(CONTROL_AE_MODE_ON, FLASH_MODE_OFF)));
-        assertTrue(values.contains(new Pair<>(CONTROL_AE_MODE_OFF, FLASH_MODE_OFF)));
-        values = mapper.mapFlash(Flash.TORCH);
-        assertEquals(2, values.size());
-        assertTrue(values.contains(new Pair<>(CONTROL_AE_MODE_ON, FLASH_MODE_TORCH)));
-        assertTrue(values.contains(new Pair<>(CONTROL_AE_MODE_OFF, FLASH_MODE_TORCH)));
-        values = mapper.mapFlash(Flash.AUTO);
-        assertEquals(2, values.size());
-        assertTrue(values.contains(new Pair<>(CONTROL_AE_MODE_ON_AUTO_FLASH, FLASH_MODE_OFF)));
-        assertTrue(values.contains(new Pair<>(CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE, FLASH_MODE_OFF)));
-        values = mapper.mapFlash(Flash.ON);
-        assertEquals(1, values.size());
-        assertTrue(values.contains(new Pair<>(CONTROL_AE_MODE_ON_ALWAYS_FLASH, FLASH_MODE_OFF)));
-
-        assertEquals(mapper.mapFacing(Facing.BACK), LENS_FACING_BACK);
-        assertEquals(mapper.mapFacing(Facing.FRONT), LENS_FACING_FRONT);
-
-        assertEquals(mapper.mapHdr(Hdr.OFF), CONTROL_SCENE_MODE_DISABLED);
-        assertEquals(mapper.mapHdr(Hdr.ON), CONTROL_SCENE_MODE_HDR);
-
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.AUTO), CONTROL_AWB_MODE_AUTO);
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.DAYLIGHT), CONTROL_AWB_MODE_DAYLIGHT);
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.CLOUDY), CONTROL_AWB_MODE_CLOUDY_DAYLIGHT);
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.INCANDESCENT), CONTROL_AWB_MODE_INCANDESCENT);
-        assertEquals(mapper.mapWhiteBalance(WhiteBalance.FLUORESCENT), CONTROL_AWB_MODE_FLUORESCENT);
-    }
-
-
-    @Test
-    public void testUnmap() {
-        Set<Flash> values;
-        values = mapper.unmapFlash(CONTROL_AE_MODE_OFF);
-        assertEquals(values.size(), 2);
-        assertTrue(values.contains(Flash.OFF));
-        assertTrue(values.contains(Flash.TORCH));
-        values = mapper.unmapFlash(CONTROL_AE_MODE_ON);
-        assertEquals(values.size(), 2);
-        assertTrue(values.contains(Flash.OFF));
-        assertTrue(values.contains(Flash.TORCH));
-        values = mapper.unmapFlash(CONTROL_AE_MODE_ON_ALWAYS_FLASH);
-        assertEquals(values.size(), 1);
-        assertTrue(values.contains(Flash.ON));
-        values = mapper.unmapFlash(CONTROL_AE_MODE_ON_AUTO_FLASH);
-        assertEquals(values.size(), 1);
-        assertTrue(values.contains(Flash.AUTO));
-        values = mapper.unmapFlash(CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE);
-        assertEquals(values.size(), 1);
-        assertTrue(values.contains(Flash.AUTO));
-        values = mapper.unmapFlash(CONTROL_AE_MODE_ON_EXTERNAL_FLASH);
-        assertEquals(values.size(), 0);
-
-        assertEquals(Facing.BACK, mapper.unmapFacing(LENS_FACING_BACK));
-        assertEquals(Facing.FRONT, mapper.unmapFacing(LENS_FACING_FRONT));
-
-        assertEquals(Hdr.OFF, mapper.unmapHdr(CONTROL_SCENE_MODE_DISABLED));
-        assertEquals(Hdr.ON, mapper.unmapHdr(CONTROL_SCENE_MODE_HDR));
-
-        assertEquals(WhiteBalance.AUTO, mapper.unmapWhiteBalance(CONTROL_AWB_MODE_AUTO));
-        assertEquals(WhiteBalance.DAYLIGHT, mapper.unmapWhiteBalance(CONTROL_AWB_MODE_DAYLIGHT));
-        assertEquals(WhiteBalance.CLOUDY, mapper.unmapWhiteBalance(CONTROL_AWB_MODE_CLOUDY_DAYLIGHT));
-        assertEquals(WhiteBalance.INCANDESCENT, mapper.unmapWhiteBalance(CONTROL_AWB_MODE_INCANDESCENT));
-        assertEquals(WhiteBalance.FLUORESCENT, mapper.unmapWhiteBalance(CONTROL_AWB_MODE_FLUORESCENT));
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/filter/BaseFilterTest.java

@@ -1,172 +0,0 @@
-package com.otaliastudios.cameraview.filter;
-
-
-import android.opengl.GLES20;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseEglTest;
-import com.otaliastudios.cameraview.internal.GlTextureDrawer;
-import com.otaliastudios.opengl.program.GlTextureProgram;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class BaseFilterTest extends BaseEglTest {
-
-    public static class TestFilter extends BaseFilter implements TwoParameterFilter {
-
-        private float param1;
-        private float param2;
-
-        @NonNull
-        @Override
-        public String getFragmentShader() {
-            return createDefaultFragmentShader();
-        }
-
-        @Override
-        public void setParameter1(float value) {
-            param1 = value;
-        }
-
-        @Override
-        public void setParameter2(float value) {
-            param2 = value;
-        }
-
-        @Override
-        public float getParameter1() {
-            return param1;
-        }
-
-        @Override
-        public float getParameter2() {
-            return param2;
-        }
-    }
-
-    private TestFilter filter;
-
-    @Test
-    public void testCreateDefaultFragmentShader() {
-        filter = new TestFilter();
-        filter.fragmentTextureCoordinateName = "XXX";
-        String defaultFragmentShader = filter.createDefaultFragmentShader();
-        assertNotNull(defaultFragmentShader);
-        assertTrue(defaultFragmentShader.contains(filter.fragmentTextureCoordinateName));
-    }
-
-    @Test
-    public void testCreateDefaultVertexShader() {
-        filter = new TestFilter();
-        filter.vertexModelViewProjectionMatrixName = "AAA";
-        filter.vertexPositionName = "BBB";
-        filter.vertexTextureCoordinateName = "CCC";
-        filter.vertexTransformMatrixName = "DDD";
-        filter.fragmentTextureCoordinateName = "EEE";
-        String defaultVertexShader = filter.createDefaultVertexShader();
-        assertNotNull(defaultVertexShader);
-        assertTrue(defaultVertexShader.contains(filter.vertexModelViewProjectionMatrixName));
-        assertTrue(defaultVertexShader.contains(filter.vertexPositionName));
-        assertTrue(defaultVertexShader.contains(filter.vertexTextureCoordinateName));
-        assertTrue(defaultVertexShader.contains(filter.vertexTransformMatrixName));
-        assertTrue(defaultVertexShader.contains(filter.fragmentTextureCoordinateName));
-    }
-
-    @Test
-    public void testOnProgramCreate() {
-        filter = new TestFilter();
-        int handle = GlTextureProgram.create(filter.getVertexShader(), filter.getFragmentShader());
-        filter.onCreate(handle);
-        assertNotNull(filter.program);
-        filter.onDestroy();
-        assertNull(filter.program);
-        GLES20.glDeleteProgram(handle);
-    }
-
-    @Test
-    public void testDraw_whenInvalid() {
-        filter = spy(new TestFilter());
-        float[] matrix = new float[16];
-        filter.draw(0L, matrix);
-        verify(filter, never()).onPreDraw(0L, matrix);
-        verify(filter, never()).onDraw(0L);
-        verify(filter, never()).onPostDraw(0L);
-    }
-
-    @Test
-    public void testDraw() {
-        // Use a drawer which cares about GL setup.
-        filter = spy(new TestFilter());
-        GlTextureDrawer drawer = new GlTextureDrawer();
-        drawer.setFilter(filter);
-
-        float[] matrix = drawer.getTextureTransform();
-        drawer.draw(0L);
-        verify(filter, times(1)).onPreDraw(0L, matrix);
-        verify(filter, times(1)).onDraw(0L);
-        verify(filter, times(1)).onPostDraw(0L);
-
-        drawer.release();
-    }
-
-    @Test(expected = RuntimeException.class)
-    public void testOnCopy_invalid() {
-        // Anonymous inner classes do not have a public constructor.
-        Filter filter = new BaseFilter() {
-            @NonNull
-            @Override
-            public String getFragmentShader() {
-                return "whatever";
-            }
-        };
-        filter.copy();
-    }
-
-    @Test
-    public void testOnCopy() {
-        filter = new TestFilter();
-        BaseFilter other = filter.copy();
-        assertTrue(other instanceof TestFilter);
-    }
-
-    @Test
-    public void testCopy_withSize() {
-        filter = new TestFilter();
-        filter.setSize(WIDTH, HEIGHT);
-        BaseFilter other = filter.copy();
-        assertEquals(WIDTH, other.size.getWidth());
-        assertEquals(HEIGHT, other.size.getHeight());
-    }
-
-    @Test
-    public void testCopy_withParameter1() {
-        filter = new TestFilter();
-        filter.setParameter1(0.5F);
-        TestFilter other = (TestFilter) filter.copy();
-        assertEquals(filter.getParameter1(), other.getParameter1(), 0.001F);
-    }
-
-    @Test
-    public void testCopy_withParameter2() {
-        filter = new TestFilter();
-        filter.setParameter2(0.5F);
-        TestFilter other = (TestFilter) filter.copy();
-        assertEquals(filter.getParameter2(), other.getParameter2(), 0.001F);
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/filter/FilterParserTest.java

@@ -1,52 +0,0 @@
-package com.otaliastudios.cameraview.filter;
-
-
-import android.content.res.TypedArray;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.R;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static junit.framework.TestCase.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class FilterParserTest extends BaseTest {
-
-    @Test
-    public void testFallback() {
-        TypedArray array = mock(TypedArray.class);
-        when(array.hasValue(R.styleable.CameraView_cameraFilter)).thenReturn(false);
-        when(array.getString(R.styleable.CameraView_cameraFilter)).thenReturn(null);
-        FilterParser parser = new FilterParser(array);
-        assertNotNull(parser.getFilter());
-        assertTrue(parser.getFilter() instanceof NoFilter);
-    }
-    @Test
-    public void testConstructor() {
-        TypedArray array = mock(TypedArray.class);
-        when(array.hasValue(R.styleable.CameraView_cameraFilter)).thenReturn(true);
-        when(array.getString(R.styleable.CameraView_cameraFilter)).thenReturn(MyFilter.class.getName());
-        FilterParser parser = new FilterParser(array);
-        assertNotNull(parser.getFilter());
-        assertTrue(parser.getFilter() instanceof MyFilter);
-    }
-
-    public static class MyFilter extends BaseFilter {
-        @NonNull
-        @Override
-        public String getFragmentShader() {
-            return createDefaultFragmentShader();
-        }
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/filter/FiltersTest.java

@@ -1,30 +0,0 @@
-package com.otaliastudios.cameraview.filter;
-
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class FiltersTest extends BaseTest {
-
-    @Test
-    public void testNewInstance() {
-        // At least tests that all our default filters have a no-args constructor.
-        Filters[] filtersArray = Filters.values();
-        for (Filters filters : filtersArray) {
-            Filter filter = filters.newInstance();
-            assertNotNull(filter);
-        }
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/filter/MultiFilterTest.java

@@ -1,212 +0,0 @@
-package com.otaliastudios.cameraview.filter;
-
-
-import android.opengl.GLES20;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseEglTest;
-import com.otaliastudios.cameraview.filters.AutoFixFilter;
-import com.otaliastudios.cameraview.filters.BrightnessFilter;
-import com.otaliastudios.cameraview.filters.DuotoneFilter;
-import com.otaliastudios.cameraview.filters.VignetteFilter;
-import com.otaliastudios.cameraview.internal.GlTextureDrawer;
-import com.otaliastudios.opengl.program.GlProgram;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class MultiFilterTest extends BaseEglTest {
-
-    @Test
-    public void testConstructor1() {
-        MultiFilter multiFilter = new MultiFilter(
-                new DuotoneFilter(),
-                new AutoFixFilter()
-        );
-        assertEquals(2, multiFilter.filters.size());
-    }
-
-    @Test
-    public void testConstructor2() {
-        List<Filter> filters = new ArrayList<>();
-        filters.add(new DuotoneFilter());
-        filters.add(new AutoFixFilter());
-        MultiFilter multiFilter = new MultiFilter(filters);
-        assertEquals(2, multiFilter.filters.size());
-    }
-
-    @Test
-    public void testAddFilter() {
-        MultiFilter multiFilter = new MultiFilter();
-        assertEquals(0, multiFilter.filters.size());
-        multiFilter.addFilter(new DuotoneFilter());
-        assertEquals(1, multiFilter.filters.size());
-        multiFilter.addFilter(new AutoFixFilter());
-        assertEquals(2, multiFilter.filters.size());
-    }
-
-    @Test
-    public void testAddFilter_multi() {
-        MultiFilter multiFilter = new MultiFilter(new DuotoneFilter());
-        assertEquals(1, multiFilter.filters.size());
-        MultiFilter other = new MultiFilter(
-                new AutoFixFilter(),
-                new BrightnessFilter(),
-                new VignetteFilter());
-        multiFilter.addFilter(other);
-        assertEquals(4, multiFilter.filters.size());
-    }
-
-    @Test
-    public void testSetSize() {
-        DuotoneFilter filter = new DuotoneFilter();
-        MultiFilter multiFilter = new MultiFilter(filter);
-        MultiFilter.State state = multiFilter.states.get(filter);
-        assertNotNull(state);
-        assertNull(state.size);
-        multiFilter.setSize(WIDTH, HEIGHT);
-        assertNotNull(state.size);
-    }
-
-    @Test
-    public void testCopy() {
-        DuotoneFilter filter = spy(new DuotoneFilter());
-        MultiFilter multiFilter = new MultiFilter(filter);
-        MultiFilter multiFilterCopy = (MultiFilter) multiFilter.copy();
-        assertEquals(1, multiFilterCopy.filters.size());
-        verify(filter, times(1)).onCopy();
-    }
-
-    @Test
-    public void testParameter1() {
-        DuotoneFilter filter = new DuotoneFilter();
-        MultiFilter multiFilter = new MultiFilter(filter);
-        float desired = 0.21582F; // whatever
-        multiFilter.setParameter1(desired);
-        assertEquals(desired, multiFilter.getParameter1(), 0.001F);
-        assertEquals(desired, filter.getParameter1(), 0.001F);
-    }
-
-    @Test
-    public void testParameter2() {
-        DuotoneFilter filter = new DuotoneFilter();
-        MultiFilter multiFilter = new MultiFilter(filter);
-        float desired = 0.21582F; // whatever
-        multiFilter.setParameter2(desired);
-        assertEquals(desired, multiFilter.getParameter2(), 0.001F);
-        assertEquals(desired, filter.getParameter2(), 0.001F);
-    }
-
-    @Test
-    public void testOnCreate_isLazy() {
-        DuotoneFilter filter = spy(new DuotoneFilter());
-        MultiFilter multiFilter = new MultiFilter(filter);
-
-        int program = GlProgram.create(multiFilter.getVertexShader(),
-                multiFilter.getFragmentShader());
-        multiFilter.onCreate(program);
-        verify(filter, never()).onCreate(anyInt());
-
-        multiFilter.onDestroy();
-        GLES20.glDeleteProgram(program);
-        verify(filter, never()).onDestroy();
-    }
-
-    @Test
-    public void testDraw_simple() {
-        DuotoneFilter filter = spy(new DuotoneFilter());
-        MultiFilter multiFilter = new MultiFilter(filter);
-        multiFilter.setSize(WIDTH, HEIGHT);
-        GlTextureDrawer drawer = new GlTextureDrawer();
-        drawer.setFilter(multiFilter);
-        float[] matrix = drawer.getTextureTransform();
-        drawer.draw(0L);
-        drawer.release();
-
-        // The child should have experienced the whole lifecycle.
-        verify(filter, atLeastOnce()).getVertexShader();
-        verify(filter, atLeastOnce()).getFragmentShader();
-        verify(filter, atLeastOnce()).setSize(anyInt(), anyInt());
-        verify(filter, times(1)).onCreate(anyInt());
-        verify(filter, times(1)).draw(0L, matrix);
-        verify(filter, times(1)).onDestroy();
-    }
-
-    @Test
-    public void testDraw_multi() {
-        // Want to test that when filter1 is drawn, the current framebuffer is a
-        // non-default one. When filter2 is drawn, the current framebuffer is 0.
-        final DuotoneFilter filter1 = spy(new DuotoneFilter());
-        final DuotoneFilter filter2 = spy(new DuotoneFilter());
-        final MultiFilter multiFilter = new MultiFilter(filter1, filter2);
-        multiFilter.setSize(WIDTH, HEIGHT);
-        GlTextureDrawer drawer = new GlTextureDrawer();
-        drawer.setFilter(multiFilter);
-        float[] matrix = drawer.getTextureTransform();
-        final int[] result = new int[1];
-
-        doAnswer(new Answer() {
-            @Override
-            public Object answer(InvocationOnMock invocation) {
-                MultiFilter.State state = multiFilter.states.get(filter1);
-                assertNotNull(state);
-                assertTrue(state.isProgramCreated);
-                assertTrue(state.isFramebufferCreated);
-
-                GLES20.glGetIntegerv(GLES20.GL_FRAMEBUFFER_BINDING, result, 0);
-                // assertTrue(result[0] != 0);
-                return null;
-            }
-        }).when(filter1).draw(0L, matrix);
-
-        // Note: second filter is drawn with the identity matrix!
-        doAnswer(new Answer() {
-            @Override
-            public Object answer(InvocationOnMock invocation) {
-                // The last filter has no FBO / texture.
-                MultiFilter.State state = multiFilter.states.get(filter2);
-                assertNotNull(state);
-                assertTrue(state.isProgramCreated);
-                assertFalse(state.isFramebufferCreated);
-
-                GLES20.glGetIntegerv(GLES20.GL_FRAMEBUFFER_BINDING, result, 0);
-                assertEquals(0, result[0]);
-                return null;
-
-            }
-        }).when(filter2).draw(eq(0L), any(float[].class));
-
-        drawer.draw(0L);
-        drawer.release();
-
-        // Verify that both are drawn.
-        verify(filter1, times(1)).draw(0L, matrix);
-        verify(filter2, times(1)).draw(eq(0L), any(float[].class));
-    }
-
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/filter/NoFilterTest.java

@@ -1,35 +0,0 @@
-package com.otaliastudios.cameraview.filter;
-
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class NoFilterTest extends BaseTest {
-
-    public static class DummyFilter extends BaseFilter {
-        @NonNull
-        @Override
-        public String getFragmentShader() {
-            return "whatever";
-        }
-    }
-
-    @Test
-    public void testGetFragmentShader() {
-        NoFilter filter = new NoFilter();
-        String defaultFragmentShader = new DummyFilter().createDefaultFragmentShader();
-        assertEquals(defaultFragmentShader, filter.getFragmentShader());
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/filter/SimpleFilterTest.java

@@ -1,43 +0,0 @@
-package com.otaliastudios.cameraview.filter;
-
-
-import android.content.res.TypedArray;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.R;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static junit.framework.TestCase.assertNotNull;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class SimpleFilterTest extends BaseTest {
-
-    @Test
-    public void testGetFragmentShader() {
-        String shader = "shader";
-        SimpleFilter filter = new SimpleFilter(shader);
-        assertEquals(shader, filter.getFragmentShader());
-    }
-
-    @Test
-    public void testCopy() {
-        String shader = "shader";
-        SimpleFilter filter = new SimpleFilter(shader);
-        BaseFilter copy = filter.copy();
-        assertTrue(copy instanceof SimpleFilter);
-        SimpleFilter simpleCopy = (SimpleFilter) copy;
-        assertEquals(shader, simpleCopy.getFragmentShader());
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/frame/ByteBufferFrameManagerTest.java

@@ -1,112 +0,0 @@
-package com.otaliastudios.cameraview.frame;
-
-
-import android.graphics.ImageFormat;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.engine.offset.Angles;
-import com.otaliastudios.cameraview.size.Size;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class ByteBufferFrameManagerTest extends BaseTest {
-
-    private final Angles angles = new Angles();
-    private ByteBufferFrameManager.BufferCallback callback;
-
-    @Before
-    public void setUp() {
-        callback = mock(ByteBufferFrameManager.BufferCallback.class);
-    }
-
-    @After
-    public void tearDown() {
-        callback = null;
-    }
-
-    @Test
-    public void testAllocate() {
-        ByteBufferFrameManager manager = new ByteBufferFrameManager(1, callback);
-        manager.setUp(ImageFormat.NV21, new Size(50, 50), angles);
-        verify(callback, times(1)).onBufferAvailable(any(byte[].class));
-        reset(callback);
-
-        manager = new ByteBufferFrameManager(5, callback);
-        manager.setUp(ImageFormat.NV21, new Size(50, 50), angles);
-        verify(callback, times(5)).onBufferAvailable(any(byte[].class));
-    }
-
-    @Test
-    public void testOnFrameReleased_alreadyFull() {
-        ByteBufferFrameManager manager = new ByteBufferFrameManager(1, callback);
-        manager.setUp(ImageFormat.NV21, new Size(50, 50), angles);
-        int length = manager.getFrameBytes();
-
-        Frame frame1 = manager.getFrame(new byte[length], 0);
-        assertNotNull(frame1);
-        // Since frame1 is already taken and poolSize = 1, getFrame() would return null.
-        // To create a new frame, freeze the first one.
-        Frame frame2 = frame1.freeze();
-        // Now release the first frame so it goes back into the pool.
-        manager.onFrameReleased(frame1, (byte[]) frame1.getData());
-        reset(callback);
-        // Release the second. The pool is already full, so onBufferAvailable should not be called
-        // since this Frame instance will NOT be reused.
-        manager.onFrameReleased(frame2, (byte[]) frame2.getData());
-        verify(callback, never()).onBufferAvailable((byte[]) frame2.getData());
-    }
-
-    @Test
-    public void testOnFrameReleased_sameLength() {
-        ByteBufferFrameManager manager = new ByteBufferFrameManager(1, callback);
-        manager.setUp(ImageFormat.NV21, new Size(50, 50), angles);
-        int length = manager.getFrameBytes();
-
-        // A camera preview frame comes. Request a frame.
-        byte[] picture = new byte[length];
-        Frame frame = manager.getFrame(picture, 0);
-        assertNotNull(frame);
-
-        // Release the frame and ensure that onBufferAvailable is called.
-        reset(callback);
-        manager.onFrameReleased(frame, (byte[]) frame.getData());
-        verify(callback, times(1)).onBufferAvailable(picture);
-    }
-
-    @Test
-    public void testOnFrameReleased_differentLength() {
-        ByteBufferFrameManager manager = new ByteBufferFrameManager(1, callback);
-        manager.setUp(ImageFormat.NV21, new Size(50, 50), angles);
-        int length = manager.getFrameBytes();
-
-        // A camera preview frame comes. Request a frame.
-        byte[] picture = new byte[length];
-        Frame frame = manager.getFrame(picture, 0);
-        assertNotNull(frame);
-
-        // Don't release the frame. Change the allocation size.
-        manager.setUp(ImageFormat.NV16, new Size(15, 15), angles);
-
-        // Now release the old frame and ensure that onBufferAvailable is NOT called,
-        // because the released data has wrong length.
-        manager.onFrameReleased(frame, (byte[]) frame.getData());
-        reset(callback);
-        verify(callback, never()).onBufferAvailable(picture);
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/frame/FrameManagerTest.java

@@ -1,73 +0,0 @@
-package com.otaliastudios.cameraview.frame;
-
-
-import android.graphics.ImageFormat;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.engine.offset.Angles;
-import com.otaliastudios.cameraview.size.Size;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class FrameManagerTest extends BaseTest {
-
-    private final Angles angles = new Angles();
-
-    @Test
-    public void testFrameRecycling() {
-        // A 1-pool manager will always recycle the same frame.
-        FrameManager<String> manager = new FrameManager<String>(1, String.class) {
-            @Override
-            protected void onFrameDataReleased(@NonNull String data, boolean recycled) { }
-
-            @NonNull
-            @Override
-            protected String onCloneFrameData(@NonNull String data) {
-                return data;
-            }
-        };
-        manager.setUp(ImageFormat.NV21, new Size(50, 50), angles);
-
-        Frame first = manager.getFrame("foo", 0);
-        assertNotNull(first);
-        first.release();
-        Frame second = manager.getFrame("bar", 0);
-        assertNotNull(second);
-        second.release();
-        assertEquals(first, second);
-    }
-
-    @Test
-    public void testGetFrame() {
-        FrameManager<String> manager = new FrameManager<String>(1, String.class) {
-            @Override
-            protected void onFrameDataReleased(@NonNull String data, boolean recycled) { }
-
-            @NonNull
-            @Override
-            protected String onCloneFrameData(@NonNull String data) {
-                return data;
-            }
-        };
-        manager.setUp(ImageFormat.NV21, new Size(50, 50), angles);
-
-        Frame first = manager.getFrame("foo", 0);
-        assertNotNull(first);
-        Frame second = manager.getFrame("bar", 0);
-        assertNull(second);
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/gesture/GestureFinderTest.java

@@ -1,90 +0,0 @@
-package com.otaliastudios.cameraview.gesture;
-
-
-import android.annotation.TargetApi;
-import android.content.Context;
-
-import androidx.annotation.NonNull;
-import androidx.test.espresso.ViewInteraction;
-import androidx.test.espresso.matcher.RootMatchers;
-import androidx.test.rule.ActivityTestRule;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.TestActivity;
-import com.otaliastudios.cameraview.tools.Op;
-
-import org.hamcrest.Matchers;
-import org.junit.Before;
-import org.junit.Rule;
-
-import static androidx.test.espresso.Espresso.onView;
-
-@TargetApi(17)
-public abstract class GestureFinderTest<T extends GestureFinder> extends BaseTest {
-
-    protected abstract T createFinder(@NonNull GestureFinder.Controller controller);
-
-    @Rule
-    public ActivityTestRule<TestActivity> rule = new ActivityTestRule<>(TestActivity.class);
-
-    @SuppressWarnings("WeakerAccess")
-    protected T finder;
-    @SuppressWarnings("WeakerAccess")
-    protected Op<Gesture> touchOp;
-    @SuppressWarnings("WeakerAccess")
-    protected ViewGroup layout;
-
-    @Before
-    public void setUp() {
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                TestActivity a = rule.getActivity();
-                layout = new FrameLayout(a);
-                finder = createFinder(new Controller());
-                finder.setActive(true);
-                a.inflate(layout);
-
-                touchOp = new Op<>(false);
-                layout.setOnTouchListener(new View.OnTouchListener() {
-                    @Override
-                    public boolean onTouch(View view, MotionEvent motionEvent) {
-                        boolean found = finder.onTouchEvent(motionEvent);
-                        if (found) touchOp.controller().end(finder.getGesture());
-                        return true;
-                    }
-                });
-            }
-        });
-    }
-
-    @SuppressWarnings("WeakerAccess")
-    protected final ViewInteraction onLayout() {
-        return onView(Matchers.<View>is(layout))
-                .inRoot(RootMatchers.withDecorView(
-                        Matchers.is(rule.getActivity().getWindow().getDecorView())));
-    }
-
-    private class Controller implements GestureFinder.Controller {
-
-        @NonNull
-        @Override
-        public Context getContext() {
-            return layout.getContext();
-        }
-
-        @Override
-        public int getWidth() {
-            return layout.getWidth();
-        }
-
-        @Override
-        public int getHeight() {
-            return layout.getHeight();
-        }
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/gesture/PinchGestureFinderTest.java

@@ -1,71 +0,0 @@
-package com.otaliastudios.cameraview.gesture;
-
-
-import androidx.annotation.NonNull;
-import androidx.test.espresso.ViewAction;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.tools.SdkExclude;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * On API 26 these tests fail during Espresso's inRoot() - the window never gains focus.
- * This might be due to a system popup or something similar.
- */
-@SdkExclude(minSdkVersion = 26, maxSdkVersion = 26)
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class PinchGestureFinderTest extends GestureFinderTest<PinchGestureFinder> {
-
-    @Override
-    protected PinchGestureFinder createFinder(@NonNull GestureFinder.Controller controller) {
-        return new PinchGestureFinder(controller);
-    }
-
-    @Test
-    public void testDefaults() {
-        assertEquals(finder.getGesture(), Gesture.PINCH);
-        assertEquals(finder.getPoints().length, 2);
-        assertEquals(finder.getPoints()[0].x, 0, 0);
-        assertEquals(finder.getPoints()[0].y, 0, 0);
-        assertEquals(finder.getPoints()[1].x, 0, 0);
-        assertEquals(finder.getPoints()[1].y, 0, 0);
-    }
-
-    // TODO: test pinch open
-    // TODO: test pinch close
-    // TODO: test pinch disabled
-
-    // Possible approach: mimic pinch gesture and let espresso test.
-    // Too lazy to do this now, but it's possible.
-    // https://stackoverflow.com/questions/11523423/how-to-generate-zoom-pinch-gesture-for-testing-for-android
-
-    public abstract class PinchViewAction implements ViewAction {
-    }
-
-    private void testPinch(ViewAction action, boolean increasing) {
-        touchOp.listen();
-        touchOp.controller().start();
-        onLayout().perform(action);
-        Gesture found = touchOp.await(10000);
-        assertNotNull(found);
-
-        // How will this move  our parameter?
-        float curr = 0.5f, min = 0f, max = 1f;
-        float newValue = finder.computeValue(curr, min, max);
-        if (increasing) {
-            assertTrue(newValue > curr);
-            assertTrue(newValue <= max);
-        } else {
-            assertTrue(newValue < curr);
-            assertTrue(newValue >= min);
-        }
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/gesture/ScrollGestureFinderTest.java

@@ -1,98 +0,0 @@
-package com.otaliastudios.cameraview.gesture;
-
-
-import androidx.annotation.NonNull;
-import androidx.test.espresso.ViewAction;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.tools.SdkExclude;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static androidx.test.espresso.action.ViewActions.swipeDown;
-import static androidx.test.espresso.action.ViewActions.swipeLeft;
-import static androidx.test.espresso.action.ViewActions.swipeRight;
-import static androidx.test.espresso.action.ViewActions.swipeUp;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * On API 26 these tests fail during Espresso's inRoot() - the window never gains focus.
- * This might be due to a system popup or something similar.
- */
-@SdkExclude(minSdkVersion = 26, maxSdkVersion = 26)
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class ScrollGestureFinderTest extends GestureFinderTest<ScrollGestureFinder> {
-
-    private final static long WAIT = 2000; // 500 was too short
-
-    @Override
-    protected ScrollGestureFinder createFinder(@NonNull GestureFinder.Controller controller) {
-        return new ScrollGestureFinder(controller);
-    }
-
-    @Test
-    public void testDefaults() {
-        assertNull(finder.mType);
-        assertEquals(finder.getPoints().length, 2);
-        assertEquals(finder.getPoints()[0].x, 0, 0);
-        assertEquals(finder.getPoints()[0].y, 0, 0);
-        assertEquals(finder.getPoints()[1].x, 0, 0);
-        assertEquals(finder.getPoints()[1].y, 0, 0);
-    }
-
-    @Test
-    public void testScrollDisabled() {
-        finder.setActive(false);
-        touchOp.listen();
-        touchOp.controller().start();
-        onLayout().perform(swipeUp());
-        Gesture found = touchOp.await(WAIT);
-        assertNull(found);
-    }
-
-    private void testScroll(ViewAction scroll, Gesture expected, boolean increasing) {
-        touchOp.listen();
-        touchOp.controller().start();
-        onLayout().perform(scroll);
-        Gesture found = touchOp.await(WAIT);
-        assertEquals(found, expected);
-
-        // How will this move our parameter?
-        float curr = 0.5f, min = 0f, max = 1f;
-        float newValue = finder.computeValue(curr, min, max);
-        if (increasing) {
-            assertTrue(newValue >= curr);
-            assertTrue(newValue <= max);
-        } else {
-            assertTrue(newValue <= curr);
-            assertTrue(newValue >= min);
-        }
-    }
-
-    @Test
-    public void testScrollLeft() {
-        testScroll(swipeLeft(), Gesture.SCROLL_HORIZONTAL, false);
-    }
-
-    @Test
-    public void testScrollRight() {
-        testScroll(swipeRight(), Gesture.SCROLL_HORIZONTAL, true);
-    }
-
-    @Test
-    public void testScrollUp() {
-        testScroll(swipeUp(), Gesture.SCROLL_VERTICAL, true);
-    }
-
-    @Test
-    public void testScrollDown() {
-        testScroll(swipeDown(), Gesture.SCROLL_VERTICAL, false);
-    }
-
-
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/gesture/TapGestureFinderTest.java

@@ -1,85 +0,0 @@
-package com.otaliastudios.cameraview.gesture;
-
-
-import androidx.annotation.NonNull;
-import androidx.test.espresso.action.GeneralClickAction;
-import androidx.test.espresso.action.GeneralLocation;
-import androidx.test.espresso.action.Press;
-import androidx.test.espresso.action.Tap;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-import android.view.InputDevice;
-import android.view.MotionEvent;
-
-import com.otaliastudios.cameraview.tools.SdkExclude;
-import com.otaliastudios.cameraview.size.Size;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static androidx.test.espresso.action.ViewActions.*;
-import static org.junit.Assert.*;
-
-/**
- * On API 26 these tests fail during Espresso's inRoot() - the window never gains focus.
- * This might be due to a system popup or something similar.
- */
-@SdkExclude(minSdkVersion = 26, maxSdkVersion = 26)
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class TapGestureFinderTest extends GestureFinderTest<TapGestureFinder> {
-
-    @Override
-    protected TapGestureFinder createFinder(@NonNull GestureFinder.Controller controller) {
-        return new TapGestureFinder(controller);
-    }
-
-    @Test
-    public void testDefaults() {
-        assertNull(finder.mType);
-        assertEquals(finder.getPoints().length, 1);
-        assertEquals(finder.getPoints()[0].x, 0, 0);
-        assertEquals(finder.getPoints()[0].y, 0, 0);
-    }
-
-    @Test
-    public void testTap() {
-        touchOp.listen();
-        touchOp.controller().start();
-        GeneralClickAction a = new GeneralClickAction(
-                Tap.SINGLE, GeneralLocation.CENTER, Press.FINGER,
-                InputDevice.SOURCE_UNKNOWN, MotionEvent.BUTTON_PRIMARY);
-        onLayout().perform(a);
-        Gesture found = touchOp.await(500);
-
-        assertEquals(found, Gesture.TAP);
-        Size size = rule.getActivity().getContentSize();
-        assertEquals(finder.getPoints()[0].x, (size.getWidth() / 2f), 1f);
-        assertEquals(finder.getPoints()[0].y, (size.getHeight() / 2f), 1f);
-    }
-
-    @Test
-    public void testTapWhileDisabled() {
-        finder.setActive(false);
-        touchOp.listen();
-        touchOp.controller().start();
-        onLayout().perform(click());
-        Gesture found = touchOp.await(500);
-        assertNull(found);
-    }
-
-    @Test
-    public void testLongTap() {
-        touchOp.listen();
-        touchOp.controller().start();
-        GeneralClickAction a = new GeneralClickAction(
-                Tap.LONG, GeneralLocation.CENTER, Press.FINGER,
-                InputDevice.SOURCE_UNKNOWN, MotionEvent.BUTTON_PRIMARY);
-        onLayout().perform(a);
-        Gesture found = touchOp.await(500);
-        assertEquals(found, Gesture.LONG_TAP);
-        Size size = rule.getActivity().getContentSize();
-        assertEquals(finder.getPoints()[0].x, (size.getWidth() / 2f), 1f);
-        assertEquals(finder.getPoints()[0].y, (size.getHeight() / 2f), 1f);
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/internal/CamcorderProfilesTest.java

@@ -1,61 +0,0 @@
-package com.otaliastudios.cameraview.internal;
-
-
-import android.media.CamcorderProfile;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.CameraUtils;
-import com.otaliastudios.cameraview.internal.CamcorderProfiles;
-import com.otaliastudios.cameraview.tools.SdkExclude;
-import com.otaliastudios.cameraview.size.Size;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertEquals;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class CamcorderProfilesTest extends BaseTest {
-
-    private String getCameraId() {
-        if (CameraUtils.hasCameras(getContext())) {
-            return "0";
-        }
-        return null;
-    }
-
-    @Test
-    public void testInvalidCameraReturnsLowest() {
-        CamcorderProfile invalid = CamcorderProfiles.get("invalid", new Size(100, 100));
-        CamcorderProfile lowest = CamcorderProfile.get(CamcorderProfile.QUALITY_LOW);
-        assertEquals(lowest.videoFrameWidth, invalid.videoFrameWidth);
-        assertEquals(lowest.videoFrameHeight, invalid.videoFrameHeight);
-    }
-
-    /**
-     * For some reason this fails on emulator 26.
-     */
-    @SdkExclude(minSdkVersion = 26, maxSdkVersion = 26)
-    @Test
-    public void testGet() {
-        String cameraId = getCameraId();
-        if (cameraId == null) return;
-        int cameraIdInt = Integer.parseInt(cameraId);
-
-        // Not much we can test. Let's just ask for lowest and highest.
-        CamcorderProfile low = CamcorderProfiles.get(cameraId, new Size(1, 1));
-        CamcorderProfile high = CamcorderProfiles.get(cameraId, new Size(Integer.MAX_VALUE, Integer.MAX_VALUE));
-
-        // Compare with lowest
-        CamcorderProfile lowest = CamcorderProfile.get(cameraIdInt, CamcorderProfile.QUALITY_LOW);
-        CamcorderProfile highest = CamcorderProfile.get(cameraIdInt, CamcorderProfile.QUALITY_HIGH);
-        assertEquals(lowest.videoFrameWidth, low.videoFrameWidth);
-        assertEquals(lowest.videoFrameHeight, low.videoFrameHeight);
-        assertEquals(highest.videoFrameWidth, high.videoFrameWidth);
-        assertEquals(highest.videoFrameHeight, high.videoFrameHeight);
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/internal/CropHelperTest.java

@@ -1,53 +0,0 @@
-package com.otaliastudios.cameraview.internal;
-
-
-import android.graphics.Rect;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.internal.CropHelper;
-import com.otaliastudios.cameraview.size.AspectRatio;
-import com.otaliastudios.cameraview.size.Size;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertTrue;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class CropHelperTest extends BaseTest {
-
-    @Test
-    public void testCrop() {
-        testCrop(new Size(1600, 1600), AspectRatio.of(16, 16));
-        testCrop(new Size(1600, 1600), AspectRatio.of(16, 9));
-        testCrop(new Size(1600, 1600), AspectRatio.of(9, 16));
-    }
-
-    private void testCrop(final Size inSize, final AspectRatio outRatio) {
-        AspectRatio inRatio = AspectRatio.of(inSize.getWidth(), inSize.getHeight());
-        Rect out = CropHelper.computeCrop(inSize, outRatio);
-        Size outSize = new Size(out.width(), out.height());
-        assertTrue(outRatio.matches(outSize));
-
-        if (outRatio.matches(inSize)) {
-            // They are equal.
-            assertEquals(outSize.getWidth(), inSize.getWidth());
-            assertEquals(outSize.getHeight(), inSize.getHeight());
-        } else if (outRatio.toFloat() > inRatio.toFloat()) {
-            // Width must match.
-            assertEquals(outSize.getWidth(), inSize.getWidth());
-            assertNotEquals(outSize.getHeight(), inSize.getHeight());
-        } else {
-            // Height must match.
-            assertEquals(outSize.getHeight(), inSize.getHeight());
-            assertNotEquals(outSize.getWidth(), inSize.getWidth());
-        }
-    }
-
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/internal/DeviceEncodersTest.java

@@ -1,219 +0,0 @@
-package com.otaliastudios.cameraview.internal;
-
-
-import android.media.MediaCodecInfo;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.MediumTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.size.AspectRatio;
-import com.otaliastudios.cameraview.size.Size;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-
-@RunWith(AndroidJUnit4.class)
-@MediumTest
-public class DeviceEncodersTest extends BaseTest {
-
-    // This is guaranteed to work, see
-    // https://developer.android.com/guide/topics/media/media-formats
-    private final static Size GUARANTEED_SIZE = new Size(176, 144);
-
-    private boolean enabled;
-
-    @Before
-    public void setUp() {
-        enabled = DeviceEncoders.ENABLED;
-    }
-
-    @After
-    public void tearDown() {
-        DeviceEncoders.ENABLED = enabled;
-    }
-
-    @NonNull
-    private DeviceEncoders create() {
-        return new DeviceEncoders(DeviceEncoders.MODE_RESPECT_ORDER,
-                "video/avc",
-                "audio/mp4a-latm",
-                0,
-                0);
-    }
-
-    @Test
-    public void testGetDeviceEncoders() {
-        DeviceEncoders deviceEncoders = create();
-        if (DeviceEncoders.ENABLED) {
-            List<MediaCodecInfo> infos = deviceEncoders.getDeviceEncoders();
-            for (MediaCodecInfo info : infos) {
-                assertTrue(info.isEncoder());
-            }
-        }
-    }
-
-    @Test
-    public void testIsHardwareEncoder() {
-        DeviceEncoders deviceEncoders = create();
-        if (DeviceEncoders.ENABLED) {
-            assertFalse(deviceEncoders.isHardwareEncoder("OMX.google.encoder"));
-            assertTrue(deviceEncoders.isHardwareEncoder("OMX.other.encoder"));
-        }
-    }
-
-    @Test
-    public void testFindDeviceEncoder() {
-        DeviceEncoders deviceEncoders = create();
-        if (DeviceEncoders.ENABLED) {
-            List<MediaCodecInfo> allEncoders = deviceEncoders.getDeviceEncoders();
-            MediaCodecInfo encoder = deviceEncoders.findDeviceEncoder(allEncoders,
-                    "video/avc", DeviceEncoders.MODE_RESPECT_ORDER, 0);
-            assertNotNull(encoder);
-            List<String> encoderTypes = Arrays.asList(encoder.getSupportedTypes());
-            assertTrue(encoderTypes.contains("video/avc"));
-        }
-    }
-
-    @Test
-    public void testGetVideoEncoder() {
-        if (DeviceEncoders.ENABLED) {
-            DeviceEncoders deviceEncoders = create();
-            assertNotNull(deviceEncoders.getVideoEncoder());
-        }
-
-        DeviceEncoders.ENABLED = false;
-        DeviceEncoders deviceEncoders = create();
-        assertNull(deviceEncoders.getVideoEncoder());
-    }
-
-    @Test
-    public void testGetAudioEncoder() {
-        if (DeviceEncoders.ENABLED) {
-            DeviceEncoders deviceEncoders = create();
-            assertNotNull(deviceEncoders.getAudioEncoder());
-        }
-
-        DeviceEncoders.ENABLED = false;
-        DeviceEncoders deviceEncoders = create();
-        assertNull(deviceEncoders.getAudioEncoder());
-    }
-
-    @Test
-    public void testGetSupportedVideoSize_disabled() {
-        DeviceEncoders.ENABLED = false;
-        DeviceEncoders deviceEncoders = create();
-        Size input = new Size(GUARANTEED_SIZE.getWidth(), GUARANTEED_SIZE.getHeight());
-        Size output = deviceEncoders.getSupportedVideoSize(input);
-        assertSame(input, output);
-    }
-
-    @Test
-    public void testGetSupportedVideoSize_scalesDown() {
-        DeviceEncoders deviceEncoders = create();
-        if (DeviceEncoders.ENABLED) {
-            Size input = new Size(
-                    GUARANTEED_SIZE.getWidth() * 1000,
-                    GUARANTEED_SIZE.getHeight() * 1000);
-            try {
-                Size output = deviceEncoders.getSupportedVideoSize(input);
-                assertTrue(AspectRatio.of(input).matches(output, 0.01F));
-            } catch (RuntimeException e) {
-                // The scaled down size happens to be not supported.
-                // I see no way of testing this easily if we're not sure of supported ranges.
-                // This depends highly on the alignment since scaling down, while keeping AR,
-                // can change the alignment and require width / height changes.
-            }
-        }
-    }
-
-    @Test
-    public void testGetSupportedVideoSize_aligns() {
-        DeviceEncoders deviceEncoders = create();
-        if (DeviceEncoders.ENABLED) {
-            Size input = new Size(GUARANTEED_SIZE.getWidth() + 1,
-                    GUARANTEED_SIZE.getHeight() + 1);
-            Size output = deviceEncoders.getSupportedVideoSize(input);
-            assertTrue(output.getWidth() <= input.getWidth());
-            assertTrue(output.getHeight() <= input.getHeight());
-        }
-    }
-
-    @Test
-    public void testGetSupportedVideoBitRate_disabled() {
-        DeviceEncoders.ENABLED = false;
-        DeviceEncoders deviceEncoders = create();
-        int input = 1000;
-        int output = deviceEncoders.getSupportedVideoBitRate(input);
-        assertEquals(input, output);
-    }
-
-    @Test
-    public void testGetSupportedVideoBitRate_enabled() {
-        DeviceEncoders deviceEncoders = create();
-        if (DeviceEncoders.ENABLED) {
-            // Ensure it's clamped: we can pass a negative value and check it's >= 0.
-            int input = -1000;
-            int output = deviceEncoders.getSupportedVideoBitRate(input);
-            assertNotEquals(input, output);
-            assertTrue(output >= 0);
-        }
-    }
-
-    @Test
-    public void testGetSupportedAudioBitRate_disabled() {
-        DeviceEncoders.ENABLED = false;
-        DeviceEncoders deviceEncoders = create();
-        int input = 1000;
-        int output = deviceEncoders.getSupportedAudioBitRate(input);
-        assertEquals(input, output);
-    }
-
-    @Test
-    public void testGetSupportedAudioBitRate_enabled() {
-        DeviceEncoders deviceEncoders = create();
-        if (DeviceEncoders.ENABLED) {
-            // Ensure it's clamped: we can pass a negative value and check it's >= 0.
-            int input = -1000;
-            int output = deviceEncoders.getSupportedAudioBitRate(input);
-            assertNotEquals(input, output);
-            assertTrue(output >= 0);
-        }
-    }
-
-    @Test
-    public void testGetSupportedFrameRate_disabled() {
-        DeviceEncoders.ENABLED = false;
-        DeviceEncoders deviceEncoders = create();
-        int input = 1000;
-        int output = deviceEncoders.getSupportedVideoFrameRate(GUARANTEED_SIZE, input);
-        assertEquals(input, output);
-    }
-
-    @Test
-    public void testGetSupportedFrameRate_enabled() {
-        DeviceEncoders deviceEncoders = create();
-        if (DeviceEncoders.ENABLED) {
-            // Ensure it's clamped: we can pass a negative value and check it's >= 0.
-            int input = -10;
-            Size inputSize = deviceEncoders.getSupportedVideoSize(GUARANTEED_SIZE);
-            int output = deviceEncoders.getSupportedVideoFrameRate(inputSize, input);
-            assertNotEquals(input, output);
-            assertTrue(output >= 0);
-        }
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/internal/OrientationHelperTest.java

@@ -1,109 +0,0 @@
-package com.otaliastudios.cameraview.internal;
-
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-import android.view.OrientationEventListener;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.internal.OrientationHelper;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class OrientationHelperTest extends BaseTest {
-
-    private OrientationHelper helper;
-    private OrientationHelper.Callback callback;
-
-    @Before
-    public void setUp() {
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                callback = mock(OrientationHelper.Callback.class);
-                helper = new OrientationHelper(getContext(), callback);
-            }
-        });
-    }
-
-    @After
-    public void tearDown() {
-        callback = null;
-        helper = null;
-    }
-
-    @Test
-    public void testEnable() {
-        // On some API levels, enable() needs to be run on the UI thread.
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                assertEquals(helper.getLastDisplayOffset(), -1);
-                assertEquals(helper.getLastDeviceOrientation(), -1);
-
-                helper.enable();
-                assertNotEquals(helper.getLastDisplayOffset(), -1); // Don't know about device orientation.
-
-                // Ensure nothing bad if called twice.
-                helper.enable();
-                assertNotEquals(helper.getLastDisplayOffset(), -1);
-
-                helper.disable();
-                assertEquals(helper.getLastDisplayOffset(), -1);
-                assertEquals(helper.getLastDeviceOrientation(), -1);
-            }
-        });
-    }
-
-    @Test
-    public void testRotation() {
-        // On some API levels, enable() needs to be run on the UI thread.
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                // Sometimes (on some APIs) the helper will trigger an update to 0
-                // right after enabling. But that's fine for us, times(1) will be OK either way.
-                helper.enable();
-                helper.mDeviceOrientationListener.onOrientationChanged(OrientationEventListener.ORIENTATION_UNKNOWN);
-                assertEquals(helper.getLastDeviceOrientation(), 0);
-                helper.mDeviceOrientationListener.onOrientationChanged(10);
-                assertEquals(helper.getLastDeviceOrientation(), 0);
-                helper.mDeviceOrientationListener.onOrientationChanged(-10);
-                assertEquals(helper.getLastDeviceOrientation(), 0);
-                helper.mDeviceOrientationListener.onOrientationChanged(44);
-                assertEquals(helper.getLastDeviceOrientation(), 0);
-                helper.mDeviceOrientationListener.onOrientationChanged(360);
-                assertEquals(helper.getLastDeviceOrientation(), 0);
-
-                // Callback called just once.
-                verify(callback, times(1)).onDeviceOrientationChanged(0);
-
-                helper.mDeviceOrientationListener.onOrientationChanged(90);
-                helper.mDeviceOrientationListener.onOrientationChanged(91);
-                assertEquals(helper.getLastDeviceOrientation(), 90);
-                verify(callback, times(1)).onDeviceOrientationChanged(90);
-
-                helper.mDeviceOrientationListener.onOrientationChanged(180);
-                assertEquals(helper.getLastDeviceOrientation(), 180);
-                verify(callback, times(1)).onDeviceOrientationChanged(180);
-
-                helper.mDeviceOrientationListener.onOrientationChanged(270);
-                assertEquals(helper.getLastDeviceOrientation(), 270);
-                verify(callback, times(1)).onDeviceOrientationChanged(270);
-
-                // It is still 270 after ORIENTATION_UNKNOWN
-                helper.mDeviceOrientationListener.onOrientationChanged(OrientationEventListener.ORIENTATION_UNKNOWN);
-                assertEquals(helper.getLastDeviceOrientation(), 270);
-                verify(callback, times(1)).onDeviceOrientationChanged(270);
-            }
-        });
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/internal/RotationHelperTest.java

@@ -1,53 +0,0 @@
-package com.otaliastudios.cameraview.internal;
-
-
-import android.graphics.ImageFormat;
-import android.graphics.YuvImage;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.internal.RotationHelper;
-import com.otaliastudios.cameraview.size.Size;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class RotationHelperTest extends BaseTest {
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testInvalidRotation1() {
-        RotationHelper.rotate(new byte[10], new Size(1, 1), -1);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testInvalidRotation2() {
-        RotationHelper.rotate(new byte[10], new Size(1, 1), -90);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testInvalidRotation3() {
-        RotationHelper.rotate(new byte[10], new Size(1, 1), 360);
-    }
-
-    @Test
-    public void testRotate() {
-        // Just test that nothing happens.
-        Size inputSize = new Size(160, 90);
-        int inputSizeBits = inputSize.getWidth() * inputSize.getHeight() * ImageFormat.getBitsPerPixel(ImageFormat.NV21);
-        int inputSizeBytes = (int) Math.ceil(inputSizeBits / 8.0d);
-        byte[] input = new byte[inputSizeBytes];
-        byte[] output = RotationHelper.rotate(input, inputSize, 90);
-        assertEquals(input.length, output.length);
-
-        Size outputSize = inputSize.flip();
-        YuvImage image = new YuvImage(output, ImageFormat.NV21, outputSize.getWidth(), outputSize.getHeight(), null);
-        assertNotNull(image);
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/internal/WorkerHandlerTest.java

@@ -1,242 +0,0 @@
-package com.otaliastudios.cameraview.internal;
-
-
-import com.google.android.gms.tasks.Task;
-import com.google.android.gms.tasks.Tasks;
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.internal.WorkerHandler;
-import com.otaliastudios.cameraview.tools.Op;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executor;
-
-import static org.junit.Assert.*;
-import static org.junit.Assert.assertNotNull;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class WorkerHandlerTest extends BaseTest {
-
-    @Test
-    public void testGetFromCache() {
-        WorkerHandler first = WorkerHandler.get("first");
-        WorkerHandler second = WorkerHandler.get("first");
-        assertSame(first, second);
-    }
-
-    @Test
-    public void testGetAnother() {
-        WorkerHandler first = WorkerHandler.get("first");
-        WorkerHandler second = WorkerHandler.get("second");
-        assertNotSame(first, second);
-    }
-
-    @NonNull
-    private Runnable getRunnableForOp(final @NonNull Op<Boolean> op) {
-        return new Runnable() {
-            @Override
-            public void run() {
-                op.controller().end(true);
-            }
-        };
-    }
-
-    @NonNull
-    private Callable<Boolean> getCallableForOp(final @NonNull Op<Boolean> op) {
-        return new Callable<Boolean>() {
-            @Override
-            public Boolean call() {
-                op.controller().end(true);
-                return true;
-            }
-        };
-    }
-
-    @NonNull
-    private Callable<Void> getThrowCallable() {
-        return new Callable<Void>() {
-            @Override
-            public Void call() {
-                throw new RuntimeException("Fake error");
-            }
-        };
-    }
-
-    private void waitOp(@NonNull Op<Boolean> op) {
-        Boolean result = op.await(500);
-        assertNotNull(result);
-        assertTrue(result);
-    }
-
-    @Test
-    public void testFallbackExecute() {
-        final Op<Boolean> op = new Op<>();
-        WorkerHandler.execute(getRunnableForOp(op));
-        waitOp(op);
-    }
-
-    @Test
-    public void testPostRunnable() {
-        WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op = new Op<>();
-        handler.post(getRunnableForOp(op));
-        waitOp(op);
-    }
-
-    @Test
-    public void testPostCallable() {
-        WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op = new Op<>();
-        handler.post(getCallableForOp(op));
-        waitOp(op);
-    }
-
-    @Test
-    public void testPostCallable_throws() {
-        WorkerHandler handler = WorkerHandler.get("handler");
-        Task<Void> task = handler.post(getThrowCallable());
-        try { Tasks.await(task); } catch (ExecutionException | InterruptedException ignore) {}
-        assertTrue(task.isComplete());
-        assertFalse(task.isSuccessful());
-    }
-
-    @Test
-    public void testRunRunnable_background() {
-        WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op = new Op<>();
-        handler.run(getRunnableForOp(op));
-        waitOp(op);
-    }
-
-    @Test
-    public void testRunRunnable_sameThread() {
-        final WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op1 = new Op<>();
-        final Op<Boolean> op2 = new Op<>();
-        handler.post(new Runnable() {
-            @Override
-            public void run() {
-                handler.run(getRunnableForOp(op2));
-                assertTrue(op2.await(0)); // Do not wait.
-                op1.controller().end(true);
-            }
-        });
-        waitOp(op1);
-    }
-
-    @Test
-    public void testRunCallable_background() {
-        WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op = new Op<>();
-        handler.run(getCallableForOp(op));
-        waitOp(op);
-    }
-
-    @Test
-    public void testRunCallable_sameThread() {
-        final WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op1 = new Op<>();
-        final Op<Boolean> op2 = new Op<>();
-        handler.post(new Runnable() {
-            @Override
-            public void run() {
-                handler.run(getCallableForOp(op2));
-                assertTrue(op2.await(0)); // Do not wait.
-                op1.controller().end(true);
-            }
-        });
-        waitOp(op1);
-    }
-
-    @Test
-    public void testRunCallable_sameThread_throws() {
-        final WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op = new Op<>();
-        handler.post(new Runnable() {
-            @Override
-            public void run() {
-                Task<Void> task = handler.run(getThrowCallable());
-                assertTrue(task.isComplete()); // Already complete
-                assertFalse(task.isSuccessful());
-                op.controller().end(true);
-            }
-        });
-        waitOp(op);
-    }
-
-    @Test
-    public void testPostDelayed_tooEarly() {
-        final WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op = new Op<>();
-        handler.post(1000, getRunnableForOp(op));
-        assertNull(op.await(500));
-    }
-
-    @Test
-    public void testPostDelayed() {
-        final WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op = new Op<>();
-        handler.post(1000, getRunnableForOp(op));
-        assertNotNull(op.await(2000));
-    }
-
-    @Test
-    public void testRemove() {
-        final WorkerHandler handler = WorkerHandler.get("handler");
-        final Op<Boolean> op = new Op<>();
-        Runnable runnable = getRunnableForOp(op);
-        handler.post(1000, runnable);
-        handler.remove(runnable);
-        assertNull(op.await(2000));
-    }
-
-    @Test
-    public void testGetters() {
-        final WorkerHandler handler = WorkerHandler.get("handler");
-        assertNotNull(handler.getExecutor());
-        assertNotNull(handler.getHandler());
-        assertNotNull(handler.getLooper());
-        assertNotNull(handler.getThread());
-    }
-
-    @Test
-    public void testExecutor() {
-        final WorkerHandler handler = WorkerHandler.get("handler");
-        Executor executor = handler.getExecutor();
-        final Op<Boolean> op = new Op<>();
-        executor.execute(getRunnableForOp(op));
-        waitOp(op);
-    }
-
-    @Test
-    public void testDestroy() {
-        final WorkerHandler handler = WorkerHandler.get("handler");
-        assertTrue(handler.getThread().isAlive());
-        handler.destroy();
-        WorkerHandler newHandler = WorkerHandler.get("handler");
-        assertNotSame(handler, newHandler);
-        assertTrue(newHandler.getThread().isAlive());
-        // Ensure old thread dies at some point.
-        try { handler.getThread().join(500); } catch (InterruptedException ignore) {}
-        assertFalse(handler.getThread().isAlive());
-    }
-
-    @Test
-    public void testDestroyAll() {
-        final WorkerHandler handler1 = WorkerHandler.get("handler1");
-        final WorkerHandler handler2 = WorkerHandler.get("handler2");
-        WorkerHandler.destroyAll();
-        WorkerHandler newHandler1 = WorkerHandler.get("handler1");
-        WorkerHandler newHandler2 = WorkerHandler.get("handler2");
-        assertNotSame(handler1, newHandler1);
-        assertNotSame(handler2, newHandler2);
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/markers/DefaultAutoFocusMarkerTest.java

@@ -1,104 +0,0 @@
-package com.otaliastudios.cameraview.markers;
-
-
-import android.graphics.PointF;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
-
-import androidx.test.annotation.UiThreadTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.Mockito;
-
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-
-public class DefaultAutoFocusMarkerTest extends BaseTest {
-
-    private DefaultAutoFocusMarker marker;
-
-    @Before
-    public void setUp() {
-        marker = new DefaultAutoFocusMarker();
-    }
-
-    @After
-    public void tearDown() {
-        marker = null;
-    }
-
-    @Test
-    public void testOnAttach() {
-        assertNull(marker.mContainer);
-        assertNull(marker.mFill);
-        ViewGroup container = new FrameLayout(getContext());
-        View result = marker.onAttach(getContext(), container);
-        assertNotNull(result);
-        assertNotNull(marker.mContainer);
-        assertNotNull(marker.mFill);
-    }
-
-    @UiThreadTest
-    @Test
-    public void testOnAutoFocusStart() {
-        View mockContainer = spy(new View(getContext()));
-        View mockFill = spy(new View(getContext()));
-        marker.mContainer = mockContainer;
-        marker.mFill = mockFill;
-        marker.onAutoFocusStart(AutoFocusTrigger.GESTURE, new PointF());
-        verify(mockContainer, atLeastOnce()).clearAnimation();
-        verify(mockFill, atLeastOnce()).clearAnimation();
-        verify(mockContainer, atLeastOnce()).animate();
-        verify(mockFill, atLeastOnce()).animate();
-    }
-
-    @UiThreadTest
-    @Test
-    public void testOnAutoFocusStart_fromMethod() {
-        View mockContainer = spy(new View(getContext()));
-        View mockFill = spy(new View(getContext()));
-        marker.mContainer = mockContainer;
-        marker.mFill = mockFill;
-        marker.onAutoFocusStart(AutoFocusTrigger.METHOD, new PointF());
-        verify(mockContainer, never()).clearAnimation();
-        verify(mockFill, never()).clearAnimation();
-        verify(mockContainer, never()).animate();
-        verify(mockFill, never()).animate();
-    }
-
-    @UiThreadTest
-    @Test
-    public void testOnAutoFocusEnd() {
-        View mockContainer = spy(new View(getContext()));
-        View mockFill = spy(new View(getContext()));
-        marker.mContainer = mockContainer;
-        marker.mFill = mockFill;
-        marker.onAutoFocusEnd(AutoFocusTrigger.GESTURE, true, new PointF());
-        verify(mockContainer, atLeastOnce()).animate();
-        verify(mockFill, atLeastOnce()).animate();
-    }
-
-    @UiThreadTest
-    @Test
-    public void testOnAutoFocusEnd_fromMethod() {
-        View mockContainer = spy(new View(getContext()));
-        View mockFill = spy(new View(getContext()));
-        marker.mContainer = mockContainer;
-        marker.mFill = mockFill;
-        marker.onAutoFocusEnd(AutoFocusTrigger.METHOD, true, new PointF());
-        verify(mockContainer, never()).animate();
-        verify(mockFill, never()).animate();
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/markers/MarkerLayoutTest.java

@@ -1,128 +0,0 @@
-package com.otaliastudios.cameraview.markers;
-
-
-import android.annotation.TargetApi;
-import android.content.Context;
-import android.graphics.PointF;
-import android.view.View;
-import android.view.ViewGroup;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.TestActivity;
-import com.otaliastudios.cameraview.tools.SdkExclude;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.Mockito;
-
-import androidx.annotation.NonNull;
-import androidx.test.rule.ActivityTestRule;
-
-import static org.mockito.ArgumentMatchers.anyFloat;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-/**
- * Not clear why, but for some reason on API 28+ the UiThreadTests here crash for an internal NPE
- * in FrameLayout.onMeasure.
- */
-@SdkExclude(minSdkVersion = 28)
-@TargetApi(17)
-public class MarkerLayoutTest extends BaseTest {
-
-
-    @Rule
-    public ActivityTestRule<TestActivity> rule = new ActivityTestRule<>(TestActivity.class);
-
-    private MarkerLayout markerLayout;
-    private AutoFocusMarker autoFocusMarker;
-
-    @Before
-    public void setUp() {
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                TestActivity a = rule.getActivity();
-                markerLayout = spy(new MarkerLayout(a));
-                a.inflate(markerLayout);
-                autoFocusMarker = spy(new DefaultAutoFocusMarker());
-            }
-        });
-    }
-
-    @Test
-    public void testOnMarker_callsOnAttach() {
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                markerLayout.onMarker(MarkerLayout.TYPE_AUTOFOCUS, autoFocusMarker);
-                Mockito.verify(autoFocusMarker, times(1)).onAttach(
-                        Mockito.any(Context.class),
-                        Mockito.eq(markerLayout));
-            }
-        });
-    }
-
-    @Test
-    public void testOnMarker_addsView() {
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                Assert.assertEquals(markerLayout.getChildCount(), 0);
-                markerLayout.onMarker(MarkerLayout.TYPE_AUTOFOCUS, autoFocusMarker);
-                Assert.assertEquals(markerLayout.getChildCount(), 1);
-            }
-        });
-    }
-
-    @Test
-    public void testOnMarker_removesView() {
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                markerLayout.onMarker(MarkerLayout.TYPE_AUTOFOCUS, autoFocusMarker);
-                Assert.assertEquals(markerLayout.getChildCount(), 1);
-                markerLayout.onMarker(MarkerLayout.TYPE_AUTOFOCUS, autoFocusMarker);
-                Assert.assertEquals(markerLayout.getChildCount(), 1);
-                markerLayout.onMarker(MarkerLayout.TYPE_AUTOFOCUS, null);
-                Assert.assertEquals(markerLayout.getChildCount(), 0);
-
-                Mockito.verify(autoFocusMarker, times(2)).onAttach(
-                        Mockito.any(Context.class),
-                        Mockito.eq(markerLayout));
-            }
-        });
-    }
-
-    @Test
-    public void testOnEvent() {
-        uiSync(new Runnable() {
-            @Override
-            public void run() {
-                final View mockView = spy(new View(getContext()));
-                // These fail, however it's not really needed.
-                // when(mockView.getWidth()).thenReturn(50);
-                // when(mockView.getHeight()).thenReturn(50);
-                AutoFocusMarker mockMarker = new AutoFocusMarker() {
-                    public void onAutoFocusStart(@NonNull AutoFocusTrigger trigger, @NonNull PointF point) { }
-                    public void onAutoFocusEnd(@NonNull AutoFocusTrigger trigger, boolean successful, @NonNull PointF point) { }
-
-                    @Override
-                    public View onAttach(@NonNull Context context, @NonNull ViewGroup container) {
-                        return mockView;
-                    }
-                };
-                markerLayout.onMarker(MarkerLayout.TYPE_AUTOFOCUS, mockMarker);
-                reset(mockView);
-                markerLayout.onEvent(MarkerLayout.TYPE_AUTOFOCUS, new PointF[]{new PointF(0, 0)});
-                verify(mockView, times(1)).clearAnimation();
-                verify(mockView, times(1)).setTranslationX(anyFloat());
-                verify(mockView, times(1)).setTranslationY(anyFloat());
-            }
-        });
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/markers/MarkerParserTest.java

@@ -1,79 +0,0 @@
-package com.otaliastudios.cameraview.markers;
-
-
-import android.content.Context;
-import android.content.res.TypedArray;
-import android.graphics.PointF;
-import android.view.View;
-import android.view.ViewGroup;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.annotation.StyleableRes;
-import androidx.arch.core.util.Function;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.R;
-import com.otaliastudios.cameraview.size.Size;
-import com.otaliastudios.cameraview.size.SizeSelectorParser;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static junit.framework.TestCase.assertNotNull;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class MarkerParserTest extends BaseTest {
-
-    @Test
-    public void testNullConstructor() {
-        TypedArray array = mock(TypedArray.class);
-        when(array.hasValue(R.styleable.CameraView_cameraAutoFocusMarker)).thenReturn(false);
-        when(array.getString(R.styleable.CameraView_cameraAutoFocusMarker)).thenReturn(null);
-        MarkerParser parser = new MarkerParser(array);
-        assertNull(parser.getAutoFocusMarker());
-    }
-    @Test
-    public void testConstructor() {
-        TypedArray array = mock(TypedArray.class);
-        when(array.hasValue(R.styleable.CameraView_cameraAutoFocusMarker)).thenReturn(true);
-        when(array.getString(R.styleable.CameraView_cameraAutoFocusMarker)).thenReturn(Marker.class.getName());
-        MarkerParser parser = new MarkerParser(array);
-        assertNotNull(parser.getAutoFocusMarker());
-        assertTrue(parser.getAutoFocusMarker() instanceof Marker);
-    }
-
-    public static class Marker implements AutoFocusMarker {
-
-        public Marker() { }
-
-        @Nullable
-        @Override
-        public View onAttach(@NonNull Context context, @NonNull ViewGroup container) {
-            return null;
-        }
-
-        @Override
-        public void onAutoFocusStart(@NonNull AutoFocusTrigger trigger, @NonNull PointF point) { }
-
-        @Override
-        public void onAutoFocusEnd(@NonNull AutoFocusTrigger trigger, boolean successful, @NonNull PointF point) { }
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/metering/MeteringRegionsTest.java

@@ -1,137 +0,0 @@
-package com.otaliastudios.cameraview.metering;
-
-
-import android.content.Context;
-import android.content.res.TypedArray;
-import android.graphics.PointF;
-import android.graphics.Rect;
-import android.graphics.RectF;
-import android.view.View;
-import android.view.ViewGroup;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.R;
-import com.otaliastudios.cameraview.markers.AutoFocusMarker;
-import com.otaliastudios.cameraview.markers.AutoFocusTrigger;
-import com.otaliastudios.cameraview.markers.MarkerParser;
-import com.otaliastudios.cameraview.size.Size;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-import java.util.List;
-
-import static junit.framework.TestCase.assertNotNull;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class MeteringRegionsTest extends BaseTest {
-
-    private final Size bounds = new Size(1000, 1000);
-
-    private void checkRegion(@NonNull MeteringRegion region, @NonNull PointF center, int weight) {
-        assertEquals(center.x, region.mRegion.centerX(), 0.01F);
-        assertEquals(center.y, region.mRegion.centerY(), 0.01F);
-        assertEquals(weight, region.mWeight);
-    }
-
-    @Test
-    public void testFromPoint() {
-        PointF center = new PointF(500, 500);
-        MeteringRegions regions = MeteringRegions.fromPoint(bounds, center);
-        assertEquals(2, regions.mRegions.size());
-        MeteringRegion first = regions.mRegions.get(0);
-        MeteringRegion second = regions.mRegions.get(1);
-        checkRegion(first, center, MeteringRegion.MAX_WEIGHT);
-        checkRegion(second, center,
-                Math.round(MeteringRegions.BLUR_FACTOR_WEIGHT * MeteringRegion.MAX_WEIGHT));
-    }
-
-    @Test
-    public void testFromArea() {
-        RectF area = new RectF(400, 400, 600, 600);
-        MeteringRegions regions = MeteringRegions.fromArea(bounds, area);
-        assertEquals(1, regions.mRegions.size());
-        MeteringRegion region = regions.mRegions.get(0);
-        checkRegion(region, new PointF(area.centerX(), area.centerY()), MeteringRegion.MAX_WEIGHT);
-    }
-
-    @Test
-    public void testFromArea_withBlur() {
-        RectF area = new RectF(400, 400, 600, 600);
-        MeteringRegions regions = MeteringRegions.fromArea(bounds, area,
-                MeteringRegion.MAX_WEIGHT, true);
-        assertEquals(2, regions.mRegions.size());
-        MeteringRegion first = regions.mRegions.get(0);
-        MeteringRegion second = regions.mRegions.get(1);
-        PointF center = new PointF(area.centerX(), area.centerY());
-        checkRegion(first, center, MeteringRegion.MAX_WEIGHT);
-        checkRegion(second, center,
-                Math.round(MeteringRegions.BLUR_FACTOR_WEIGHT * MeteringRegion.MAX_WEIGHT));
-    }
-
-    @Test
-    public void testTransform() {
-        MeteringTransform transform = mock(MeteringTransform.class);
-        when(transform.transformMeteringPoint(any(PointF.class))).then(new Answer<PointF>() {
-            @Override
-            public PointF answer(InvocationOnMock invocation) {
-                PointF in = invocation.getArgument(0);
-                // This will swap x and y coordinates
-                //noinspection SuspiciousNameCombination
-                return new PointF(in.y, in.x);
-            }
-        });
-        RectF area = new RectF(0, 0, 100, 500); // tall area
-        RectF expected = new RectF(0, 0, 500, 100); // wide area
-        MeteringRegions regions = MeteringRegions.fromArea(bounds, area);
-        MeteringRegions transformed = regions.transform(transform);
-        verify(transform, times(4)).transformMeteringPoint(any(PointF.class));
-        assertEquals(1, transformed.mRegions.size());
-        assertEquals(expected, transformed.mRegions.get(0).mRegion);
-    }
-
-
-    @Test
-    public void testGet() {
-        MeteringTransform<Integer> transform = new MeteringTransform<Integer>() {
-            @NonNull
-            @Override
-            public PointF transformMeteringPoint(@NonNull PointF point) {
-                return point;
-            }
-
-            @NonNull
-            @Override
-            public Integer transformMeteringRegion(@NonNull RectF region, int weight) {
-                return weight;
-            }
-        };
-        MeteringRegions regions = MeteringRegions.fromArea(bounds,
-                new RectF(400, 400, 600, 600),
-                900,
-                true);
-        assertEquals(2, regions.mRegions.size());
-        List<Integer> result = regions.get(1, transform);
-        assertEquals(1, result.size());
-        assertEquals(900, (int) result.get(0));
-    }
-
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/overlay/OverlayDrawerTest.java

@@ -1,78 +0,0 @@
-package com.otaliastudios.cameraview.overlay;
-
-
-import android.graphics.Canvas;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseEglTest;
-import com.otaliastudios.cameraview.internal.GlTextureDrawer;
-import com.otaliastudios.cameraview.size.Size;
-
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.Description;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class OverlayDrawerTest extends BaseEglTest {
-
-    @Test
-    public void testDraw() {
-        Overlay overlay = mock(Overlay.class);
-        OverlayDrawer drawer = new OverlayDrawer(overlay, new Size(WIDTH, HEIGHT));
-        drawer.draw(Overlay.Target.PICTURE_SNAPSHOT);
-        verify(overlay, times(1)).drawOn(
-                eq(Overlay.Target.PICTURE_SNAPSHOT),
-                any(Canvas.class));
-    }
-
-    @Test
-    public void testGetTransform() {
-        // We'll check that the transform is not all zeros, which is highly unlikely
-        // (the default transform should be the identity matrix)
-        OverlayDrawer drawer = new OverlayDrawer(mock(Overlay.class), new Size(WIDTH, HEIGHT));
-        drawer.draw(Overlay.Target.PICTURE_SNAPSHOT);
-        assertThat(drawer.getTransform(), new BaseMatcher<float[]>() {
-            public void describeTo(Description description) { }
-            public boolean matches(Object item) {
-                float[] array = (float[]) item;
-                for (float value : array) {
-                    if (value != 0.0F) return true;
-                }
-                return false;
-            }
-        });
-    }
-
-    @Test
-    public void testRender() {
-        OverlayDrawer drawer = new OverlayDrawer(mock(Overlay.class), new Size(WIDTH, HEIGHT));
-        drawer.mTextureDrawer = spy(drawer.mTextureDrawer);
-
-        drawer.draw(Overlay.Target.PICTURE_SNAPSHOT);
-        drawer.render(0L);
-        verify(drawer.mTextureDrawer, times(1)).draw(0L);
-    }
-
-    @Test
-    public void testRelease() {
-        OverlayDrawer drawer = new OverlayDrawer(mock(Overlay.class), new Size(WIDTH, HEIGHT));
-        GlTextureDrawer textureDrawer = spy(drawer.mTextureDrawer);
-        drawer.mTextureDrawer = textureDrawer;
-        drawer.release();
-        verify(textureDrawer, times(1)).release();
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/overlay/OverlayLayoutTest.java

@@ -1,177 +0,0 @@
-package com.otaliastudios.cameraview.overlay;
-
-
-import android.content.res.XmlResourceParser;
-import android.graphics.Canvas;
-import android.util.AttributeSet;
-import android.util.Xml;
-import android.view.View;
-import android.view.ViewGroup;
-
-import androidx.annotation.NonNull;
-import androidx.test.annotation.UiThreadTest;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.tools.SdkExclude;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.anyFloat;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class OverlayLayoutTest extends BaseTest {
-
-    private OverlayLayout overlayLayout;
-
-    @Before
-    public void setUp() {
-        overlayLayout = spy(new OverlayLayout(getContext()));
-    }
-
-    @After
-    public void tearDown() {
-        overlayLayout = null;
-    }
-
-    @Test
-    public void testIsOverlay_LayoutParams() {
-        ViewGroup.LayoutParams params;
-
-        params = new ViewGroup.LayoutParams(10, 10);
-        assertFalse(overlayLayout.isOverlay(params));
-
-        params = new OverlayLayout.LayoutParams(10, 10);
-        assertTrue(overlayLayout.isOverlay(params));
-    }
-
-    @Test
-    public void testIsOverlay_attributeSet() throws Exception {
-        int layout1 = com.otaliastudios.cameraview.test.R.layout.overlay;
-        int layout2 = com.otaliastudios.cameraview.test.R.layout.not_overlay;
-
-        AttributeSet set1 = getAttributeSet(layout1);
-        assertTrue(overlayLayout.isOverlay(set1));
-
-        AttributeSet set2 = getAttributeSet(layout2);
-        assertFalse(overlayLayout.isOverlay(set2));
-    }
-
-    @NonNull
-    private AttributeSet getAttributeSet(int layout) throws Exception {
-        // Get the attribute set in the correct state: use a parser and move to START_TAG
-        XmlResourceParser parser = getContext().getResources().getLayout(layout);
-        //noinspection StatementWithEmptyBody
-        while (parser.next() != XmlResourceParser.START_TAG) {}
-        return Xml.asAttributeSet(parser);
-    }
-
-    @Test
-    public void testLayoutParams_drawsOn() {
-        OverlayLayout.LayoutParams params = new OverlayLayout.LayoutParams(10, 10);
-
-        assertFalse(params.drawsOn(Overlay.Target.PREVIEW));
-        assertFalse(params.drawsOn(Overlay.Target.PICTURE_SNAPSHOT));
-        assertFalse(params.drawsOn(Overlay.Target.VIDEO_SNAPSHOT));
-
-        params.drawOnPreview = true;
-        assertTrue(params.drawsOn(Overlay.Target.PREVIEW));
-        params.drawOnPictureSnapshot = true;
-        assertTrue(params.drawsOn(Overlay.Target.PICTURE_SNAPSHOT));
-        params.drawOnVideoSnapshot = true;
-        assertTrue(params.drawsOn(Overlay.Target.VIDEO_SNAPSHOT));
-    }
-
-    @Test
-    public void testLayoutParams_toString() {
-        OverlayLayout.LayoutParams params = new OverlayLayout.LayoutParams(10, 10);
-        String string = params.toString();
-        assertTrue(string.contains("drawOnPreview"));
-        assertTrue(string.contains("drawOnPictureSnapshot"));
-        assertTrue(string.contains("drawOnVideoSnapshot"));
-    }
-
-    @Test
-    public void testDrawChild() {
-        Canvas canvas = new Canvas();
-        OverlayLayout.LayoutParams params = new OverlayLayout.LayoutParams(10, 10);
-        View child = new View(getContext());
-        child.setLayoutParams(params);
-        when(overlayLayout.doDrawChild(canvas, child, 0)).thenReturn(true);
-
-        overlayLayout.currentTarget = Overlay.Target.PREVIEW;
-        assertFalse(overlayLayout.drawChild(canvas, child, 0));
-        params.drawOnPreview = true;
-        assertTrue(overlayLayout.drawChild(canvas, child, 0));
-
-        overlayLayout.currentTarget = Overlay.Target.PICTURE_SNAPSHOT;
-        assertFalse(overlayLayout.drawChild(canvas, child, 0));
-        params.drawOnPictureSnapshot = true;
-        assertTrue(overlayLayout.drawChild(canvas, child, 0));
-
-        overlayLayout.currentTarget = Overlay.Target.VIDEO_SNAPSHOT;
-        assertFalse(overlayLayout.drawChild(canvas, child, 0));
-        params.drawOnVideoSnapshot = true;
-        assertTrue(overlayLayout.drawChild(canvas, child, 0));
-    }
-
-    @SdkExclude(minSdkVersion = 31) // spying views does not work properly on 31, should investigate
-    @UiThreadTest
-    @Test
-    public void testDraw() {
-        Canvas canvas = new Canvas();
-        when(overlayLayout.drawsOn(Overlay.Target.PREVIEW)).thenReturn(false);
-        overlayLayout.draw(canvas);
-        verify(overlayLayout, never()).drawOn(Overlay.Target.PREVIEW, canvas);
-
-        when(overlayLayout.drawsOn(Overlay.Target.PREVIEW)).thenReturn(true);
-        overlayLayout.draw(canvas);
-        verify(overlayLayout, times(1)).drawOn(Overlay.Target.PREVIEW, canvas);
-    }
-
-    @SdkExclude(minSdkVersion = 31) // spying views does not work properly on 31, should investigate
-    @UiThreadTest
-    @Test
-    public void testDrawOn() {
-        Canvas canvas = spy(new Canvas());
-        View child = new View(getContext());
-        OverlayLayout.LayoutParams params = new OverlayLayout.LayoutParams(10, 10);
-        params.drawOnPreview = true;
-        params.drawOnPictureSnapshot = true;
-        params.drawOnVideoSnapshot = true;
-        overlayLayout.addView(child, params);
-
-        overlayLayout.drawOn(Overlay.Target.PREVIEW, canvas);
-        verify(canvas, never()).scale(anyFloat(), anyFloat());
-        verify(overlayLayout, times(1)).doDrawChild(eq(canvas), eq(child), anyLong());
-        reset(canvas);
-        reset(overlayLayout);
-
-        overlayLayout.drawOn(Overlay.Target.PICTURE_SNAPSHOT, canvas);
-        verify(canvas, times(1)).scale(anyFloat(), anyFloat());
-        verify(overlayLayout, times(1)).doDrawChild(eq(canvas), eq(child), anyLong());
-        reset(canvas);
-        reset(overlayLayout);
-
-        overlayLayout.drawOn(Overlay.Target.VIDEO_SNAPSHOT, canvas);
-        verify(canvas, times(1)).scale(anyFloat(), anyFloat());
-        verify(overlayLayout, times(1)).doDrawChild(eq(canvas), eq(child), anyLong());
-        reset(canvas);
-        reset(overlayLayout);
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/picture/PictureRecorderTest.java

@@ -1,43 +0,0 @@
-package com.otaliastudios.cameraview.picture;
-
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.PictureResult;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mockito;
-
-import java.lang.reflect.Constructor;
-
-import static org.junit.Assert.assertNull;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class PictureRecorderTest extends BaseTest {
-
-    @Test
-    public void testRecorder() throws Exception {
-        PictureResult.Stub result = createStub();
-        PictureRecorder.PictureResultListener listener = Mockito.mock(PictureRecorder.PictureResultListener.class);
-        PictureRecorder recorder = new PictureRecorder(result, listener) {
-            public void take() {
-                dispatchResult();
-            }
-        };
-        recorder.take();
-        Mockito.verify(listener, Mockito.times(1)).onPictureResult(result, null);
-        assertNull(recorder.mListener);
-        assertNull(recorder.mResult);
-    }
-
-    private PictureResult.Stub createStub() throws Exception {
-        Constructor<PictureResult.Stub> constructor = PictureResult.Stub.class.getDeclaredConstructor();
-        constructor.setAccessible(true);
-        return constructor.newInstance();
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/preview/GlCameraPreviewTest.java

@@ -1,43 +0,0 @@
-package com.otaliastudios.cameraview.preview;
-
-
-import android.content.Context;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-import android.view.ViewGroup;
-
-import com.otaliastudios.cameraview.filter.Filter;
-import com.otaliastudios.cameraview.filter.Filters;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import static org.junit.Assert.assertEquals;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class GlCameraPreviewTest extends CameraPreviewTest<GlCameraPreview> {
-
-    @Override
-    protected GlCameraPreview createPreview(Context context, ViewGroup parent) {
-        return new GlCameraPreview(context, parent);
-    }
-
-    @Override
-    protected float getCropScaleY() {
-        return 1F / preview.mCropScaleY;
-    }
-
-    @Override
-    protected float getCropScaleX() {
-        return 1F / preview.mCropScaleX;
-    }
-
-    @Test
-    public void testSetFilter() {
-        Filter filter = Filters.BLACK_AND_WHITE.newInstance();
-        preview.setFilter(filter);
-        assertEquals(filter, preview.getCurrentFilter());
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/preview/MockCameraPreview.java

@@ -1,63 +0,0 @@
-package com.otaliastudios.cameraview.preview;
-
-
-import android.content.Context;
-import androidx.annotation.NonNull;
-
-import android.view.View;
-import android.view.ViewGroup;
-
-import com.otaliastudios.cameraview.filter.Filter;
-import com.otaliastudios.cameraview.preview.CameraPreview;
-
-public class MockCameraPreview extends CameraPreview<View, Void> implements FilterCameraPreview {
-
-    public MockCameraPreview(Context context, ViewGroup parent) {
-        super(context, parent);
-    }
-
-    private View rootView;
-    private Filter filter;
-
-    @Override
-    public boolean supportsCropping() {
-        return true;
-    }
-
-    @NonNull
-    @Override
-    protected View onCreateView(@NonNull Context context, @NonNull ViewGroup parent) {
-        rootView = new View(context);
-        return rootView;
-    }
-
-    @NonNull
-    @Override
-    public Class<Void> getOutputClass() {
-        return null;
-    }
-
-    @NonNull
-    @Override
-    public Void getOutput() {
-        return null;
-    }
-
-
-    @NonNull
-    @Override
-    public View getRootView() {
-        return rootView;
-    }
-
-    @Override
-    public void setFilter(@NonNull Filter filter) {
-        this.filter = filter;
-    }
-
-    @NonNull
-    @Override
-    public Filter getCurrentFilter() {
-        return filter;
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/preview/SurfaceCameraPreviewTest.java

@@ -1,30 +0,0 @@
-package com.otaliastudios.cameraview.preview;
-
-
-import android.content.Context;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-import android.view.ViewGroup;
-
-import org.junit.runner.RunWith;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class SurfaceCameraPreviewTest extends CameraPreviewTest<SurfaceCameraPreview> {
-
-    @Override
-    protected SurfaceCameraPreview createPreview(Context context, ViewGroup parent) {
-        return new SurfaceCameraPreview(context, parent);
-    }
-
-    @Override
-    protected float getCropScaleX() {
-        return 1F;
-    }
-
-    @Override
-    protected float getCropScaleY() {
-        return 1F;
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/size/SizeSelectorParserTest.java

@@ -1,211 +0,0 @@
-package com.otaliastudios.cameraview.size;
-
-
-import android.content.res.TypedArray;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.StyleableRes;
-import androidx.arch.core.util.Function;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.R;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class SizeSelectorParserTest extends BaseTest {
-
-    private MockTypedArray input;
-    private List<Size> sizes = Arrays.asList(
-            new Size(100, 200),
-            new Size(150, 300),
-            new Size(600, 900),
-            new Size(600, 600),
-            new Size(1600, 900),
-            new Size(30, 40),
-            new Size(40, 30),
-            new Size(2000, 4000)
-    );
-
-    @Before
-    public void setUp() {
-        input = new MockTypedArray();
-    }
-
-    @After
-    public void tearDown() {
-        input = null;
-    }
-
-    private void doAssert(@NonNull Function<List<Size>, Void> assertions) {
-        SizeSelectorParser parser = new SizeSelectorParser(input.array);
-        assertions.apply(parser.getPictureSizeSelector().select(sizes));
-        assertions.apply(parser.getVideoSizeSelector().select(sizes));
-    }
-
-    @Test
-    public void testWidth() {
-        input.setMinWidth(1500);
-        input.setMaxWidth(1700);
-        doAssert(new Function<List<Size>, Void>() {
-            @Override
-            public Void apply(List<Size> input) {
-                assertEquals(1, input.size());
-                assertEquals(new Size(1600, 900), input.get(0));
-                return null;
-            }
-        });
-    }
-
-    @Test
-    public void testHeight() {
-        input.setMinHeight(25);
-        input.setMaxHeight(35);
-        doAssert(new Function<List<Size>, Void>() {
-            @Override
-            public Void apply(List<Size> input) {
-                assertEquals(1, input.size());
-                assertEquals(new Size(40, 30), input.get(0));
-                return null;
-            }
-        });
-    }
-
-    @Test
-    public void testArea() {
-        input.setMinArea(30 * 30);
-        input.setMaxArea(40 * 40);
-        doAssert(new Function<List<Size>, Void>() {
-            @Override
-            public Void apply(List<Size> input) {
-                assertEquals(2, input.size());
-                assertTrue(input.contains(new Size(40, 30)));
-                assertTrue(input.contains(new Size(30, 40)));
-                return null;
-            }
-        });
-    }
-
-    @Test
-    public void testSmallest() {
-        input.setSmallest(true);
-        doAssert(new Function<List<Size>, Void>() {
-            @Override
-            public Void apply(List<Size> input) {
-                assertEquals(sizes.size(), input.size());
-                Size first = input.get(0);
-                assertEquals(30 * 40, first.getWidth() * first.getHeight());
-                return null;
-            }
-        });
-    }
-
-    @Test
-    public void testBiggest() {
-        input.setBiggest(true);
-        doAssert(new Function<List<Size>, Void>() {
-            @Override
-            public Void apply(List<Size> input) {
-                assertEquals(sizes.size(), input.size());
-                assertEquals(new Size(2000, 4000), input.get(0));
-                return null;
-            }
-        });
-    }
-
-    @Test
-    public void testAspectRatio() {
-        input.setAspectRatio("16:9");
-        doAssert(new Function<List<Size>, Void>() {
-            @Override
-            public Void apply(List<Size> input) {
-                assertEquals(1, input.size());
-                assertEquals(new Size(1600, 900), input.get(0));
-                return null;
-            }
-        });
-    }
-
-    @SuppressWarnings("SameParameterValue")
-    private class MockTypedArray {
-        private TypedArray array = mock(TypedArray.class);
-
-        private void setIntValue(@StyleableRes int index, int value) {
-            when(array.hasValue(index)).thenReturn(true);
-            when(array.getInteger(eq(index), anyInt())).thenReturn(value);
-        }
-
-        private void setBooleanValue(@StyleableRes int index, boolean value) {
-            when(array.hasValue(index)).thenReturn(true);
-            when(array.getBoolean(eq(index), anyBoolean())).thenReturn(value);
-        }
-
-        private void setStringValue(@StyleableRes int index, @NonNull String value) {
-            when(array.hasValue(index)).thenReturn(true);
-            when(array.getString(index)).thenReturn(value);
-        }
-
-        private void setMinWidth(int value) {
-            setIntValue(R.styleable.CameraView_cameraPictureSizeMinWidth, value);
-            setIntValue(R.styleable.CameraView_cameraVideoSizeMinWidth, value);
-        }
-
-        private void setMaxWidth(int value) {
-            setIntValue(R.styleable.CameraView_cameraPictureSizeMaxWidth, value);
-            setIntValue(R.styleable.CameraView_cameraVideoSizeMaxWidth, value);
-        }
-
-        private void setMinHeight(int value) {
-            setIntValue(R.styleable.CameraView_cameraPictureSizeMinHeight, value);
-            setIntValue(R.styleable.CameraView_cameraVideoSizeMinHeight, value);
-        }
-
-        private void setMaxHeight(int value) {
-            setIntValue(R.styleable.CameraView_cameraPictureSizeMaxHeight, value);
-            setIntValue(R.styleable.CameraView_cameraVideoSizeMaxHeight, value);
-        }
-
-        private void setMinArea(int value) {
-            setIntValue(R.styleable.CameraView_cameraPictureSizeMinArea, value);
-            setIntValue(R.styleable.CameraView_cameraVideoSizeMinArea, value);
-        }
-
-        private void setMaxArea(int value) {
-            setIntValue(R.styleable.CameraView_cameraPictureSizeMaxArea, value);
-            setIntValue(R.styleable.CameraView_cameraVideoSizeMaxArea, value);
-        }
-
-        private void setSmallest(boolean value) {
-            setBooleanValue(R.styleable.CameraView_cameraPictureSizeSmallest, value);
-            setBooleanValue(R.styleable.CameraView_cameraVideoSizeSmallest, value);
-        }
-
-        private void setBiggest(boolean value) {
-            setBooleanValue(R.styleable.CameraView_cameraPictureSizeBiggest, value);
-            setBooleanValue(R.styleable.CameraView_cameraVideoSizeBiggest, value);
-        }
-
-        private void setAspectRatio(@NonNull String value) {
-            setStringValue(R.styleable.CameraView_cameraPictureSizeAspectRatio, value);
-            setStringValue(R.styleable.CameraView_cameraVideoSizeAspectRatio, value);
-        }
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/tools/Emulator.java

@@ -1,12 +0,0 @@
-package com.otaliastudios.cameraview.tools;
-
-import android.os.Build;
-
-public class Emulator {
-    public static boolean isEmulator() {
-        // From Android's RequiresDeviceFilter
-        return Build.HARDWARE.equals("goldfish")
-                || Build.HARDWARE.equals("ranchu")
-                || Build.HARDWARE.equals("gce_x86");
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/tools/Op.java

@@ -1,149 +0,0 @@
-package com.otaliastudios.cameraview.tools;
-
-import androidx.annotation.NonNull;
-
-import com.google.android.gms.tasks.OnSuccessListener;
-import com.google.android.gms.tasks.Task;
-import com.otaliastudios.cameraview.controls.Control;
-
-import org.mockito.Mockito;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-import org.mockito.stubbing.Stubber;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
-/**
- * A naive implementation of {@link java.util.concurrent.CountDownLatch}
- * to help in testing.
- */
-public class Op<T> {
-
-    public class Controller {
-        private int mToBeIgnored;
-
-        private Controller() { }
-
-        /** Op owner method: notifies the action started. */
-        public void start() {
-            if (!isListening()) mToBeIgnored++;
-        }
-
-        /** Op owner method: notifies the action ended. */
-        public void end(T result) {
-            if (mToBeIgnored > 0) {
-                mToBeIgnored--;
-                return;
-            }
-
-            if (isListening()) { // Should be always true.
-                mResult = result;
-                mLatch.countDown();
-            }
-        }
-
-        public void from(@NonNull Task<T> task) {
-            start();
-            task.addOnSuccessListener(new OnSuccessListener<T>() {
-                @Override
-                public void onSuccess(T result) {
-                    end(result);
-                }
-            });
-        }
-
-        @NonNull
-        public Stubber from(final int invocationArgument) {
-            return Mockito.doAnswer(new Answer() {
-                @Override
-                public Object answer(InvocationOnMock invocation) {
-                    //noinspection unchecked
-                    T o = (T) invocation.getArguments()[invocationArgument];
-                    start();
-                    end(o);
-                    return null;
-                }
-            });
-        }
-    }
-
-    private CountDownLatch mLatch;
-    private Controller mController = new Controller();
-    private T mResult;
-
-    /**
-     * Listeners should:
-     * - call {@link #listen()} to notify they are interested in the next action
-     * - call {@link #await()} to know when the action is performed.
-     *
-     * Op owners should:
-     * - call {@link Controller#start()} when task started
-     * - call {@link Controller#end(Object)} when task ends
-     */
-    public Op() {
-        this(true);
-    }
-
-    public Op(boolean startListening) {
-        if (startListening) listen();
-    }
-
-    public Op(@NonNull Task<T> task) {
-        listen();
-        controller().from(task);
-    }
-
-    private boolean isListening() {
-        return mLatch != null;
-    }
-
-    /**
-     * Listener method: notifies we are interested in the next action.
-     */
-    public void listen() {
-        if (isListening()) throw new RuntimeException("Should not happen.");
-        mResult = null;
-        mLatch = new CountDownLatch(1);
-    }
-
-    /**
-     * Listener method: waits for next task action to end.
-     * @param millis milliseconds
-     * @return the action result
-     */
-    public T await(long millis) {
-        return await(millis, TimeUnit.MILLISECONDS);
-    }
-
-    /**
-     * Listener method: waits 1 minute for next task action to end.
-     * @return the action result
-     */
-    public T await() {
-        return await(1, TimeUnit.MINUTES);
-    }
-
-    /**
-     * Listener method: waits for next task action to end.
-     * @param time time
-     * @param unit the time unit
-     * @return the action result
-     */
-    private T await(long time, @NonNull TimeUnit unit) {
-        try {
-            mLatch.await(time, unit);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        T result = mResult;
-        mResult = null;
-        mLatch = null;
-        return result;
-    }
-
-    @NonNull
-    public Controller controller() {
-        return mController;
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/tools/Retry.java

@@ -1,9 +0,0 @@
-package com.otaliastudios.cameraview.tools;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Retry {
-    boolean emulatorOnly() default false;
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/tools/RetryRule.java

@@ -1,52 +0,0 @@
-package com.otaliastudios.cameraview.tools;
-
-import android.os.Build;
-
-import com.otaliastudios.cameraview.CameraLogger;
-
-import org.junit.rules.TestRule;
-import org.junit.runner.Description;
-import org.junit.runners.model.Statement;
-
-import java.util.concurrent.atomic.AtomicInteger;
-
-public class RetryRule implements TestRule {
-
-    private final static String TAG = RetryRule.class.getSimpleName();
-    private final static CameraLogger LOG = CameraLogger.create(TAG);
-
-    private AtomicInteger retries;
-
-    public RetryRule(int retries) {
-        this.retries = new AtomicInteger(retries);
-    }
-
-    @Override
-    public Statement apply(final Statement base, final Description description) {
-        return new Statement() {
-            @Override
-            public void evaluate() throws Throwable {
-                Retry retry = description.getAnnotation(Retry.class);
-                if (retry == null || retry.emulatorOnly() && !Emulator.isEmulator()) {
-                    base.evaluate();
-                } else {
-                    Throwable caught = null;
-                    while (retries.getAndDecrement() > 0) {
-                        try {
-                            base.evaluate();
-                            return;
-                        } catch (Throwable throwable) {
-                            LOG.e("[RETRY] Test failed.", retries.get(),
-                                    "retries available...");
-                            LOG.e("*******************************************************");
-                            caught = throwable;
-                        }
-                    }
-                    if (caught != null) {
-                        throw caught;
-                    }
-                }
-            }
-        };
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/tools/SdkExclude.java

@@ -1,20 +0,0 @@
-package com.otaliastudios.cameraview.tools;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Like {@link androidx.test.filters.SdkSuppress}, but negative.
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.TYPE, ElementType.METHOD})
-public @interface SdkExclude {
-    /** The minimum API level to drop (inclusive) */
-    int minSdkVersion() default 1;
-    /** The maximum API level to drop (inclusive) */
-    int maxSdkVersion() default Integer.MAX_VALUE;
-    /** Whether this filter only applies to emulators */
-    boolean emulatorOnly() default false;
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/tools/SdkExcludeFilter.java

@@ -1,47 +0,0 @@
-package com.otaliastudios.cameraview.tools;
-
-
-import android.os.Build;
-
-import androidx.annotation.Nullable;
-import androidx.test.internal.runner.filters.ParentFilter;
-
-import org.junit.runner.Description;
-
-/**
- * Filter for {@link SdkExclude}, based on
- * {@link androidx.test.internal.runner.TestRequestBuilder}'s SdkSuppressFilter.
- */
-public class SdkExcludeFilter extends ParentFilter {
-
-    protected boolean evaluateTest(Description description) {
-        SdkExclude annotation = getAnnotationForTest(description);
-        if (annotation != null) {
-            if ((!annotation.emulatorOnly() || Emulator.isEmulator())
-                    && Build.VERSION.SDK_INT >= annotation.minSdkVersion()
-                    && Build.VERSION.SDK_INT <= annotation.maxSdkVersion()) {
-                return false; // exclude the test
-            }
-            return true; // run the test
-        }
-        return true; // no annotation, run the test
-    }
-
-    @Nullable
-    private SdkExclude getAnnotationForTest(Description description) {
-        final SdkExclude s = description.getAnnotation(SdkExclude.class);
-        if (s != null) {
-            return s;
-        }
-        final Class<?> testClass = description.getTestClass();
-        if (testClass != null) {
-            return testClass.getAnnotation(SdkExclude.class);
-        }
-        return null;
-    }
-
-    @Override
-    public String describe() {
-        return "Skip tests annotated with SdkExclude";
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/tools/SdkInclude.java

@@ -1,20 +0,0 @@
-package com.otaliastudios.cameraview.tools;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Like {@link androidx.test.filters.SdkSuppress}, but with emulatorOnly().
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.TYPE, ElementType.METHOD})
-public @interface SdkInclude {
-    /** The minimum API level to run (inclusive) */
-    int minSdkVersion() default 1;
-    /** The maximum API level to run (inclusive) */
-    int maxSdkVersion() default Integer.MAX_VALUE;
-    /** Whether this filter only applies to emulators */
-    boolean emulatorOnly() default false;
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/tools/SdkIncludeFilter.java

@@ -1,47 +0,0 @@
-package com.otaliastudios.cameraview.tools;
-
-
-import android.os.Build;
-
-import androidx.annotation.Nullable;
-import androidx.test.internal.runner.filters.ParentFilter;
-
-import org.junit.runner.Description;
-
-/**
- * Filter for {@link SdkInclude}, based on
- * {@link androidx.test.internal.runner.TestRequestBuilder}'s SdkSuppressFilter.
- */
-public class SdkIncludeFilter extends ParentFilter {
-
-    protected boolean evaluateTest(Description description) {
-        SdkInclude annotation = getAnnotationForTest(description);
-        if (annotation != null) {
-            if ((!annotation.emulatorOnly() || Emulator.isEmulator())
-                    && Build.VERSION.SDK_INT >= annotation.minSdkVersion()
-                    && Build.VERSION.SDK_INT <= annotation.maxSdkVersion()) {
-                return true; // run the test
-            }
-            return false; // drop the test
-        }
-        return true; // no annotation, run the test
-    }
-
-    @Nullable
-    private SdkInclude getAnnotationForTest(Description description) {
-        final SdkInclude s = description.getAnnotation(SdkInclude.class);
-        if (s != null) {
-            return s;
-        }
-        final Class<?> testClass = description.getTestClass();
-        if (testClass != null) {
-            return testClass.getAnnotation(SdkInclude.class);
-        }
-        return null;
-    }
-
-    @Override
-    public String describe() {
-        return "Skip tests annotated with SdkInclude";
-    }
-}

cameraview/src/androidTest/java/com/otaliastudios/cameraview/video/VideoRecorderTest.java

@@ -1,52 +0,0 @@
-package com.otaliastudios.cameraview.video;
-
-
-import com.otaliastudios.cameraview.BaseTest;
-import com.otaliastudios.cameraview.VideoResult;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.filters.SmallTest;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mockito;
-
-import java.lang.reflect.Constructor;
-
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class VideoRecorderTest extends BaseTest {
-
-    @Test
-    public void testRecorder() throws Exception {
-        VideoResult.Stub result = createStub();
-        VideoRecorder.VideoResultListener listener = Mockito.mock(VideoRecorder.VideoResultListener.class);
-        VideoRecorder recorder = new VideoRecorder(listener) {
-            @Override
-            protected void onStart() {
-                dispatchVideoRecordingStart();
-            }
-
-            @Override
-            protected void onStop(boolean isCameraShutdown) {
-                dispatchVideoRecordingEnd();
-                dispatchResult();
-            }
-        };
-        recorder.start(result);
-        Mockito.verify(listener,Mockito.times(1) )
-                .onVideoRecordingStart();
-        recorder.stop(false);
-        Mockito.verify(listener, Mockito.times(1))
-                .onVideoRecordingEnd();
-        Mockito.verify(listener, Mockito.times(1))
-                .onVideoResult(result, null);
-    }
-
-    private VideoResult.Stub createStub() throws Exception {
-        Constructor<VideoResult.Stub> constructor = VideoResult.Stub.class.getDeclaredConstructor();
-        constructor.setAccessible(true);
-        return constructor.newInstance();
-    }
-}

cameraview/src/androidTest/res/layout/not_overlay.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"/>

cameraview/src/androidTest/res/layout/overlay.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    app:layout_drawOnPreview="true"
-    app:layout_drawOnPictureSnapshot="true"
-    app:layout_drawOnVideoSnapshot="true"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"/>

cameraview/src/main/AndroidManifest.xml

@@ -1,5 +1,4 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
     package="com.otaliastudios.cameraview">
 
     <uses-permission android:name="android.permission.CAMERA" />
@@ -21,8 +20,6 @@
         android:name="android.hardware.microphone"
         android:required="false"/>
 
-    <uses-sdk tools:overrideLibrary="com.otaliastudios.opengl" />
-
     <application/>
 
 </manifest>